geode-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (GEODE-3149) Protobuf protocol module will throw exceptions on some input
Date Wed, 15 Nov 2017 05:58:19 GMT

    [ https://issues.apache.org/jira/browse/GEODE-3149?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16252984#comment-16252984 ] 

ASF GitHub Bot commented on GEODE-3149:
---------------------------------------

pivotal-jbarrett closed pull request #149: GEODE-3149: Code cleanup
URL: https://github.com/apache/geode-native/pull/149
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/clicache/src/AttributesFactory.cpp b/clicache/src/AttributesFactory.cpp
index 05559a7c..1627150f 100644
--- a/clicache/src/AttributesFactory.cpp
+++ b/clicache/src/AttributesFactory.cpp
@@ -65,7 +65,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesFactory<TKey, TValue>::SetCacheLoader( ICacheLoader<TKey, TValue>^ cacheLoader )
       {
-        native::CacheLoaderPtr loaderptr;
+        std::shared_ptr<native::CacheLoader> loaderptr;
         if ( cacheLoader != nullptr ) {
           CacheLoaderGeneric<TKey, TValue>^ clg = gcnew CacheLoaderGeneric<TKey, TValue>();
           clg->SetCacheLoader(cacheLoader);
@@ -85,7 +85,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesFactory<TKey, TValue>::SetCacheWriter( ICacheWriter<TKey, TValue>^ cacheWriter )
       {
-        native::CacheWriterPtr writerptr;
+        std::shared_ptr<native::CacheWriter> writerptr;
         if ( cacheWriter != nullptr ) {
           CacheWriterGeneric<TKey, TValue>^ cwg = gcnew CacheWriterGeneric<TKey, TValue>();
           cwg->SetCacheWriter(cacheWriter);
@@ -105,7 +105,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesFactory<TKey, TValue>::SetCacheListener( ICacheListener<TKey, TValue>^ cacheListener )
       {
-        native::CacheListenerPtr listenerptr;
+        std::shared_ptr<native::CacheListener> listenerptr;
         if ( cacheListener != nullptr ) {
           CacheListenerGeneric<TKey, TValue>^ clg = gcnew CacheListenerGeneric<TKey, TValue>();
           clg->SetCacheListener(cacheListener);
@@ -125,7 +125,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesFactory<TKey, TValue>::SetPartitionResolver( IPartitionResolver<TKey, TValue>^ partitionresolver )
       {
-        native::PartitionResolverPtr resolverptr;
+        std::shared_ptr<native::PartitionResolver> resolverptr;
         if ( partitionresolver != nullptr ) {
           Client::IFixedPartitionResolver<TKey, TValue>^ resolver = 
             dynamic_cast<Client::IFixedPartitionResolver<TKey, TValue>^>(partitionresolver);
@@ -278,7 +278,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesFactory<TKey, TValue>::SetPersistenceManager(IPersistenceManager<TKey, TValue>^ persistenceManager, Properties<String^, String^>^ config )
       {
-        native::PersistenceManagerPtr persistenceManagerptr;
+        std::shared_ptr<native::PersistenceManager> persistenceManagerptr;
         if ( persistenceManager != nullptr ) {
           PersistenceManagerGeneric<TKey, TValue>^ clg = gcnew PersistenceManagerGeneric<TKey, TValue>();
           clg->SetPersistenceManager(persistenceManager);
@@ -469,7 +469,7 @@ namespace Apache
 
           try
           {
-            native::RegionAttributesPtr nativeptr = m_nativeptr->get()->createRegionAttributes();
+            std::shared_ptr<native::RegionAttributes> nativeptr = m_nativeptr->get()->createRegionAttributes();
             return Apache::Geode::Client::RegionAttributes<TKey, TValue>::Create(nativeptr);
           }
           finally
diff --git a/clicache/src/AttributesMutator.cpp b/clicache/src/AttributesMutator.cpp
index 92a16053..aa106ca1 100644
--- a/clicache/src/AttributesMutator.cpp
+++ b/clicache/src/AttributesMutator.cpp
@@ -167,7 +167,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesMutator<TKey, TValue>::SetCacheListener( ICacheListener<TKey, TValue>^ cacheListener )
       {
-        native::CacheListenerPtr listenerptr;
+        std::shared_ptr<native::CacheListener> listenerptr;
         if (cacheListener != nullptr)
         {
           auto clg = gcnew CacheListenerGeneric<TKey, TValue>();
@@ -195,7 +195,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesMutator<TKey, TValue>::SetCacheLoader( ICacheLoader<TKey, TValue>^ cacheLoader )
       {
-        native::CacheLoaderPtr loaderptr;
+        std::shared_ptr<native::CacheLoader> loaderptr;
         if (cacheLoader != nullptr)
         {
           auto clg = gcnew CacheLoaderGeneric<TKey, TValue>();
@@ -223,7 +223,7 @@ namespace Apache
       generic<class TKey, class TValue>
       void AttributesMutator<TKey, TValue>::SetCacheWriter( ICacheWriter<TKey, TValue>^ cacheWriter )
       {
-        native::CacheWriterPtr writerptr;
+        std::shared_ptr<native::CacheWriter> writerptr;
         if (cacheWriter != nullptr)
         {
           auto cwg = gcnew CacheWriterGeneric<TKey, TValue>();
diff --git a/clicache/src/AttributesMutator.hpp b/clicache/src/AttributesMutator.hpp
index 3421ef72..443cdfc5 100644
--- a/clicache/src/AttributesMutator.hpp
+++ b/clicache/src/AttributesMutator.hpp
@@ -244,7 +244,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static AttributesMutator<TKey, TValue>^ Create( native::AttributesMutatorPtr nativeptr )
+        inline static AttributesMutator<TKey, TValue>^ Create( std::shared_ptr<native::AttributesMutator> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew AttributesMutator<TKey, TValue>( nativeptr );
@@ -257,7 +257,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline AttributesMutator<TKey, TValue>( native::AttributesMutatorPtr nativeptr )
+        inline AttributesMutator<TKey, TValue>( std::shared_ptr<native::AttributesMutator> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::AttributesMutator>(nativeptr);
         }
diff --git a/clicache/src/Cache.cpp b/clicache/src/Cache.cpp
index d15c25bd..d7a11110 100644
--- a/clicache/src/Cache.cpp
+++ b/clicache/src/Cache.cpp
@@ -48,7 +48,7 @@ namespace Apache
     {
       namespace native = apache::geode::client;
 
-      Cache::Cache(native::CachePtr nativeptr)
+      Cache::Cache(std::shared_ptr<native::Cache> nativeptr)
       {
         m_nativeptr = gcnew native_shared_ptr<native::Cache>(nativeptr);
         m_pdxTypeRegistry = gcnew Apache::Geode::Client::Internal::PdxTypeRegistry(this);
@@ -181,7 +181,7 @@ namespace Apache
       generic<class TKey, class TValue>
       array<Client::IRegion<TKey, TValue>^>^ Cache::RootRegions( )
       {
-        apache::geode::client::VectorOfRegion vrr;
+        std::vector<std::shared_ptr<apache::geode::client::Region>> vrr;
         try
         {
 			vrr = m_nativeptr->get()->rootRegions( );
@@ -195,7 +195,7 @@ namespace Apache
 
         for( System::Int32 index = 0; index < vrr.size( ); index++ )
         {
-          apache::geode::client::RegionPtr& nativeptr( vrr[ index ] );
+          std::shared_ptr<apache::geode::client::Region>& nativeptr( vrr[ index ] );
           rootRegions[ index ] = Client::Region<TKey, TValue>::Create( nativeptr );
         }
         return rootRegions;
diff --git a/clicache/src/Cache.hpp b/clicache/src/Cache.hpp
index 20edfc27..78b53ed8 100644
--- a/clicache/src/Cache.hpp
+++ b/clicache/src/Cache.hpp
@@ -178,7 +178,7 @@ namespace Apache
         /// </summary>
         /// <remarks>
         /// If Pool attached with Region is in multiusersecure mode then don't use return instance of region as no credential are attached with this instance.
-        /// Get region from RegionService instance of Cache.<see cref="Cache.CreateAuthenticatedView(PropertiesPtr)" />.
+        /// Get region from RegionService instance of Cache.<see cref="Cache.CreateAuthenticatedView(std::shared_ptr<PropertiesPtr>)" />.
         /// </remarks>
         /// <param name="path">the pathname of the region</param>
         /// <returns>the region</returns>
@@ -288,7 +288,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Cache^ Create(native::CachePtr nativeptr)
+        inline static Cache^ Create(std::shared_ptr<native::Cache> nativeptr)
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew Cache( nativeptr );
@@ -310,7 +310,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        Cache(native::CachePtr nativeptr);
+        Cache(std::shared_ptr<native::Cache> nativeptr);
 
         native_shared_ptr<native::Cache>^ m_nativeptr;
 
diff --git a/clicache/src/CacheFactory.cpp b/clicache/src/CacheFactory.cpp
index c95e6a7a..f2f63000 100644
--- a/clicache/src/CacheFactory.cpp
+++ b/clicache/src/CacheFactory.cpp
@@ -60,7 +60,7 @@ namespace Apache
 				bool pdxIgnoreUnreadFields = false;
         bool pdxReadSerialized = false;
 				bool appDomainEnable = false; 
-        native::CachePtr nativeCache = nullptr;
+        std::shared_ptr<native::Cache> nativeCache = nullptr;
         _GF_MG_EXCEPTION_TRY2
           //msclr::lock lockInstance(m_singletonSync);
           DistributedSystem::acquireDisconnectLock();
diff --git a/clicache/src/CacheFactory.hpp b/clicache/src/CacheFactory.hpp
index 5c188284..3af6792e 100644
--- a/clicache/src/CacheFactory.hpp
+++ b/clicache/src/CacheFactory.hpp
@@ -169,7 +169,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheFactory(native::CacheFactoryPtr nativeptr, Properties<String^, String^>^ dsProps)
+        inline CacheFactory(std::shared_ptr<native::CacheFactory> nativeptr, Properties<String^, String^>^ dsProps)
         {
           m_nativeptr = gcnew native_shared_ptr<native::CacheFactory>(nativeptr);
           m_dsProps = dsProps;
diff --git a/clicache/src/CacheStatistics.hpp b/clicache/src/CacheStatistics.hpp
index ec006ac6..8a1decef 100644
--- a/clicache/src/CacheStatistics.hpp
+++ b/clicache/src/CacheStatistics.hpp
@@ -134,7 +134,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CacheStatistics^ Create( apache::geode::client::CacheStatisticsPtr nativeptr )
+        inline static CacheStatistics^ Create( std::shared_ptr<apache::geode::client::CacheStatistics> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew CacheStatistics( nativeptr );
@@ -147,7 +147,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheStatistics( apache::geode::client::CacheStatisticsPtr nativeptr )
+        inline CacheStatistics( std::shared_ptr<apache::geode::client::CacheStatistics> nativeptr )
         {
            m_nativeptr = gcnew native_shared_ptr<native::CacheStatistics>(nativeptr);
         }
diff --git a/clicache/src/CacheTransactionManager.cpp b/clicache/src/CacheTransactionManager.cpp
index e812c43d..1159c86c 100644
--- a/clicache/src/CacheTransactionManager.cpp
+++ b/clicache/src/CacheTransactionManager.cpp
@@ -219,7 +219,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2
 
           // Conver the unmanaged object to  managed generic object 
-          apache::geode::client::TransactionWriterPtr& writerPtr( m_nativeptr->getGCKeepAlive()->getWriter( ) );
+          std::shared_ptr<apache::geode::client::TransactionWriter>& writerPtr( m_nativeptr->getGCKeepAlive()->getWriter( ) );
           apache::geode::client::ManagedTransactionWriterGeneric* twg =
           dynamic_cast<apache::geode::client::ManagedTransactionWriterGeneric*>( writerPtr.get() );
 
@@ -239,7 +239,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2
           // Create a unmanaged object using the ManagedTransactionWriterGeneric.
           // Set the generic object inside the TransactionWriterGeneric that is a non generic object
-          apache::geode::client::TransactionWriterPtr writerPtr;
+          std::shared_ptr<apache::geode::client::TransactionWriter> writerPtr;
           if ( transactionWriter != nullptr ) 
           {
             TransactionWriterGeneric<TKey, TValue>^ twg = gcnew TransactionWriterGeneric<TKey, TValue> ();
@@ -258,7 +258,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2
           // Create a unmanaged object using the ManagedTransactionListenerGeneric.
           // Set the generic object inside the TransactionListenerGeneric that is a non generic object
-          apache::geode::client::TransactionListenerPtr listenerPtr;
+          std::shared_ptr<apache::geode::client::TransactionListener> listenerPtr;
           if ( transactionListener != nullptr ) 
           {
             TransactionListenerGeneric<TKey, TValue>^ twg = gcnew TransactionListenerGeneric<TKey, TValue> ();
@@ -277,7 +277,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2
           // Create an unmanaged non generic object using the managed generic object
           // use this to call the remove listener
-          apache::geode::client::TransactionListenerPtr listenerPtr;
+          std::shared_ptr<apache::geode::client::TransactionListener> listenerPtr;
           if ( transactionListener != nullptr ) 
           {
             TransactionListenerGeneric<TKey, TValue>^ twg = gcnew TransactionListenerGeneric<TKey, TValue> ();
diff --git a/clicache/src/CacheTransactionManager.hpp b/clicache/src/CacheTransactionManager.hpp
index 8638bae1..acca7767 100644
--- a/clicache/src/CacheTransactionManager.hpp
+++ b/clicache/src/CacheTransactionManager.hpp
@@ -203,7 +203,7 @@ namespace Apache
 
       internal:
 
-        inline static CacheTransactionManager^ Create( native::InternalCacheTransactionManager2PCPtr nativeptr )
+        inline static CacheTransactionManager^ Create( std::shared_ptr<native::InternalCacheTransactionManager2PC> nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew CacheTransactionManager( nativeptr ) : nullptr );
@@ -216,7 +216,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheTransactionManager( native::InternalCacheTransactionManager2PCPtr nativeptr )
+        inline CacheTransactionManager( std::shared_ptr<native::InternalCacheTransactionManager2PC> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::InternalCacheTransactionManager2PC>(nativeptr);
         }
diff --git a/clicache/src/CacheableBuiltins.hpp b/clicache/src/CacheableBuiltins.hpp
index fdb845a3..dc07e940 100644
--- a/clicache/src/CacheableBuiltins.hpp
+++ b/clicache/src/CacheableBuiltins.hpp
@@ -176,7 +176,7 @@ namespace Apache
         /// Protected constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableBuiltinKey(native::SerializablePtr nativeptr)
+        inline CacheableBuiltinKey(std::shared_ptr<native::Serializable> nativeptr)
           : CacheableKey(nativeptr) { }
       };
 
@@ -279,7 +279,7 @@ namespace Apache
         /// Protected constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableBuiltinArray(native::SerializablePtr nptr)
+        inline CacheableBuiltinArray(std::shared_ptr<native::Serializable> nptr)
           : Serializable(nptr)
         {
           auto nativeptr = std::static_pointer_cast<TNative>(nptr);
@@ -386,20 +386,20 @@ namespace Apache
            }                                                                     \
            \
            internal:                                                               \
-           static IGeodeSerializable^ Create(native::SerializablePtr obj)            \
+           static IGeodeSerializable^ Create(std::shared_ptr<native::Serializable> obj)            \
            {                                                                     \
            return (obj != nullptr ? gcnew m(obj) : nullptr);                   \
            }                                                                     \
            \
            private:                                                                \
-             inline m(native::SerializablePtr nativeptr)                            \
+             inline m(std::shared_ptr<native::Serializable> nativeptr)                            \
               : CacheableBuiltinKey(nativeptr) { }                                \
       };
 
 
 #define _GFCLI_CACHEABLE_ARRAY_DEF_NEW(m, mt)                                    \
       ref class m : public CacheableBuiltinArray<            \
-        native::m, native::m##Ptr, mt, GeodeClassIds::m>                  \
+        native::m, native::m, mt, GeodeClassIds::m>                  \
             {                                                                       \
       public:                                                                 \
         /** <summary>
@@ -449,7 +449,7 @@ namespace Apache
       }                                                                     \
       \
             internal:                                                               \
-              static IGeodeSerializable^ Create(native::SerializablePtr obj)            \
+              static IGeodeSerializable^ Create(std::shared_ptr<native::Serializable> obj)            \
       {                                                                     \
       return (obj != nullptr ? gcnew m(obj) : nullptr);                   \
       }                                                                     \
@@ -482,7 +482,7 @@ namespace Apache
                */                                                                   \
                inline m(array<mt>^ value, System::Int32 length)                              \
                : CacheableBuiltinArray(value, length) { }                          \
-               inline m(native::SerializablePtr nativeptr)                            \
+               inline m(std::shared_ptr<native::Serializable> nativeptr)                            \
                : CacheableBuiltinArray(nativeptr) { }                              \
       };
 
diff --git a/clicache/src/CacheableHashSet.hpp b/clicache/src/CacheableHashSet.hpp
index 3b5e97eb..60f5d71e 100644
--- a/clicache/src/CacheableHashSet.hpp
+++ b/clicache/src/CacheableHashSet.hpp
@@ -583,7 +583,7 @@ namespace Apache
           /// Private constructor to wrap a native object pointer
           /// </summary>
           /// <param name="nativeptr">The native object pointer</param>
-          inline CacheableHashSetType<TYPEID, HSTYPE>(apache::geode::client::SerializablePtr nativeptr)
+          inline CacheableHashSetType<TYPEID, HSTYPE>(std::shared_ptr<apache::geode::client::Serializable> nativeptr)
             : Serializable(nativeptr) { }
 
           /// <summary>
@@ -650,13 +650,13 @@ namespace Apache
       }                                                                     \
       \
             internal:                                                               \
-              static IGeodeSerializable^ Create(apache::geode::client::SerializablePtr obj)            \
+              static IGeodeSerializable^ Create(std::shared_ptr<apache::geode::client::Serializable> obj)            \
       {                                                                     \
       return gcnew m(obj);                                                \
       }                                                                     \
       \
             private:                                                                \
-              inline m(apache::geode::client::SerializablePtr nativeptr)                            \
+              inline m(std::shared_ptr<apache::geode::client::Serializable> nativeptr)                            \
               : Internal::CacheableHashSetType<Apache::Geode::Client::GeodeClassIds::m, HSTYPE>(nativeptr) { }             \
       };
 
diff --git a/clicache/src/CacheableKey.hpp b/clicache/src/CacheableKey.hpp
index 39bf3e51..752fbebe 100644
--- a/clicache/src/CacheableKey.hpp
+++ b/clicache/src/CacheableKey.hpp
@@ -131,7 +131,7 @@ namespace Apache
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableKey(apache::geode::client::SerializablePtr nativeptr)
+        inline CacheableKey(std::shared_ptr<apache::geode::client::Serializable> nativeptr)
           : Client::Serializable(nativeptr) { }
       };
     }  // namespace Client
diff --git a/clicache/src/CacheableString.cpp b/clicache/src/CacheableString.cpp
index 7f7a2275..2b653bed 100644
--- a/clicache/src/CacheableString.cpp
+++ b/clicache/src/CacheableString.cpp
@@ -69,7 +69,7 @@ namespace Apache
 
 
       inline void CacheableString::GetCacheableString(String^ value,
-                                                      apache::geode::client::CacheableStringPtr& cStr)
+                                                      std::shared_ptr<apache::geode::client::CacheableString>& cStr)
       {
         size_t len;
         if (value != nullptr && (len = value->Length) > 0) {
@@ -83,7 +83,7 @@ namespace Apache
       }
 
       inline void CacheableString::GetCacheableString(array<Char>^ value,
-                                                      apache::geode::client::CacheableStringPtr& cStr)
+                                                      std::shared_ptr<apache::geode::client::CacheableString>& cStr)
       {
         size_t len;
         if (value != nullptr && (len = value->Length) > 0) {
diff --git a/clicache/src/CacheableString.hpp b/clicache/src/CacheableString.hpp
index 2109258c..f469af57 100644
--- a/clicache/src/CacheableString.hpp
+++ b/clicache/src/CacheableString.hpp
@@ -242,7 +242,7 @@ namespace Apache
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        static IGeodeSerializable^ Create(apache::geode::client::SerializablePtr obj)
+        static IGeodeSerializable^ Create(std::shared_ptr<apache::geode::client::Serializable> obj)
         {
           return (obj != nullptr ?
                   gcnew CacheableString(obj) : nullptr);
@@ -253,14 +253,14 @@ namespace Apache
         /// from the given managed string.
         /// </summary>
         static void GetCacheableString(String^ value,
-                                       apache::geode::client::CacheableStringPtr& cStr);
+                                       std::shared_ptr<apache::geode::client::CacheableString>& cStr);
 
         /// <summary>
         /// Internal function to create a <c>apache::geode::client::CacheableString</c>
         /// from the given managed array of characters.
         /// </summary>
         static void GetCacheableString(array<Char>^ value,
-                                       apache::geode::client::CacheableStringPtr& cStr);
+                                       std::shared_ptr<apache::geode::client::CacheableString>& cStr);
 
         /// <summary>
         /// Get the <c>System.String</c> from the given
@@ -316,7 +316,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableString(apache::geode::client::SerializablePtr nativeptr)
+        inline CacheableString(std::shared_ptr<apache::geode::client::Serializable> nativeptr)
           : CacheableKey(nativeptr) { }
       };
     }  // namespace Client
diff --git a/clicache/src/CacheableStringArray.hpp b/clicache/src/CacheableStringArray.hpp
index 36bcd976..cfbb37c9 100644
--- a/clicache/src/CacheableStringArray.hpp
+++ b/clicache/src/CacheableStringArray.hpp
@@ -155,7 +155,7 @@ namespace Apache
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        static IGeodeSerializable^ Create(apache::geode::client::SerializablePtr obj)
+        static IGeodeSerializable^ Create(std::shared_ptr<apache::geode::client::Serializable> obj)
         {
           return (obj != nullptr ?
                   gcnew CacheableStringArray(obj) : nullptr);
@@ -183,7 +183,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableStringArray(apache::geode::client::SerializablePtr nativeptr)
+        inline CacheableStringArray(std::shared_ptr<apache::geode::client::Serializable> nativeptr)
           : Serializable(nativeptr) { }
       };
     }  // namespace Client
diff --git a/clicache/src/CqAttributes.hpp b/clicache/src/CqAttributes.hpp
index cf3fb561..c0d34475 100644
--- a/clicache/src/CqAttributes.hpp
+++ b/clicache/src/CqAttributes.hpp
@@ -61,7 +61,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqAttributes<TKey, TResult>^ Create( native::CqAttributesPtr nativeptr )
+        inline static CqAttributes<TKey, TResult>^ Create( std::shared_ptr<native::CqAttributes> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew CqAttributes( nativeptr );
@@ -78,7 +78,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqAttributes( native::CqAttributesPtr nativeptr )
+        inline CqAttributes( std::shared_ptr<native::CqAttributes> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::CqAttributes>(nativeptr);
         }
diff --git a/clicache/src/CqAttributesMutator.cpp b/clicache/src/CqAttributesMutator.cpp
index d728746b..9e7d9355 100644
--- a/clicache/src/CqAttributesMutator.cpp
+++ b/clicache/src/CqAttributesMutator.cpp
@@ -93,7 +93,7 @@ namespace Apache
         if (auto lister = dynamic_cast<Client::ICqStatusListener<TKey, TResult>^>(cqListener)) {
           auto cqlg = gcnew CqStatusListenerGeneric<TKey, TResult>();
           cqlg->AddCqListener(cqListener);
-          native::CqStatusListenerPtr lptr = std::shared_ptr<native::ManagedCqStatusListenerGeneric>(
+          std::shared_ptr<native::CqStatusListener> lptr = std::shared_ptr<native::ManagedCqStatusListenerGeneric>(
             new native::ManagedCqStatusListenerGeneric(lister));
           ((native::ManagedCqStatusListenerGeneric*)lptr.get())->setptr(cqlg);
           try {
@@ -116,7 +116,7 @@ namespace Apache
         else {
           auto cqlg = gcnew CqListenerGeneric<TKey, TResult>();
           cqlg->AddCqListener(cqListener);
-          native::CqListenerPtr lptr = std::shared_ptr<native::ManagedCqListenerGeneric>(
+          std::shared_ptr<native::CqListener> lptr = std::shared_ptr<native::ManagedCqListenerGeneric>(
             new native::ManagedCqListenerGeneric(cqListener));
           ((native::ManagedCqListenerGeneric*)lptr.get())->setptr(cqlg);
           try {
diff --git a/clicache/src/CqAttributesMutator.hpp b/clicache/src/CqAttributesMutator.hpp
index 7e04b654..c814ff0e 100644
--- a/clicache/src/CqAttributesMutator.hpp
+++ b/clicache/src/CqAttributesMutator.hpp
@@ -91,7 +91,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Client::CqAttributesMutator<TKey, TResult>^ Create( native::CqAttributesMutatorPtr nativeptr )
+        inline static Client::CqAttributesMutator<TKey, TResult>^ Create( std::shared_ptr<native::CqAttributesMutator> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew  Client::CqAttributesMutator<TKey, TResult>( nativeptr );
@@ -104,7 +104,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqAttributesMutator<TKey, TResult>( native::CqAttributesMutatorPtr nativeptr )
+        inline CqAttributesMutator<TKey, TResult>( std::shared_ptr<native::CqAttributesMutator> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::CqAttributesMutator>(nativeptr);
         }
diff --git a/clicache/src/CqEvent.cpp b/clicache/src/CqEvent.cpp
index ae1c668d..a98003fd 100644
--- a/clicache/src/CqEvent.cpp
+++ b/clicache/src/CqEvent.cpp
@@ -33,7 +33,7 @@ namespace Apache
       generic<class TKey, class TResult>
       CqQuery<TKey, TResult>^ CqEvent<TKey, TResult>::getCq( )
       {
-        native::CqQueryPtr& cQueryptr( m_nativeptr->getCq( ) );
+        std::shared_ptr<native::CqQuery>& cQueryptr( m_nativeptr->getCq( ) );
         return CqQuery<TKey, TResult>::Create( cQueryptr);
       }
 
@@ -52,14 +52,14 @@ namespace Apache
       generic<class TKey, class TResult>
       TKey CqEvent<TKey, TResult>::getKey( )
       {
-        native::CacheableKeyPtr& keyptr( m_nativeptr->getKey( ) );
+        std::shared_ptr<native::CacheableKey>& keyptr( m_nativeptr->getKey( ) );
         return Serializable::GetManagedValueGeneric<TKey>(keyptr);
       }
 
       generic<class TKey, class TResult>
       TResult CqEvent<TKey, TResult>::getNewValue( )
       {
-        native::CacheablePtr& valptr( m_nativeptr->getNewValue( ) );
+        std::shared_ptr<native::Cacheable>& valptr( m_nativeptr->getNewValue( ) );
         return Serializable::GetManagedValueGeneric<TResult>(valptr);
       }
 
diff --git a/clicache/src/CqQuery.hpp b/clicache/src/CqQuery.hpp
index 957cb05a..850310a4 100644
--- a/clicache/src/CqQuery.hpp
+++ b/clicache/src/CqQuery.hpp
@@ -163,7 +163,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqQuery<TKey, TResult>^ Create( native::CqQueryPtr nativeptr )
+        inline static CqQuery<TKey, TResult>^ Create( std::shared_ptr<native::CqQuery> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew  CqQuery<TKey, TResult>( nativeptr );
@@ -176,7 +176,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqQuery( native::CqQueryPtr nativeptr )
+        inline CqQuery( std::shared_ptr<native::CqQuery> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::CqQuery>(nativeptr);
         }
diff --git a/clicache/src/CqServiceStatistics.hpp b/clicache/src/CqServiceStatistics.hpp
index d711d8a4..2fa9c419 100644
--- a/clicache/src/CqServiceStatistics.hpp
+++ b/clicache/src/CqServiceStatistics.hpp
@@ -76,7 +76,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqServiceStatistics^ Create( apache::geode::client::CqServiceStatisticsPtr nativeptr )
+        inline static CqServiceStatistics^ Create( std::shared_ptr<apache::geode::client::CqServiceStatistics> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew CqServiceStatistics( nativeptr );
@@ -89,7 +89,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqServiceStatistics( apache::geode::client::CqServiceStatisticsPtr nativeptr )
+        inline CqServiceStatistics( std::shared_ptr<apache::geode::client::CqServiceStatistics> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::CqServiceStatistics>(nativeptr);
         }
diff --git a/clicache/src/CqStatistics.hpp b/clicache/src/CqStatistics.hpp
index 05aa23ce..93876fb3 100644
--- a/clicache/src/CqStatistics.hpp
+++ b/clicache/src/CqStatistics.hpp
@@ -69,7 +69,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqStatistics^ Create( apache::geode::client::CqStatisticsPtr nativeptr )
+        inline static CqStatistics^ Create( std::shared_ptr<apache::geode::client::CqStatistics> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew CqStatistics( nativeptr );
@@ -82,7 +82,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqStatistics( apache::geode::client::CqStatisticsPtr nativeptr )
+        inline CqStatistics( std::shared_ptr<apache::geode::client::CqStatistics> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::CqStatistics>(nativeptr);
         }
diff --git a/clicache/src/EntryEvent.cpp b/clicache/src/EntryEvent.cpp
index 47218c64..bda549c2 100644
--- a/clicache/src/EntryEvent.cpp
+++ b/clicache/src/EntryEvent.cpp
@@ -31,35 +31,35 @@ namespace Apache
       generic<class TKey, class TValue>
       IRegion<TKey, TValue>^ EntryEvent<TKey, TValue>::Region::get( )
       {
-        apache::geode::client::RegionPtr regionptr = m_nativeptr->getRegion();
+        std::shared_ptr<apache::geode::client::Region> regionptr = m_nativeptr->getRegion();
         return Client::Region<TKey, TValue>::Create( regionptr );
       }
 
       generic<class TKey, class TValue>
       TKey EntryEvent<TKey, TValue>::Key::get( )
       {
-        apache::geode::client::CacheableKeyPtr& keyptr( m_nativeptr->getKey( ) );
+        std::shared_ptr<apache::geode::client::CacheableKey>& keyptr( m_nativeptr->getKey( ) );
         return Serializable::GetManagedValueGeneric<TKey>( keyptr );
       }
 
       generic<class TKey, class TValue>
       TValue EntryEvent<TKey, TValue>::OldValue::get( )
       {
-        apache::geode::client::CacheablePtr& valptr( m_nativeptr->getOldValue( ) );
+        std::shared_ptr<apache::geode::client::Cacheable>& valptr( m_nativeptr->getOldValue( ) );
         return Serializable::GetManagedValueGeneric<TValue>( valptr );
       }
 
       generic<class TKey, class TValue>
       TValue EntryEvent<TKey, TValue>::NewValue::get( )
       {
-        apache::geode::client::CacheablePtr& valptr( m_nativeptr->getNewValue( ) );
+        std::shared_ptr<apache::geode::client::Cacheable>& valptr( m_nativeptr->getNewValue( ) );
         return Serializable::GetManagedValueGeneric<TValue>( valptr );
       }
 
       generic<class TKey, class TValue>
       Object^ EntryEvent<TKey, TValue>::CallbackArgument::get()
       {
-        apache::geode::client::SerializablePtr& valptr(m_nativeptr->getCallbackArgument());
+        std::shared_ptr<apache::geode::client::Serializable>& valptr(m_nativeptr->getCallbackArgument());
         return Serializable::GetManagedValueGeneric<Object^>( valptr );
       }
 
diff --git a/clicache/src/ExceptionTypes.hpp b/clicache/src/ExceptionTypes.hpp
index 491dfcb0..6ac31b44 100644
--- a/clicache/src/ExceptionTypes.hpp
+++ b/clicache/src/ExceptionTypes.hpp
@@ -152,7 +152,7 @@ namespace Apache
         /// contained in the message. Note that in this process the
         /// original stacktrace is appended to the message of the exception.
         /// </remarks>
-        inline static apache::geode::client::ExceptionPtr GetNative(Exception^ ex)
+        inline static std::shared_ptr<apache::geode::client::Exception> GetNative(Exception^ ex)
         {
           if (ex != nullptr) {
             GeodeException^ gfEx = dynamic_cast<GeodeException^>(ex);
@@ -160,7 +160,7 @@ namespace Apache
               return gfEx->GetNative();
             }
             else {
-              apache::geode::client::ExceptionPtr cause;
+              std::shared_ptr<apache::geode::client::Exception> cause;
               if (ex->InnerException != nullptr) {
                 cause = GeodeException::GetNative(ex->InnerException);
               }
@@ -176,11 +176,11 @@ namespace Apache
         /// Gets the C++ native exception object for this managed
         /// <c>GeodeException</c>.
         /// </summary>
-        virtual apache::geode::client::ExceptionPtr GetNative()
+        virtual std::shared_ptr<apache::geode::client::Exception> GetNative()
         {
           String^ msg = this->Message + ": " + this->StackTrace;
           ManagedString mg_msg(msg);
-          apache::geode::client::ExceptionPtr cause;
+          std::shared_ptr<apache::geode::client::Exception> cause;
           if (this->InnerException != nullptr) {
             cause = GeodeException::GetNative(this->InnerException);
           }
@@ -205,7 +205,7 @@ namespace Apache
         inline static void ThrowNative(Exception^ ex)
         {
           if (ex != nullptr) {
-            apache::geode::client::ExceptionPtr cause;
+            std::shared_ptr<apache::geode::client::Exception> cause;
             if (ex->InnerException != nullptr) {
               cause = GeodeException::GetNative(ex->InnerException);
             }
@@ -350,11 +350,11 @@ namespace Apache
           } \
           return nullptr; \
         } \
-        virtual apache::geode::client::ExceptionPtr GetNative() override \
+        virtual std::shared_ptr<apache::geode::client::Exception> GetNative() override \
         { \
           String^ msg = this->Message + ": " + this->StackTrace; \
           ManagedString mg_msg(msg); \
-          apache::geode::client::ExceptionPtr cause; \
+          std::shared_ptr<apache::geode::client::Exception> cause; \
           if (this->InnerException != nullptr) { \
             cause = GeodeException::GetNative(this->InnerException); \
           } \
diff --git a/clicache/src/Execution.cpp b/clicache/src/Execution.cpp
index 3b41d098..8b564b67 100644
--- a/clicache/src/Execution.cpp
+++ b/clicache/src/Execution.cpp
@@ -88,7 +88,7 @@ namespace Apache
       Execution<TResult>^ Execution<TResult>::WithCollector(Client::IResultCollector<TResult>^ rc)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-          native::ResultCollectorPtr rcptr;
+          std::shared_ptr<native::ResultCollector> rcptr;
         if ( rc != nullptr ) {
           auto rcg = gcnew ResultCollectorGeneric<TResult>();
           rcg->SetResultCollector(rc); 
diff --git a/clicache/src/Execution.hpp b/clicache/src/Execution.hpp
index a1f27b8f..067afbe2 100644
--- a/clicache/src/Execution.hpp
+++ b/clicache/src/Execution.hpp
@@ -90,7 +90,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Execution<TResult>^ Create( native::ExecutionPtr nativeptr, IResultCollector<TResult>^ rc )
+        inline static Execution<TResult>^ Create( std::shared_ptr<native::Execution> nativeptr, IResultCollector<TResult>^ rc )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew Execution<TResult>( nativeptr, rc );
@@ -100,7 +100,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer.
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Execution( native::ExecutionPtr nativeptr, IResultCollector<TResult>^ rc )
+        inline Execution( std::shared_ptr<native::Execution> nativeptr, IResultCollector<TResult>^ rc )
         {
           m_rc = rc;
           m_nativeptr = gcnew native_shared_ptr<native::Execution>(nativeptr);
diff --git a/clicache/src/LocalRegion.cpp b/clicache/src/LocalRegion.cpp
index 67b92b5a..821c28b4 100644
--- a/clicache/src/LocalRegion.cpp
+++ b/clicache/src/LocalRegion.cpp
@@ -41,7 +41,7 @@ namespace Apache
       generic<class TKey, class TValue>
       TValue LocalRegion<TKey, TValue>::Get(TKey key, Object^ callbackArg)
       {
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
         auto nativeptr= this->getRegionEntryValue(keyptr);
         if (nativeptr == nullptr)
         {
@@ -52,7 +52,7 @@ namespace Apache
       }     
 
       generic<class TKey, class TValue>
-      apache::geode::client::SerializablePtr LocalRegion<TKey, TValue>::getRegionEntryValue(apache::geode::client::CacheableKeyPtr& keyptr)
+      std::shared_ptr<apache::geode::client::Serializable> LocalRegion<TKey, TValue>::getRegionEntryValue(std::shared_ptr<apache::geode::client::CacheableKey>& keyptr)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           try
@@ -78,9 +78,9 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );        
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
           m_nativeptr->get()->localPut( keyptr, valueptr, callbackptr );
         }
         finally
@@ -94,7 +94,7 @@ namespace Apache
       generic<class TKey, class TValue>
       TValue LocalRegion<TKey, TValue>::default::get(TKey key)
       { 
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
         auto nativeptr = this->getRegionEntryValue(keyptr);
         if (nativeptr == nullptr)
         {
@@ -111,8 +111,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );
           m_nativeptr->get()->localPut( keyptr, valueptr );
         }
         finally
@@ -127,7 +127,7 @@ namespace Apache
       System::Collections::Generic::IEnumerator<KeyValuePair<TKey,TValue>>^ 
         LocalRegion<TKey, TValue>::GetEnumerator()
       {
-        apache::geode::client::VectorOfRegionEntry vc;
+        std::vector<std::shared_ptr<apache::geode::client::RegionEntry>> vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -157,7 +157,7 @@ namespace Apache
       System::Collections::IEnumerator^ 
         LocalRegion<TKey, TValue>::GetEnumeratorOld()
       {
-        apache::geode::client::VectorOfRegionEntry vc;
+        std::vector<std::shared_ptr<apache::geode::client::RegionEntry>> vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -185,7 +185,7 @@ namespace Apache
 
 
       generic<class TKey, class TValue>
-      bool LocalRegion<TKey, TValue>::AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2)
+      bool LocalRegion<TKey, TValue>::AreValuesEqual(std::shared_ptr<apache::geode::client::Cacheable>& val1, std::shared_ptr<apache::geode::client::Cacheable>& val2)
       {
         if ( val1 == nullptr && val2 == nullptr )
         {
@@ -269,7 +269,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::VectorOfCacheableKey vc;
+        std::vector<std::shared_ptr<apache::geode::client::CacheableKey>> vc;
         try
         {
           vc = m_nativeptr->get()->keys();
@@ -296,7 +296,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::VectorOfCacheable vc;
+          std::vector<std::shared_ptr<apache::geode::client::Cacheable>> vc;
           try
           {
             vc = m_nativeptr->get()->values(  );
@@ -326,8 +326,8 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
-            native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+            std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );
             m_nativeptr->get()->localCreate( keyptr, valueptr );
           }
           finally
@@ -345,8 +345,8 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key );
-            native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value );
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key );
+            std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value );
             m_nativeptr->get()->localCreate( keyptr, valueptr );
           }
           finally
@@ -364,9 +364,9 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
-            native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );          
-            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+            std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value );
+            std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
             m_nativeptr->get()->localCreate( keyptr, valueptr, callbackptr );
           }
           finally
@@ -384,7 +384,7 @@ namespace Apache
     
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
             m_nativeptr->get()->localDestroy(keyptr);
             return true;
           }
@@ -407,8 +407,8 @@ namespace Apache
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
            try
            {
-             native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-             native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+             std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+             std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
              m_nativeptr->get()->localDestroy(keyptr, callbackptr);
              return true;
            }
@@ -430,8 +430,8 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key );
-            native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value );
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key );
+            std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value );
             return m_nativeptr->get()->localRemove(keyptr, valueptr);
           }
           finally
@@ -449,9 +449,9 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-            native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
-            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+            std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
+            std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
             return m_nativeptr->get()->localRemove(keyptr, valueptr, callbackptr);
           }
           finally
@@ -479,7 +479,7 @@ namespace Apache
                     
           try
           {
-            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
+            std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
             m_nativeptr->get()->localInvalidateRegion( callbackptr );
           }
           finally
@@ -506,7 +506,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */          
           try
           {
-            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
+            std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
             m_nativeptr->get()->localDestroyRegion( callbackptr );
           }
           finally
@@ -534,8 +534,8 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );          
-            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key );
+            std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg );
             m_nativeptr->get()->localInvalidate( keyptr, callbackptr );
           }
           finally
@@ -750,7 +750,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::VectorOfRegion vsr;
+          std::vector<std::shared_ptr<apache::geode::client::Region>> vsr;
           try
           {
             vsr = m_nativeptr->get()->subregions( recursive );
@@ -780,7 +780,7 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
             auto nativeptr = m_nativeptr->get()->getEntry(keyptr);
             return RegionEntry<TKey, TValue>::Create(nativeptr);
           }
@@ -797,7 +797,7 @@ namespace Apache
       {
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::VectorOfRegionEntry vc;
+          std::vector<std::shared_ptr<apache::geode::client::RegionEntry>> vc;
           try
           {
             vc = m_nativeptr->get()->entries( recursive );
@@ -893,7 +893,7 @@ namespace Apache
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::VectorOfRegionEntry vc;
+        std::vector<std::shared_ptr<apache::geode::client::RegionEntry>> vc;
         try
         {
           vc = m_nativeptr->get()->entries( false );
@@ -910,7 +910,7 @@ namespace Apache
 
         for( System::Int32 index = 0; index < vc.size( ); index++ )
         {
-          apache::geode::client::RegionEntryPtr nativeptr =  vc[ index ];                       
+          std::shared_ptr<apache::geode::client::RegionEntry> nativeptr =  vc[ index ];
           TKey key = Serializable::GetManagedValueGeneric<TKey> (nativeptr->getKey());
           TValue val = Serializable::GetManagedValueGeneric<TValue> (nativeptr->getValue());            
           toArray[ startIdx ] = KeyValuePair<TKey,TValue>(key, val);
diff --git a/clicache/src/LocalRegion.hpp b/clicache/src/LocalRegion.hpp
index 4955e498..a8f8a437 100644
--- a/clicache/src/LocalRegion.hpp
+++ b/clicache/src/LocalRegion.hpp
@@ -231,7 +231,7 @@ namespace Apache
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
         //generic<class TKey, class TValue>
-        inline static IRegion<TKey, TValue>^ Create( native::RegionPtr nativeptr )
+        inline static IRegion<TKey, TValue>^ Create( std::shared_ptr<native::Region> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew LocalRegion<TKey, TValue>( nativeptr );
@@ -246,14 +246,14 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline LocalRegion( native::RegionPtr nativeptr )
+        inline LocalRegion( std::shared_ptr<native::Region> nativeptr )
 				{
           m_nativeptr = gcnew native_shared_ptr<native::Region>(nativeptr);
         }
 
         private:        
-        inline apache::geode::client::SerializablePtr getRegionEntryValue(apache::geode::client::CacheableKeyPtr& key);
-        bool AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2);
+        inline std::shared_ptr<apache::geode::client::Serializable> getRegionEntryValue(std::shared_ptr<apache::geode::client::CacheableKey>& key);
+        bool AreValuesEqual(std::shared_ptr<apache::geode::client::Cacheable>& val1, std::shared_ptr<apache::geode::client::Cacheable>& val2);
 
         native_shared_ptr<native::Region>^ m_nativeptr;   
       };
diff --git a/clicache/src/Pool.hpp b/clicache/src/Pool.hpp
index 9dc7e8e1..f6b08d29 100644
--- a/clicache/src/Pool.hpp
+++ b/clicache/src/Pool.hpp
@@ -322,7 +322,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Pool^ Create(native::PoolPtr nativeptr)
+        inline static Pool^ Create(std::shared_ptr<native::Pool> nativeptr)
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew Pool( nativeptr );
@@ -339,7 +339,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Pool(native::PoolPtr nativeptr)
+        inline Pool(std::shared_ptr<native::Pool> nativeptr)
         {
           m_nativeptr = gcnew native_shared_ptr<native::Pool>(nativeptr);
         }
diff --git a/clicache/src/PoolFactory.hpp b/clicache/src/PoolFactory.hpp
index 8f299650..1c3b6198 100644
--- a/clicache/src/PoolFactory.hpp
+++ b/clicache/src/PoolFactory.hpp
@@ -402,7 +402,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static PoolFactory^ Create(native::PoolFactoryPtr nativeptr)
+        inline static PoolFactory^ Create(std::shared_ptr<native::PoolFactory> nativeptr)
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew PoolFactory( nativeptr );
@@ -414,7 +414,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline PoolFactory(native::PoolFactoryPtr nativeptr)
+        inline PoolFactory(std::shared_ptr<native::PoolFactory> nativeptr)
         {
           m_nativeptr = gcnew native_shared_ptr<native::PoolFactory>(nativeptr);
         }
diff --git a/clicache/src/Properties.cpp b/clicache/src/Properties.cpp
index a8312b36..1b619fef 100644
--- a/clicache/src/Properties.cpp
+++ b/clicache/src/Properties.cpp
@@ -69,7 +69,7 @@ namespace Apache
       {
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TPropKey>(key);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TPropKey>(key);
           auto nativeptr = m_nativeptr->get()->find(keyptr);
           return Serializable::GetManagedValueGeneric<TPropValue>(nativeptr);
         }
@@ -82,8 +82,8 @@ namespace Apache
       generic<class TPropKey, class TPropValue>
       void Properties<TPropKey, TPropValue>::Insert( TPropKey key, TPropValue value )
       {
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TPropKey>(key, true);
-        native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TPropValue>(value, true);
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TPropKey>(key, true);
+        std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TPropValue>(value, true);
 
         _GF_MG_EXCEPTION_TRY2
 
@@ -102,7 +102,7 @@ namespace Apache
       generic<class TPropKey, class TPropValue>
       void Properties<TPropKey, TPropValue>::Remove( TPropKey key)
       {
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TPropKey>(key);
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TPropKey>(key);
 
         _GF_MG_EXCEPTION_TRY2
 
@@ -323,7 +323,7 @@ namespace Apache
       //
       //generic<class TPropKey, class TPropValue>
       //Properties<TPropKey, TPropValue>::Properties( SerializationInfo^ info,
-      //  StreamingContext context, native::SerializationRegistryPtr serializationRegistry)
+      //  StreamingContext context, std::shared_ptr<native::SerializationRegistry> serializationRegistry)
       //  : Properties(serializationRegistry)
       //{
       //  array<Byte>^ bytes = nullptr;
diff --git a/clicache/src/Properties.hpp b/clicache/src/Properties.hpp
index 689cb320..8aa467cf 100644
--- a/clicache/src/Properties.hpp
+++ b/clicache/src/Properties.hpp
@@ -214,7 +214,7 @@ namespace Apache
       protected:
 
         // For deserialization using the .NET serialization (ISerializable)
-        //Properties(SerializationInfo^ info, StreamingContext context, native::SerializationRegistryPtr serializationRegistry);
+        //Properties(SerializationInfo^ info, StreamingContext context, std::shared_ptr<native::SerializationRegistry> serializationRegistry);
 
 
       internal:
@@ -228,7 +228,7 @@ namespace Apache
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
         //generic<class TPropKey, class TPropValue>
-        static Properties<TPropKey, TPropValue>^ Create( native::PropertiesPtr nativeptr )
+        static Properties<TPropKey, TPropValue>^ Create( std::shared_ptr<native::Properties> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew Properties<TPropKey, TPropValue>( nativeptr );
@@ -250,7 +250,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Properties( native::PropertiesPtr nativeptr )
+        inline Properties( std::shared_ptr<native::Properties> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::Properties>(nativeptr);
         }
@@ -268,9 +268,9 @@ namespace Apache
           Apache::Geode::Client::IGeodeSerializable^ value)
         {
           TPropKey tpkey = Apache::Geode::Client::Serializable::
-            GetManagedValueGeneric<TPropKey>(SerializablePtr(SafeMSerializableConvertGeneric(key)));
+            GetManagedValueGeneric<TPropKey>(std::shared_ptr<apache::geode::client::Serializable>(SafeMSerializableConvertGeneric(key)));
           TPropValue tpvalue = Apache::Geode::Client::Serializable::
-            GetManagedValueGeneric<TPropValue>(SerializablePtr(SafeMSerializableConvertGeneric(value)));
+            GetManagedValueGeneric<TPropValue>(std::shared_ptr<apache::geode::client::Serializable>(SafeMSerializableConvertGeneric(value)));
           m_visitor->Invoke(tpkey, tpvalue);
         }
 
diff --git a/clicache/src/Query.cpp b/clicache/src/Query.cpp
index f5593735..6b9b7d08 100644
--- a/clicache/src/Query.cpp
+++ b/clicache/src/Query.cpp
@@ -87,7 +87,7 @@ namespace Apache
       }
 
       generic<class TResult>
-      ISelectResults<TResult>^ Query<TResult>::WrapResults(const apache::geode::client::SelectResultsPtr& selectResults)
+      ISelectResults<TResult>^ Query<TResult>::WrapResults(const std::shared_ptr<apache::geode::client::SelectResults>& selectResults)
       {
         if ( __nullptr == selectResults ) return nullptr;
 
diff --git a/clicache/src/Query.hpp b/clicache/src/Query.hpp
index 2294b915..c86251f5 100644
--- a/clicache/src/Query.hpp
+++ b/clicache/src/Query.hpp
@@ -190,7 +190,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Query<TResult>^ Create( apache::geode::client::QueryPtr nativeptr )
+        inline static Query<TResult>^ Create( std::shared_ptr<apache::geode::client::Query> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew Query<TResult>( nativeptr );
@@ -203,12 +203,12 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Query( apache::geode::client::QueryPtr nativeptr )
+        inline Query( std::shared_ptr<apache::geode::client::Query> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::Query>(nativeptr);
         }
 
-        ISelectResults<TResult>^ WrapResults(const apache::geode::client::SelectResultsPtr& selectResults);
+        ISelectResults<TResult>^ WrapResults(const std::shared_ptr<apache::geode::client::SelectResults>& selectResults);
 
         native_shared_ptr<native::Query>^ m_nativeptr;
       };
diff --git a/clicache/src/QueryService.hpp b/clicache/src/QueryService.hpp
index 78d29ef6..3bb89f7f 100644
--- a/clicache/src/QueryService.hpp
+++ b/clicache/src/QueryService.hpp
@@ -136,7 +136,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static QueryService<TKey, TResult>^ Create(native::QueryServicePtr nativeptr )
+        inline static QueryService<TKey, TResult>^ Create(std::shared_ptr<native::QueryService> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew QueryService<TKey, TResult>( nativeptr );
@@ -149,7 +149,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline QueryService(native::QueryServicePtr nativeptr)
+        inline QueryService(std::shared_ptr<native::QueryService> nativeptr)
         {
            m_nativeptr = gcnew native_shared_ptr<native::QueryService>(nativeptr);
         }
diff --git a/clicache/src/Region.cpp b/clicache/src/Region.cpp
index 289517ba..357becc9 100644
--- a/clicache/src/Region.cpp
+++ b/clicache/src/Region.cpp
@@ -53,8 +53,8 @@ namespace Apache
       generic<class TKey, class TValue>
       TValue Region<TKey, TValue>::Get(TKey key, Object^ callbackArg)
       {
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-        native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+        std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
         GC::KeepAlive(m_nativeptr);
         auto nativeptr = this->get(keyptr, callbackptr);
         if (nativeptr == nullptr)
@@ -66,7 +66,7 @@ namespace Apache
       }
 
       generic<class TKey, class TValue>
-      native::SerializablePtr Region<TKey, TValue>::get(native::CacheableKeyPtr& keyptr, native::SerializablePtr& callbackptr)
+      std::shared_ptr<native::Serializable> Region<TKey, TValue>::get(std::shared_ptr<native::CacheableKey>& keyptr, std::shared_ptr<native::Serializable>& callbackptr)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           try
@@ -81,7 +81,7 @@ namespace Apache
       }
 
       generic<class TKey, class TValue>
-      native::SerializablePtr Region<TKey, TValue>::get(native::CacheableKeyPtr& keyptr)
+      std::shared_ptr<native::Serializable> Region<TKey, TValue>::get(std::shared_ptr<native::CacheableKey>& keyptr)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           try
@@ -119,9 +119,9 @@ namespace Apache
 
           try
           {
-            native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-            native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
-            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+            std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+            std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
+            std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
             m_nativeptr->get()->put(keyptr, valueptr, callbackptr);
           }
           finally
@@ -135,7 +135,7 @@ namespace Apache
       generic<class TKey, class TValue>
       TValue Region<TKey, TValue>::default::get(TKey key)
       {
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
         GC::KeepAlive(m_nativeptr);
         auto nativeptr = this->get(keyptr);
         if (nativeptr == nullptr)
@@ -153,8 +153,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
           m_nativeptr->get()->put(keyptr, valueptr);
         }
         finally
@@ -169,7 +169,7 @@ namespace Apache
       System::Collections::Generic::IEnumerator<KeyValuePair<TKey, TValue>>^
         Region<TKey, TValue>::GetEnumerator()
       {
-        native::VectorOfRegionEntry vc;
+		std::vector<std::shared_ptr<native::RegionEntry>> vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -200,7 +200,7 @@ namespace Apache
       System::Collections::IEnumerator^
         Region<TKey, TValue>::GetEnumeratorOld()
       {
-        native::VectorOfRegionEntry vc;
+		std::vector<std::shared_ptr<native::RegionEntry>> vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -228,7 +228,7 @@ namespace Apache
       }
 
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::AreValuesEqual(native::CacheablePtr& val1, native::CacheablePtr& val2)
+      bool Region<TKey, TValue>::AreValuesEqual(std::shared_ptr<native::Cacheable>& val1, std::shared_ptr<native::Cacheable>& val2)
       {
         if (val1 == nullptr && val2 == nullptr)
         {
@@ -266,7 +266,7 @@ namespace Apache
       generic<class TKey, class TValue>
       bool Region<TKey, TValue>::Contains(KeyValuePair<TKey, TValue> keyValuePair)
       {
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key);
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key);
         GC::KeepAlive(m_nativeptr);
         auto nativeptr = this->get(keyptr);
         //This means that key is not present.
@@ -284,7 +284,7 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
           return m_nativeptr->get()->containsKeyOnServer(keyptr);
         }
         finally
@@ -299,7 +299,7 @@ namespace Apache
       bool Region<TKey, TValue>::TryGetValue(TKey key, TValue %val)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-        native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+        std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
         GC::KeepAlive(m_nativeptr);
         auto nativeptr = this->get(keyptr);
         if (nativeptr == nullptr) {
@@ -319,7 +319,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfCacheableKey vc;
+          std::vector<std::shared_ptr<native::CacheableKey>> vc;
         try
         {
           vc = m_nativeptr->get()->serverKeys();
@@ -345,7 +345,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfCacheable vc;
+          std::vector<std::shared_ptr<native::Cacheable>> vc;
         try
         {
           vc = m_nativeptr->get()->values();
@@ -373,8 +373,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
           m_nativeptr->get()->create(keyptr, valueptr);
         }
         finally
@@ -392,8 +392,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValuePair.Value);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValuePair.Value);
           m_nativeptr->get()->create(keyptr, valueptr);
         }
         finally
@@ -411,9 +411,9 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           m_nativeptr->get()->create(keyptr, valueptr, callbackptr);
         }
         finally
@@ -431,7 +431,7 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
           return m_nativeptr->get()->removeEx(keyptr);
         }
         finally
@@ -450,8 +450,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           return m_nativeptr->get()->removeEx(keyptr, callbackptr);
         }
         finally
@@ -469,8 +469,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValuePair.Value);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValuePair.Value);
           return m_nativeptr->get()->remove(keyptr, valueptr);
         }
         finally
@@ -488,9 +488,9 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           GC::KeepAlive(m_nativeptr);
           return m_nativeptr->get()->remove(keyptr, valueptr, callbackptr);
         }
@@ -519,7 +519,7 @@ namespace Apache
 
         try
         {
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           m_nativeptr->get()->invalidateRegion(callbackptr);
         }
         finally
@@ -547,7 +547,7 @@ namespace Apache
 
         try
         {
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           m_nativeptr->get()->destroyRegion(callbackptr);
         }
         finally
@@ -576,8 +576,8 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           m_nativeptr->get()->invalidate(keyptr, callbackptr);
         }
         finally
@@ -607,8 +607,8 @@ namespace Apache
           native::HashMapOfCacheable nativeMap;
         for each (KeyValuePair<TKey, TValue> keyValPair in map)
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValPair.Key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValPair.Value);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValPair.Key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValPair.Value);
           nativeMap.emplace(keyptr, valueptr);
         }
         try
@@ -632,11 +632,11 @@ namespace Apache
           native::HashMapOfCacheable nativeMap;
         for each (KeyValuePair<TKey, TValue> keyValPair in map)
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValPair.Key);
-          native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValPair.Value);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(keyValPair.Key);
+          std::shared_ptr<native::Cacheable> valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValPair.Value);
           nativeMap.emplace(keyptr, valueptr);
         }
-        native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+        std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
         try
         {
           m_nativeptr->get()->putAll(nativeMap, TimeSpanUtils::TimeSpanToDurationCeil<std::chrono::seconds>(timeout), callbackptr);
@@ -672,7 +672,7 @@ namespace Apache
         if (keys != nullptr) {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            native::VectorOfCacheableKey vecKeys;
+            std::vector<std::shared_ptr<native::CacheableKey>> vecKeys;
 
           for each(TKey item in keys)
           {
@@ -680,7 +680,7 @@ namespace Apache
               Serializable::GetUnmanagedValueGeneric<TKey>(item));
           }
 
-          native::HashMapOfCacheable native_value;
+         native::HashMapOfCacheable native_value;
         
           try
           {
@@ -714,7 +714,7 @@ namespace Apache
         if (keys != nullptr) {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            native::VectorOfCacheableKey vecKeys;
+            std::vector<std::shared_ptr<native::CacheableKey>> vecKeys;
 
           for each(TKey item in keys)
           {
@@ -722,11 +722,11 @@ namespace Apache
               Serializable::GetUnmanagedValueGeneric<TKey>(item));
           }
 
-          native::HashMapOfCacheablePtr valuesPtr;
+          std::shared_ptr<native::HashMapOfCacheable> valuesPtr;
           if (values != nullptr) {
             valuesPtr = std::make_shared<native::HashMapOfCacheable>();
           }
-         native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+         std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
          native::HashMapOfCacheable native_value;
           try
           {
@@ -768,11 +768,11 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfCacheableKey vecKeys;
+          std::vector<std::shared_ptr<native::CacheableKey>> vecKeys;
         for each(TKey item in keys)
           vecKeys.push_back(Serializable::GetUnmanagedValueGeneric<TKey>(item));
 
-        native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+        std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
 
         try
         {
@@ -929,7 +929,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfRegion vsr;
+          std::vector<std::shared_ptr<native::Region>> vsr;
         try
         {
           vsr = m_nativeptr->get()->subregions(recursive);
@@ -959,7 +959,7 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
           auto nativeptr = m_nativeptr->get()->getEntry(keyptr);
           return RegionEntry<TKey, TValue>::Create(nativeptr);
         }
@@ -976,7 +976,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        native::VectorOfRegionEntry vc;
+		std::vector<std::shared_ptr<native::RegionEntry>> vc;
         try
         {
           vc = m_nativeptr->get()->entries(recursive);
@@ -1013,7 +1013,7 @@ namespace Apache
 
         try
         {
-          native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
+          std::shared_ptr<native::CacheableKey> keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key);
           return m_nativeptr->get()->containsValueForKey(keyptr);
         }
         finally
@@ -1051,7 +1051,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
         try
         {
-          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
+          std::shared_ptr<native::Serializable> callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg);
           m_nativeptr->get()->clear(callbackptr);
         }
         finally
@@ -1076,7 +1076,7 @@ namespace Apache
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfRegionEntry vc;
+		std::vector<std::shared_ptr<native::RegionEntry>> vc;
         try
         {
           vc = m_nativeptr->get()->entries(false);
@@ -1138,7 +1138,7 @@ namespace Apache
         {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            native::VectorOfCacheableKey vecKeys;
+            std::vector<std::shared_ptr<native::CacheableKey>> vecKeys;
 
           for each(TKey item in keys)
           {
@@ -1164,7 +1164,7 @@ namespace Apache
         {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            native::VectorOfCacheableKey vecKeys;
+            std::vector<std::shared_ptr<native::CacheableKey>> vecKeys;
 
           for each(TKey item in keys)
           {
@@ -1228,7 +1228,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfCacheableKey vc;
+          std::vector<std::shared_ptr<native::CacheableKey>> vc;
         try
         {
           vc = m_nativeptr->get()->getInterestList();
@@ -1255,7 +1255,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          native::VectorOfCacheableString vc;
+          std::vector<std::shared_ptr<native::CacheableString>> vc;
         try
         {
           vc = m_nativeptr->get()->getInterestListRegex();
diff --git a/clicache/src/Region.hpp b/clicache/src/Region.hpp
index 03a9ad6f..04de85a7 100644
--- a/clicache/src/Region.hpp
+++ b/clicache/src/Region.hpp
@@ -264,7 +264,7 @@ namespace Apache
         /// </returns>
         //generic<class TKey, class TValue>
         inline static IRegion<TKey, TValue>^
-        Create( native::RegionPtr nativeptr )
+        Create( std::shared_ptr<native::Region> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew Region<TKey, TValue>( nativeptr );
@@ -281,14 +281,14 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Region( native::RegionPtr nativeptr )
+        inline Region( std::shared_ptr<native::Region> nativeptr )
 				{
           m_nativeptr = gcnew native_shared_ptr<native::Region>(nativeptr);
         }
 
-        inline apache::geode::client::SerializablePtr get(apache::geode::client::CacheableKeyPtr& key, apache::geode::client::SerializablePtr& callbackArg);
-        inline apache::geode::client::SerializablePtr get(apache::geode::client::CacheableKeyPtr& key);
-        bool AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2);
+        inline std::shared_ptr<apache::geode::client::Serializable> get(std::shared_ptr<apache::geode::client::CacheableKey>& key, std::shared_ptr<apache::geode::client::Serializable>& callbackArg);
+        inline std::shared_ptr<apache::geode::client::Serializable> get(std::shared_ptr<apache::geode::client::CacheableKey>& key);
+        bool AreValuesEqual(std::shared_ptr<apache::geode::client::Cacheable>& val1, std::shared_ptr<apache::geode::client::Cacheable>& val2);
         bool isPoolInMultiuserMode();
         
         native_shared_ptr<native::Region>^ m_nativeptr;
diff --git a/clicache/src/RegionAttributes.hpp b/clicache/src/RegionAttributes.hpp
index db7e6b3f..d2a0ef38 100644
--- a/clicache/src/RegionAttributes.hpp
+++ b/clicache/src/RegionAttributes.hpp
@@ -480,7 +480,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static RegionAttributes<TKey, TValue>^ Create(native::RegionAttributesPtr nativeptr)
+        inline static RegionAttributes<TKey, TValue>^ Create(std::shared_ptr<native::RegionAttributes> nativeptr)
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew RegionAttributes<TKey, TValue>( nativeptr );
@@ -497,7 +497,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline RegionAttributes<TKey, TValue>(native::RegionAttributesPtr nativeptr)
+        inline RegionAttributes<TKey, TValue>(std::shared_ptr<native::RegionAttributes> nativeptr)
         {
           m_nativeptr = gcnew native_shared_ptr<native::RegionAttributes>(nativeptr);
         }
diff --git a/clicache/src/RegionEntry.cpp b/clicache/src/RegionEntry.cpp
index 6cafac0e..f80ac5e8 100644
--- a/clicache/src/RegionEntry.cpp
+++ b/clicache/src/RegionEntry.cpp
@@ -72,7 +72,7 @@ namespace Apache
       generic<class TKey, class TValue>
       Apache::Geode::Client::CacheStatistics^ RegionEntry<TKey, TValue>::Statistics::get( )
       {
-        apache::geode::client::CacheStatisticsPtr nativeptr;
+        std::shared_ptr<apache::geode::client::CacheStatistics> nativeptr;
         try
         {
           nativeptr = m_nativeptr->get()->getStatistics();
diff --git a/clicache/src/RegionEntry.hpp b/clicache/src/RegionEntry.hpp
index 85c933f2..06df712c 100644
--- a/clicache/src/RegionEntry.hpp
+++ b/clicache/src/RegionEntry.hpp
@@ -162,7 +162,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Client::RegionEntry<TKey, TValue>^ Create( native::RegionEntryPtr nativeptr )
+        inline static Client::RegionEntry<TKey, TValue>^ Create( std::shared_ptr<native::RegionEntry> nativeptr )
         {
          return __nullptr == nativeptr ? nullptr :
             gcnew RegionEntry<TKey, TValue>( nativeptr );
@@ -175,7 +175,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline RegionEntry( native::RegionEntryPtr nativeptr )
+        inline RegionEntry( std::shared_ptr<native::RegionEntry> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::RegionEntry>(nativeptr);
         }
diff --git a/clicache/src/RegionEvent.cpp b/clicache/src/RegionEvent.cpp
index 059e130b..37663264 100644
--- a/clicache/src/RegionEvent.cpp
+++ b/clicache/src/RegionEvent.cpp
@@ -38,7 +38,7 @@ namespace Apache
       generic<class TKey, class TValue>
       Object^ RegionEvent<TKey, TValue>::CallbackArgument::get()
       {
-        apache::geode::client::SerializablePtr& valptr(m_nativeptr->getCallbackArgument());
+        std::shared_ptr<apache::geode::client::Serializable>& valptr(m_nativeptr->getCallbackArgument());
         return Serializable::GetManagedValueGeneric<Object^>( valptr );
       }
 
diff --git a/clicache/src/RegionFactory.cpp b/clicache/src/RegionFactory.cpp
index 61839024..d7656cac 100644
--- a/clicache/src/RegionFactory.cpp
+++ b/clicache/src/RegionFactory.cpp
@@ -175,7 +175,7 @@ namespace Apache
       RegionFactory^ RegionFactory::SetPersistenceManager( Client::IPersistenceManager<TKey, TValue>^ persistenceManager, 
           Properties<String^, String^>^ config)
       {
-        native::PersistenceManagerPtr persistenceManagerptr;
+        std::shared_ptr<native::PersistenceManager> persistenceManagerptr;
         if ( persistenceManager != nullptr ) {
           PersistenceManagerGeneric<TKey, TValue>^ clg = gcnew PersistenceManagerGeneric<TKey, TValue>();
           clg->SetPersistenceManager(persistenceManager);
@@ -379,7 +379,7 @@ namespace Apache
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetCacheLoader( Client::ICacheLoader<TKey, TValue>^ cacheLoader )
       {
-        native::CacheLoaderPtr loaderptr;
+        std::shared_ptr<native::CacheLoader> loaderptr;
         if ( cacheLoader != nullptr ) {
           CacheLoaderGeneric<TKey, TValue>^ clg = gcnew CacheLoaderGeneric<TKey, TValue>();
           clg->SetCacheLoader(cacheLoader);
@@ -400,7 +400,7 @@ namespace Apache
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetCacheWriter( Client::ICacheWriter<TKey, TValue>^ cacheWriter )
       {
-        native::CacheWriterPtr writerptr;
+        std::shared_ptr<native::CacheWriter> writerptr;
         if ( cacheWriter != nullptr ) {
           CacheWriterGeneric<TKey, TValue>^ cwg = gcnew CacheWriterGeneric<TKey, TValue>();
           cwg->SetCacheWriter(cacheWriter);
@@ -421,7 +421,7 @@ namespace Apache
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetCacheListener( Client::ICacheListener<TKey, TValue>^ cacheListener )
       {
-        native::CacheListenerPtr listenerptr;
+        std::shared_ptr<native::CacheListener> listenerptr;
         if ( cacheListener != nullptr ) {
           CacheListenerGeneric<TKey, TValue>^ clg = gcnew CacheListenerGeneric<TKey, TValue>();
           clg->SetCacheListener(cacheListener);
@@ -446,7 +446,7 @@ namespace Apache
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetPartitionResolver(Client::IPartitionResolver<TKey, TValue>^ partitionresolver)
       {
-        native::PartitionResolverPtr resolverptr;
+        std::shared_ptr<native::PartitionResolver> resolverptr;
         if (partitionresolver != nullptr) {
           Client::IFixedPartitionResolver<TKey, TValue>^ resolver =
             dynamic_cast<Client::IFixedPartitionResolver<TKey, TValue>^>(partitionresolver);
diff --git a/clicache/src/ResultCollector.hpp b/clicache/src/ResultCollector.hpp
index 27d628e2..50eec6c4 100644
--- a/clicache/src/ResultCollector.hpp
+++ b/clicache/src/ResultCollector.hpp
@@ -81,7 +81,7 @@ namespace Apache
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline ResultCollector( native::ResultCollectorPtr nativeptr )
+        inline ResultCollector( std::shared_ptr<native::ResultCollector> nativeptr )
         {
            m_nativeptr = gcnew native_shared_ptr<native::ResultCollector>(nativeptr);
         }
diff --git a/clicache/src/ResultSet.hpp b/clicache/src/ResultSet.hpp
index bc64edeb..408517aa 100644
--- a/clicache/src/ResultSet.hpp
+++ b/clicache/src/ResultSet.hpp
@@ -101,7 +101,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static ResultSet<TResult>^ Create(native::ResultSetPtr nativeptr)
+        inline static ResultSet<TResult>^ Create(std::shared_ptr<native::ResultSet> nativeptr)
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew ResultSet<TResult>( nativeptr );
@@ -117,7 +117,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline ResultSet(native::ResultSetPtr nativeptr)
+        inline ResultSet(std::shared_ptr<native::ResultSet> nativeptr)
         {
           m_nativeptr = gcnew native_shared_ptr<native::ResultSet>(nativeptr);
         }
diff --git a/clicache/src/Serializable.cpp b/clicache/src/Serializable.cpp
index 6a66948f..83365980 100644
--- a/clicache/src/Serializable.cpp
+++ b/clicache/src/Serializable.cpp
@@ -254,25 +254,25 @@ namespace Apache
 
       System::Int32 Serializable::GetPDXIdForType(const char* poolName, IGeodeSerializable^ pdxType, Cache^ cache)
       {
-        native::CacheablePtr kPtr(SafeMSerializableConvertGeneric(pdxType));
+        std::shared_ptr<native::Cacheable> kPtr(SafeMSerializableConvertGeneric(pdxType));
         return CacheRegionHelper::getCacheImpl(cache->GetNative().get())->getSerializationRegistry()->GetPDXIdForType(cache->GetNative()->getPoolManager().find(poolName), kPtr);
       }
 
       IGeodeSerializable^ Serializable::GetPDXTypeById(const char* poolName, System::Int32 typeId, Cache^ cache)
       {        
-        SerializablePtr sPtr = CacheRegionHelper::getCacheImpl(cache->GetNative().get())->getSerializationRegistry()->GetPDXTypeById(cache->GetNative()->getPoolManager().find(poolName), typeId);
+        std::shared_ptr<apache::geode::client::Serializable> sPtr = CacheRegionHelper::getCacheImpl(cache->GetNative().get())->getSerializationRegistry()->GetPDXTypeById(cache->GetNative()->getPoolManager().find(poolName), typeId);
         return SafeUMSerializableConvertGeneric(sPtr);
       }
 
       int Serializable::GetEnumValue(Internal::EnumInfo^ ei, Cache^ cache)
       {
-        native::CacheablePtr kPtr(SafeMSerializableConvertGeneric(ei));
+        std::shared_ptr<native::Cacheable> kPtr(SafeMSerializableConvertGeneric(ei));
         return  CacheRegionHelper::getCacheImpl(cache->GetNative().get())->getSerializationRegistry()->GetEnumValue(cache->GetNative()->getPoolManager().getAll().begin()->second, kPtr);
       }
 
       Internal::EnumInfo^ Serializable::GetEnum(int val, Cache^ cache)
       {
-        SerializablePtr sPtr = CacheRegionHelper::getCacheImpl(cache->GetNative().get())->getSerializationRegistry()->GetEnum(cache->GetNative()->getPoolManager().getAll().begin()->second, val);
+        std::shared_ptr<apache::geode::client::Serializable> sPtr = CacheRegionHelper::getCacheImpl(cache->GetNative().get())->getSerializationRegistry()->GetEnum(cache->GetNative()->getPoolManager().getAll().begin()->second, val);
         return (Internal::EnumInfo^)SafeUMSerializableConvertGeneric(sPtr);
       }
 
@@ -638,7 +638,7 @@ namespace Apache
       }
 
       generic<class TValue>
-      TValue Serializable::GetManagedValueGeneric(native::SerializablePtr val)
+      TValue Serializable::GetManagedValueGeneric(std::shared_ptr<native::Serializable> val)
       {
         if (val == nullptr)
         {
@@ -927,7 +927,7 @@ namespace Apache
       }
 
       generic<class TKey>
-      native::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(TKey key)
+      std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric(TKey key)
       {
         if (key != nullptr) {
           return GetUnmanagedValueGeneric(key->GetType(), key);
@@ -936,7 +936,7 @@ namespace Apache
       }
 
       generic<class TKey>
-      native::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(TKey key, bool isAciiChar)
+      std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric(TKey key, bool isAciiChar)
       {
         if (key != nullptr) {
           return GetUnmanagedValueGeneric(key->GetType(), key, isAciiChar);
@@ -1053,14 +1053,14 @@ namespace Apache
       }
 
       generic<class TKey>
-      native::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
+      std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric(
         Type^ managedType, TKey key)
       {
         return GetUnmanagedValueGeneric(managedType, key, false);
       }
 
       generic<class TKey>
-      native::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
+      std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric(
         Type^ managedType, TKey key, bool isAsciiChar)
       {
         Byte typeId = Apache::Geode::Client::Serializable::GetManagedTypeMappingGeneric(managedType);
@@ -1095,128 +1095,128 @@ namespace Apache
         }
         case native::GeodeTypeIds::CacheableBytes:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableDoubleArray:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableDoubleArray::Create((array<Double>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableDoubleArray::Create((array<Double>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableFloatArray:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableFloatArray::Create((array<float>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableFloatArray::Create((array<float>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableInt16Array:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableInt32Array:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableInt64Array:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableStringArray:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableStringArray::Create((array<String^>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableStringArray::Create((array<String^>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableFileName:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)(Apache::Geode::Client::CacheableFileName^)key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)(Apache::Geode::Client::CacheableFileName^)key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableHashTable://collection::hashtable
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableHashTable::Create((System::Collections::Hashtable^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableHashTable::Create((System::Collections::Hashtable^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableHashMap://generic dictionary
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableHashMap::Create((System::Collections::IDictionary^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableHashMap::Create((System::Collections::IDictionary^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableVector://collection::arraylist
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)CacheableVector::Create((System::Collections::IList^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)CacheableVector::Create((System::Collections::IList^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableArrayList://generic ilist
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableArrayList::Create((System::Collections::IList^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableArrayList::Create((System::Collections::IList^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableLinkedList://generic linked list
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableStack:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableStack::Create((System::Collections::ICollection^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableStack::Create((System::Collections::ICollection^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case 7: //GeodeClassIds::CacheableManagedObject
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObject^)key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObject^)key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case 8://GeodeClassIds::CacheableManagedObjectXml
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectXml^)key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectXml^)key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableObjectArray:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectArray^)key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectArray^)key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableIdentityHashMap:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableHashSet://no need of it, default case should work
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableHashSet^)key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableHashSet^)key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableLinkedHashSet^)key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableLinkedHashSet^)key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CacheableDate:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableDate::Create((System::DateTime)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CacheableDate::Create((System::DateTime)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::BooleanArray:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::BooleanArray::Create((array<bool>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::BooleanArray::Create((array<bool>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         case native::GeodeTypeIds::CharArray:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CharArray::Create((array<Char>^)key)));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert((IGeodeSerializable^)Apache::Geode::Client::CharArray::Create((array<Char>^)key)));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         default:
         {
-          native::CacheablePtr kPtr(SafeGenericMSerializableConvert(key));
+          std::shared_ptr<native::Cacheable> kPtr(SafeGenericMSerializableConvert(key));
           return std::dynamic_pointer_cast<native::CacheableKey>(kPtr);
         }
         }
       } //
 
-      String^ Serializable::GetString(native::CacheableStringPtr cStr)//native::CacheableString*
+      String^ Serializable::GetString(std::shared_ptr<native::CacheableString> cStr)//native::CacheableString*
       {
         if (cStr == nullptr) {
           return nullptr;
@@ -1232,153 +1232,153 @@ namespace Apache
       // These are the new static methods to get/put data from c++
 
       //byte
-      Byte Serializable::getByte(native::SerializablePtr nativeptr)
+      Byte Serializable::getByte(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableByte* ci = static_cast<native::CacheableByte*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableByte(SByte val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableByte(SByte val)
       {
         return native::CacheableByte::create(val);
       }
 
       //boolean
-      bool Serializable::getBoolean(native::SerializablePtr nativeptr)
+      bool Serializable::getBoolean(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableBoolean* ci = static_cast<native::CacheableBoolean*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableBoolean(bool val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableBoolean(bool val)
       {
         return native::CacheableBoolean::create(val);
       }
 
       //widechar
-      Char Serializable::getChar(native::SerializablePtr nativeptr)
+      Char Serializable::getChar(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableCharacter* ci = static_cast<native::CacheableCharacter*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableWideChar(Char val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableWideChar(Char val)
       {
         return native::CacheableCharacter::create(val);
       }
 
       //double
-      double Serializable::getDouble(native::SerializablePtr nativeptr)
+      double Serializable::getDouble(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableDouble* ci = static_cast<native::CacheableDouble*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableDouble(double val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableDouble(double val)
       {
         return native::CacheableDouble::create(val);
       }
 
       //float
-      float Serializable::getFloat(native::SerializablePtr nativeptr)
+      float Serializable::getFloat(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableFloat* ci = static_cast<native::CacheableFloat*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableFloat(float val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableFloat(float val)
       {
         return native::CacheableFloat::create(val);
       }
 
       //int16
-      System::Int16 Serializable::getInt16(native::SerializablePtr nativeptr)
+      System::Int16 Serializable::getInt16(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableInt16* ci = static_cast<native::CacheableInt16*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableInt16(int val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableInt16(int val)
       {
         return native::CacheableInt16::create(val);
       }
 
       //int32
-      System::Int32 Serializable::getInt32(native::SerializablePtr nativeptr)
+      System::Int32 Serializable::getInt32(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableInt32* ci = static_cast<native::CacheableInt32*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableInt32(System::Int32 val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableInt32(System::Int32 val)
       {
         return native::CacheableInt32::create(val);
       }
 
       //int64
-      System::Int64 Serializable::getInt64(native::SerializablePtr nativeptr)
+      System::Int64 Serializable::getInt64(std::shared_ptr<native::Serializable> nativeptr)
       {
         native::CacheableInt64* ci = static_cast<native::CacheableInt64*>(nativeptr.get());
         return ci->value();
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableInt64(System::Int64 val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableInt64(System::Int64 val)
       {
         return native::CacheableInt64::create(val);
       }
 
       //cacheable ascii string
-      String^ Serializable::getASCIIString(native::SerializablePtr nativeptr)
+      String^ Serializable::getASCIIString(std::shared_ptr<native::Serializable> nativeptr)
       {
         return GetString(nativeptr->toString());
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableASCIIString(String^ val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableASCIIString(String^ val)
       {
         return GetCacheableString(val);
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableASCIIString2(String^ val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableASCIIString2(String^ val)
       {
         return GetCacheableString2(val);
       }
 
       //cacheable ascii string huge
-      String^ Serializable::getASCIIStringHuge(native::SerializablePtr nativeptr)
+      String^ Serializable::getASCIIStringHuge(std::shared_ptr<native::Serializable> nativeptr)
       {
         return GetString(nativeptr->toString());
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableASCIIStringHuge(String^ val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableASCIIStringHuge(String^ val)
       {
         return GetCacheableString(val);
       }
 
       //cacheable string
-      String^ Serializable::getUTFString(native::SerializablePtr nativeptr)
+      String^ Serializable::getUTFString(std::shared_ptr<native::Serializable> nativeptr)
       {
         return GetString(nativeptr->toString());
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableUTFString(String^ val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableUTFString(String^ val)
       {
         return GetCacheableString(val);
       }
 
       //cacheable string huge
-      String^ Serializable::getUTFStringHuge(native::SerializablePtr nativeptr)
+      String^ Serializable::getUTFStringHuge(std::shared_ptr<native::Serializable> nativeptr)
       {
         return GetString(nativeptr->toString());
       }
 
-      native::CacheableKeyPtr Serializable::getCacheableUTFStringHuge(String^ val)
+      std::shared_ptr<native::CacheableKey> Serializable::getCacheableUTFStringHuge(String^ val)
       {
         return GetCacheableString(val);
       }
 
-      native::CacheableStringPtr Serializable::GetCacheableString(String^ value)
+      std::shared_ptr<native::CacheableString> Serializable::GetCacheableString(String^ value)
       {
-        native::CacheableStringPtr cStr;
+        std::shared_ptr<native::CacheableString> cStr;
         size_t len = 0;
         if (value != nullptr) {
           len = value->Length;
@@ -1393,9 +1393,9 @@ namespace Apache
         return cStr;
       }
 
-      native::CacheableStringPtr Serializable::GetCacheableString2(String^ value)
+      std::shared_ptr<native::CacheableString> Serializable::GetCacheableString2(String^ value)
       {
-        native::CacheableStringPtr cStr;
+        std::shared_ptr<native::CacheableString> cStr;
         size_t len = 0;
         if (value != nullptr) {
           len = value->Length;
diff --git a/clicache/src/Serializable.hpp b/clicache/src/Serializable.hpp
index b124c783..460bfae4 100644
--- a/clicache/src/Serializable.hpp
+++ b/clicache/src/Serializable.hpp
@@ -75,7 +75,7 @@ namespace Apache
       /// This delegate should return an object of type <c>IGeodeSerializable</c>
       /// given a native object.
       /// </remarks>
-      delegate Apache::Geode::Client::IGeodeSerializable^ WrapperDelegateGeneric(native::SerializablePtr obj);
+      delegate Apache::Geode::Client::IGeodeSerializable^ WrapperDelegateGeneric(std::shared_ptr<native::Serializable> obj);
 
 			/// <summary>
       /// Signature of function delegates passed to
@@ -318,81 +318,81 @@ namespace Apache
          static Dictionary<String^, PdxTypeFactoryMethod^>^ PdxDelegateMap =
           gcnew Dictionary<String^, PdxTypeFactoryMethod^>();
        
-        static String^ GetString(native::CacheableStringPtr cStr);//native::CacheableString*
+        static String^ GetString(std::shared_ptr<native::CacheableString> cStr);//native::CacheableString*
         
         // These are the new static methods to get/put data from c++
 
         //byte
-        static Byte getByte(native::SerializablePtr nativeptr);
+        static Byte getByte(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableByte(SByte val);
+        static std::shared_ptr<native::CacheableKey> getCacheableByte(SByte val);
         
         //boolean
-        static bool getBoolean(native::SerializablePtr nativeptr);
+        static bool getBoolean(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableBoolean(bool val);
+        static std::shared_ptr<native::CacheableKey> getCacheableBoolean(bool val);
         
         //widechar
-        static Char getChar(native::SerializablePtr nativeptr);
+        static Char getChar(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableWideChar(Char val);
+        static std::shared_ptr<native::CacheableKey> getCacheableWideChar(Char val);
         
         //double
-        static double getDouble(native::SerializablePtr nativeptr);
+        static double getDouble(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableDouble(double val);
+        static std::shared_ptr<native::CacheableKey> getCacheableDouble(double val);
         
         //float
-        static float getFloat(native::SerializablePtr nativeptr);
+        static float getFloat(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableFloat(float val);
+        static std::shared_ptr<native::CacheableKey> getCacheableFloat(float val);
         
         //int16
-        static System::Int16 getInt16(native::SerializablePtr nativeptr);
+        static System::Int16 getInt16(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableInt16(int val);
+        static std::shared_ptr<native::CacheableKey> getCacheableInt16(int val);
         
         //int32
-        static System::Int32 getInt32(native::SerializablePtr nativeptr);
+        static System::Int32 getInt32(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableInt32(System::Int32 val);
+        static std::shared_ptr<native::CacheableKey> getCacheableInt32(System::Int32 val);
         
         //int64
-        static System::Int64 getInt64(native::SerializablePtr nativeptr);
+        static System::Int64 getInt64(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableInt64(System::Int64 val);
+        static std::shared_ptr<native::CacheableKey> getCacheableInt64(System::Int64 val);
         
         //cacheable ascii string
-        static String^ getASCIIString(native::SerializablePtr nativeptr);        
+        static String^ getASCIIString(std::shared_ptr<native::Serializable> nativeptr);
 
-        static native::CacheableKeyPtr getCacheableASCIIString(String^ val);
+        static std::shared_ptr<native::CacheableKey> getCacheableASCIIString(String^ val);
 
-        static native::CacheableKeyPtr getCacheableASCIIString2(String^ val);
+        static std::shared_ptr<native::CacheableKey> getCacheableASCIIString2(String^ val);
         
         //cacheable ascii string huge
-        static String^ getASCIIStringHuge(native::SerializablePtr nativeptr);
+        static String^ getASCIIStringHuge(std::shared_ptr<native::Serializable> nativeptr);
         
-        static native::CacheableKeyPtr getCacheableASCIIStringHuge(String^ val);        
+        static std::shared_ptr<native::CacheableKey> getCacheableASCIIStringHuge(String^ val);
 
         //cacheable string
-        static String^ getUTFString(native::SerializablePtr nativeptr);        
+        static String^ getUTFString(std::shared_ptr<native::Serializable> nativeptr);
 
-        static native::CacheableKeyPtr getCacheableUTFString(String^ val);
+        static std::shared_ptr<native::CacheableKey> getCacheableUTFString(String^ val);
         
 
         //cacheable string huge
-        static String^ getUTFStringHuge(native::SerializablePtr nativeptr);
+        static String^ getUTFStringHuge(std::shared_ptr<native::Serializable> nativeptr);
         
 
-        static native::CacheableKeyPtr getCacheableUTFStringHuge(String^ val);
+        static std::shared_ptr<native::CacheableKey> getCacheableUTFStringHuge(String^ val);
         
 
-       static native::CacheableStringPtr GetCacheableString(String^ value);       
+       static std::shared_ptr<native::CacheableString> GetCacheableString(String^ value);
 
-       static native::CacheableStringPtr GetCacheableString2(String^ value); 
+       static std::shared_ptr<native::CacheableString> GetCacheableString2(String^ value);
 
        /*
-        static String^ GetString(native::CacheableStringPtr cStr)//native::CacheableString*
+        static String^ GetString(std::shared_ptr<native::CacheableString> cStr)//native::CacheableString*
         {
           if (cStr == nullptr) {
             return nullptr;
@@ -425,7 +425,7 @@ namespace Apache
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Apache::Geode::Client::Serializable(native::SerializablePtr nativeptr)
+        inline Apache::Geode::Client::Serializable(std::shared_ptr<native::Serializable> nativeptr)
         {
           m_nativeptr = gcnew native_shared_ptr<native::Serializable>(nativeptr);
         }
@@ -452,19 +452,19 @@ namespace Apache
         static void UnregisterTypeGeneric(Byte typeId, Cache^ cache);
 
         generic<class TValue>
-        static TValue GetManagedValueGeneric(native::SerializablePtr val);
+        static TValue GetManagedValueGeneric(std::shared_ptr<native::Serializable> val);
 
         generic<class TKey>
-        static native::CacheableKeyPtr GetUnmanagedValueGeneric(TKey key);
+        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(TKey key);
 
         generic<class TKey>
-        static native::CacheableKeyPtr GetUnmanagedValueGeneric(TKey key, bool isAciiChar);
+        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(TKey key, bool isAciiChar);
 
         generic<class TKey>
-        static native::CacheableKeyPtr GetUnmanagedValueGeneric(Type^ managedType, TKey key);
+        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(Type^ managedType, TKey key);
 
         generic<class TKey>
-        static native::CacheableKeyPtr GetUnmanagedValueGeneric(Type^ managedType, TKey key, bool isAsciiChar);
+        static std::shared_ptr<native::CacheableKey> GetUnmanagedValueGeneric(Type^ managedType, TKey key, bool isAsciiChar);
 
         /// <summary>
         /// Static map of <c>TypeFactoryMethod</c> delegates created
diff --git a/clicache/src/Struct.hpp b/clicache/src/Struct.hpp
index 9b438207..557927ae 100644
--- a/clicache/src/Struct.hpp
+++ b/clicache/src/Struct.hpp
@@ -117,7 +117,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Apache::Geode::Client::Struct/*<TResult>*/( apache::geode::client::SerializablePtr nativeptr )
+        inline Apache::Geode::Client::Struct/*<TResult>*/( std::shared_ptr<apache::geode::client::Serializable> nativeptr )
           : Apache::Geode::Client::Serializable( nativeptr ) { }
 
         inline Apache::Geode::Client::Struct/*<TResult>*/(  )
@@ -128,7 +128,7 @@ namespace Apache
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        inline static Apache::Geode::Client::IGeodeSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::apache::geode::client::SerializablePtr obj )
+        inline static Apache::Geode::Client::IGeodeSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::std::shared_ptr<apache::geode::client::Serializable> obj )
         {
           return ( obj != nullptr ?
             gcnew Apache::Geode::Client::Struct/*<TResult>*/( obj ) : nullptr );
diff --git a/clicache/src/StructSet.hpp b/clicache/src/StructSet.hpp
index ae81b764..7c649e9f 100644
--- a/clicache/src/StructSet.hpp
+++ b/clicache/src/StructSet.hpp
@@ -142,7 +142,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static StructSet<TResult>^ Create(native::StructSetPtr nativeptr)
+        inline static StructSet<TResult>^ Create(std::shared_ptr<native::StructSet> nativeptr)
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew StructSet<TResult>( nativeptr );
@@ -158,7 +158,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline StructSet(native::StructSetPtr nativeptr)
+        inline StructSet(std::shared_ptr<native::StructSet> nativeptr)
         {
           m_nativeptr = gcnew native_shared_ptr<native::StructSet>(nativeptr);
         }
diff --git a/clicache/src/TransactionEvent.cpp b/clicache/src/TransactionEvent.cpp
index 35d2750f..6eefbb15 100644
--- a/clicache/src/TransactionEvent.cpp
+++ b/clicache/src/TransactionEvent.cpp
@@ -46,7 +46,7 @@ namespace Apache
       generic<class TKey, class TValue>
 			Apache::Geode::Client::TransactionId^ TransactionEvent<TKey, TValue>::TransactionId::get( )
       {
-        apache::geode::client::TransactionIdPtr & nativeptr(
+        std::shared_ptr<apache::geode::client::TransactionId> & nativeptr(
           NativePtr->getTransactionId( ) );
 
 				return Apache::Geode::Client::TransactionId::Create(
@@ -56,14 +56,14 @@ namespace Apache
       generic<class TKey, class TValue>
       array<EntryEvent<TKey, TValue>^>^ TransactionEvent<TKey, TValue>::Events::get( )
       {
-        apache::geode::client::VectorOfEntryEvent vee;
+        std::vector<std::shared_ptr<apache::geode::client::EntryEvent>> vee;
         vee = NativePtr->getEvents();
         array<EntryEvent<TKey, TValue>^>^ events =
           gcnew array<EntryEvent<TKey, TValue>^>( vee.size( ) );
         // Loop through the unmanaged event objects to convert them to the managed generic objects. 
         for( System::Int32 index = 0; index < vee.size( ); index++ )
         {
-          apache::geode::client::EntryEventPtr& nativeptr( vee[ index ] );
+          std::shared_ptr<apache::geode::client::EntryEvent>& nativeptr( vee[ index ] );
           EntryEvent<TKey, TValue> entryEvent( nativeptr.get() );
           events[ index ] = (%entryEvent);
         }
diff --git a/clicache/src/TransactionId.hpp b/clicache/src/TransactionId.hpp
index 29ceeb83..21cba465 100644
--- a/clicache/src/TransactionId.hpp
+++ b/clicache/src/TransactionId.hpp
@@ -41,7 +41,7 @@ namespace Apache
         {
         internal:
 
-          inline static TransactionId^ Create(native::TransactionIdPtr nativeptr )
+          inline static TransactionId^ Create(std::shared_ptr<native::TransactionId> nativeptr )
           {
           return __nullptr == nativeptr ? nullptr :
             gcnew TransactionId( nativeptr );
@@ -58,7 +58,7 @@ namespace Apache
           /// Private constructor to wrap a native object pointer
           /// </summary>
           /// <param name="nativeptr">The native object pointer</param>
-          inline TransactionId( native::TransactionIdPtr nativeptr )
+          inline TransactionId( std::shared_ptr<native::TransactionId> nativeptr )
           {
             m_nativeptr = gcnew native_shared_ptr<native::TransactionId>(nativeptr);
           }
diff --git a/clicache/src/UserFunctionExecutionException.hpp b/clicache/src/UserFunctionExecutionException.hpp
index 3adbfa6c..90f58e27 100644
--- a/clicache/src/UserFunctionExecutionException.hpp
+++ b/clicache/src/UserFunctionExecutionException.hpp
@@ -129,7 +129,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer.
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline UserFunctionExecutionException(apache::geode::client::UserFunctionExecutionExceptionPtr nativeptr)
+        inline UserFunctionExecutionException(std::shared_ptr<apache::geode::client::UserFunctionExecutionException> nativeptr)
 				{
           m_nativeptr = gcnew native_shared_ptr<native::UserFunctionExecutionException>(nativeptr);
         }
diff --git a/clicache/src/impl/AuthenticatedCache.cpp b/clicache/src/impl/AuthenticatedCache.cpp
index e9871def..14fa38cd 100644
--- a/clicache/src/impl/AuthenticatedCache.cpp
+++ b/clicache/src/impl/AuthenticatedCache.cpp
@@ -108,7 +108,7 @@ namespace Apache
       generic<class TKey, class TValue>
       array<IRegion<TKey, TValue>^>^ AuthenticatedCache::RootRegions( )
       {
-        apache::geode::client::VectorOfRegion vrr;
+        std::vector<std::shared_ptr<apache::geode::client::Region>> vrr;
         try
         {
           vrr = m_nativeptr->get()->rootRegions( );
diff --git a/clicache/src/impl/AuthenticatedCache.hpp b/clicache/src/impl/AuthenticatedCache.hpp
index 7f0028f4..375c17fa 100644
--- a/clicache/src/impl/AuthenticatedCache.hpp
+++ b/clicache/src/impl/AuthenticatedCache.hpp
@@ -142,7 +142,7 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static AuthenticatedCache^ Create( native::RegionServicePtr nativeptr )
+        inline static AuthenticatedCache^ Create( std::shared_ptr<native::RegionService> nativeptr )
         {
           return __nullptr == nativeptr ? nullptr :
             gcnew AuthenticatedCache( nativeptr );
@@ -159,7 +159,7 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline AuthenticatedCache( native::RegionServicePtr nativeptr )
+        inline AuthenticatedCache( std::shared_ptr<native::RegionService> nativeptr )
         {
           m_nativeptr = gcnew native_shared_ptr<native::RegionService>(nativeptr);
         }
diff --git a/clicache/src/impl/CacheLoader.hpp b/clicache/src/impl/CacheLoader.hpp
index b8b3ca0d..8aacadfb 100644
--- a/clicache/src/impl/CacheLoader.hpp
+++ b/clicache/src/impl/CacheLoader.hpp
@@ -40,10 +40,10 @@ namespace Apache
       public interface class ICacheLoaderProxy
       {
       public:
-        apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region,
-          const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::SerializablePtr& helper );
+        std::shared_ptr<apache::geode::client::Cacheable> load( const std::shared_ptr<apache::geode::client::Region>& region,
+          const std::shared_ptr<apache::geode::client::CacheableKey>& key, const std::shared_ptr<apache::geode::client::Serializable>& helper );
 
-        void close( const apache::geode::client::RegionPtr& region );
+        void close( const std::shared_ptr<apache::geode::client::Region>& region );
       };
 
       generic<class TKey, class TValue>
@@ -60,8 +60,8 @@ namespace Apache
             m_loader = loader;
           }
 
-          virtual apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region,
-            const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::SerializablePtr& helper )
+          virtual std::shared_ptr<apache::geode::client::Cacheable> load( const std::shared_ptr<apache::geode::client::Region>& region,
+            const std::shared_ptr<apache::geode::client::CacheableKey>& key, const std::shared_ptr<apache::geode::client::Serializable>& helper )
           {
             IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region);
 
@@ -72,7 +72,7 @@ namespace Apache
             return Serializable::GetUnmanagedValueGeneric<TValue>(m_loader->Load(gregion, gkey, ghelper));
           }
 
-          virtual void close( const apache::geode::client::RegionPtr& region )
+          virtual void close( const std::shared_ptr<apache::geode::client::Region>& region )
           {
             IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region);
             m_loader->Close(gregion);
diff --git a/clicache/src/impl/FixedPartitionResolver.hpp b/clicache/src/impl/FixedPartitionResolver.hpp
index 03f57c9c..da6d870e 100644
--- a/clicache/src/impl/FixedPartitionResolver.hpp
+++ b/clicache/src/impl/FixedPartitionResolver.hpp
@@ -34,7 +34,7 @@ namespace Apache
       public interface class IFixedPartitionResolverProxy
       {
       public:
-        apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev);
+        std::shared_ptr<apache::geode::client::CacheableKey> getRoutingObject(const apache::geode::client::EntryEvent& ev);
         const char * getName();
         const char* getPartitionName(const apache::geode::client::EntryEvent& opDetails);       
       };
@@ -56,7 +56,7 @@ namespace Apache
             m_strList = gcnew Dictionary<String^, ManagedString^>();
           }
 
-          virtual apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev)
+          virtual std::shared_ptr<apache::geode::client::CacheableKey> getRoutingObject(const apache::geode::client::EntryEvent& ev)
           {
             EntryEvent<TKey, TValue> gevent(&ev);
 			      Object^ groutingobject = m_resolver->GetRoutingObject(%gevent);
diff --git a/clicache/src/impl/ManagedAuthInitialize.cpp b/clicache/src/impl/ManagedAuthInitialize.cpp
index ca071a79..b7042eb6 100644
--- a/clicache/src/impl/ManagedAuthInitialize.cpp
+++ b/clicache/src/impl/ManagedAuthInitialize.cpp
@@ -34,7 +34,7 @@ namespace apache
     namespace client
     {
 
-      PropertiesPtr ManagedAuthInitializeGeneric::getCredentials(const PropertiesPtr&
+      std::shared_ptr<Properties> ManagedAuthInitializeGeneric::getCredentials(const std::shared_ptr<Properties>&
                                                                  securityprops, const char* server)
       {
         try {
diff --git a/clicache/src/impl/ManagedAuthInitialize.hpp b/clicache/src/impl/ManagedAuthInitialize.hpp
index 83f79617..5457bec5 100644
--- a/clicache/src/impl/ManagedAuthInitialize.hpp
+++ b/clicache/src/impl/ManagedAuthInitialize.hpp
@@ -101,7 +101,7 @@ namespace apache
         /// </param>
         /// <param name="server">It is the ID of the endpoint
         /// </param>
-        virtual PropertiesPtr getCredentials(const PropertiesPtr& securityprops, const char* server);
+        virtual std::shared_ptr<Properties> getCredentials(const std::shared_ptr<Properties>& securityprops, const char* server);
 
         virtual ~ManagedAuthInitializeGeneric() { }
 
diff --git a/clicache/src/impl/ManagedCacheListener.cpp b/clicache/src/impl/ManagedCacheListener.cpp
index 844231f2..bc2b2e82 100644
--- a/clicache/src/impl/ManagedCacheListener.cpp
+++ b/clicache/src/impl/ManagedCacheListener.cpp
@@ -327,7 +327,7 @@ namespace apache
         }
       }
 
-      void ManagedCacheListenerGeneric::close(const apache::geode::client::RegionPtr& region)
+      void ManagedCacheListenerGeneric::close(const std::shared_ptr<apache::geode::client::Region>& region)
       {
         try {
           auto mregion = Apache::Geode::Client::Region<Object^, Object^>::Create(region);
@@ -341,7 +341,7 @@ namespace apache
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
-      void ManagedCacheListenerGeneric::afterRegionDisconnected(const apache::geode::client::RegionPtr& region)
+      void ManagedCacheListenerGeneric::afterRegionDisconnected(const std::shared_ptr<apache::geode::client::Region>& region)
       {
         try {
           auto mregion = Apache::Geode::Client::Region<Object^, Object^>::Create(region);
diff --git a/clicache/src/impl/ManagedCacheListener.hpp b/clicache/src/impl/ManagedCacheListener.hpp
index ccc80d72..f48ab078 100644
--- a/clicache/src/impl/ManagedCacheListener.hpp
+++ b/clicache/src/impl/ManagedCacheListener.hpp
@@ -181,7 +181,7 @@ namespace apache {
         /// </remarks>
         /// <seealso cref="Apache.Geode.Client.Cache.Close" />
         /// <seealso cref="Apache.Geode.Client.Region.DestroyRegion" />
-        virtual void close(const apache::geode::client::RegionPtr& region);
+        virtual void close(const std::shared_ptr<apache::geode::client::Region>& region);
 
         ///<summary>
         ///Called when all the endpoints associated with region are down.
@@ -194,7 +194,7 @@ namespace apache {
         ///<param>
         ///region Region^ denotes the assosiated region.
         ///</param>
-        virtual void afterRegionDisconnected(const apache::geode::client::RegionPtr& region);
+        virtual void afterRegionDisconnected(const std::shared_ptr<apache::geode::client::Region>& region);
 
         /// <summary>
         /// Returns the wrapped managed object reference.
diff --git a/clicache/src/impl/ManagedCacheLoader.cpp b/clicache/src/impl/ManagedCacheLoader.cpp
index c40de7de..e693a599 100644
--- a/clicache/src/impl/ManagedCacheLoader.cpp
+++ b/clicache/src/impl/ManagedCacheLoader.cpp
@@ -214,8 +214,8 @@ namespace apache
         return NULL;
       }
 
-      CacheablePtr ManagedCacheLoaderGeneric::load(const RegionPtr& region,
-                                                   const CacheableKeyPtr& key, const SerializablePtr& aCallbackArgument)
+      std::shared_ptr<Cacheable> ManagedCacheLoaderGeneric::load(const std::shared_ptr<Region>& region,
+                                                   const std::shared_ptr<CacheableKey>& key, const std::shared_ptr<Serializable>& aCallbackArgument)
       {
         try {
           return m_managedptr->load(region, key, aCallbackArgument);
@@ -229,7 +229,7 @@ namespace apache
         return nullptr;
       }
 
-      void ManagedCacheLoaderGeneric::close(const RegionPtr& region)
+      void ManagedCacheLoaderGeneric::close(const std::shared_ptr<Region>& region)
       {
         try {
           /*
diff --git a/clicache/src/impl/ManagedCacheLoader.hpp b/clicache/src/impl/ManagedCacheLoader.hpp
index 8b717ef8..74d1c188 100644
--- a/clicache/src/impl/ManagedCacheLoader.hpp
+++ b/clicache/src/impl/ManagedCacheLoader.hpp
@@ -96,8 +96,8 @@ namespace apache
         /// will return null.
         /// </returns>
         /// <seealso cref="Apache.Geode.Client.Region.Get" />
-        virtual CacheablePtr load(const RegionPtr& region,
-          const CacheableKeyPtr& key, const SerializablePtr& aCallbackArgument);
+        virtual std::shared_ptr<Cacheable> load(const std::shared_ptr<Region>& region,
+          const std::shared_ptr<CacheableKey>& key, const std::shared_ptr<Serializable>& aCallbackArgument);
 
         /// <summary>
         /// Called when the region containing this callback is destroyed, when
@@ -115,7 +115,7 @@ namespace apache
         /// <param name="region">the region pointer</param>
         /// <seealso cref="Apache.Geode.Client.Cache.Close" />
         /// <seealso cref="Apache.Geode.Client.Region.DestroyRegion" />
-        virtual void close(const RegionPtr& region);
+        virtual void close(const std::shared_ptr<Region>& region);
 
         /*
         /// <summary>
diff --git a/clicache/src/impl/ManagedCacheWriter.cpp b/clicache/src/impl/ManagedCacheWriter.cpp
index 821e27a5..8489c0f2 100644
--- a/clicache/src/impl/ManagedCacheWriter.cpp
+++ b/clicache/src/impl/ManagedCacheWriter.cpp
@@ -294,7 +294,7 @@ namespace apache
         return false;
       }
 
-      void ManagedCacheWriterGeneric::close(const RegionPtr& rp)
+      void ManagedCacheWriterGeneric::close(const std::shared_ptr<Region>& rp)
       {
         try {
           auto mregion = Apache::Geode::Client::Region<Object^, Object^>::Create(rp);
diff --git a/clicache/src/impl/ManagedCacheWriter.hpp b/clicache/src/impl/ManagedCacheWriter.hpp
index 0b6eba1b..6570f0d7 100644
--- a/clicache/src/impl/ManagedCacheWriter.hpp
+++ b/clicache/src/impl/ManagedCacheWriter.hpp
@@ -152,7 +152,7 @@ namespace apache
         /// </remarks>
         /// <seealso cref="Apache.Geode.Client.Cache.Close" />
         /// <seealso cref="Apache.Geode.Client.Region.DestroyRegion" />
-        void close(const RegionPtr& rp);
+        void close(const std::shared_ptr<Region>& rp);
 
         /// <summary>
         /// Returns the wrapped managed object reference.
diff --git a/clicache/src/impl/ManagedCacheableDelta.cpp b/clicache/src/impl/ManagedCacheableDelta.cpp
index c0538e06..5c996510 100644
--- a/clicache/src/impl/ManagedCacheableDelta.cpp
+++ b/clicache/src/impl/ManagedCacheableDelta.cpp
@@ -197,14 +197,14 @@ namespace apache
         }
       }
 
-      DeltaPtr ManagedCacheableDeltaGeneric::clone()
+      std::shared_ptr<Delta> ManagedCacheableDeltaGeneric::clone()
       {
         try {
           if (auto cloneable = dynamic_cast<ICloneable^>((
             Apache::Geode::Client::IGeodeDelta^) m_managedptr)) {
             auto Mclone = 
               dynamic_cast<Apache::Geode::Client::IGeodeSerializable^>(cloneable->Clone());
-            return DeltaPtr(static_cast<ManagedCacheableDeltaGeneric*>(
+            return std::shared_ptr<Delta>(static_cast<ManagedCacheableDeltaGeneric*>(
               SafeMSerializableConvertGeneric(Mclone)));
           }
           else {
diff --git a/clicache/src/impl/ManagedCacheableDelta.hpp b/clicache/src/impl/ManagedCacheableDelta.hpp
index ab168022..9fdc6571 100644
--- a/clicache/src/impl/ManagedCacheableDelta.hpp
+++ b/clicache/src/impl/ManagedCacheableDelta.hpp
@@ -134,7 +134,7 @@ namespace apache
 
         virtual bool hasDelta();
 
-        virtual apache::geode::client::DeltaPtr clone();
+        virtual std::shared_ptr<apache::geode::client::Delta> clone();
 
         /// <summary>
         /// return the hashcode for this key.
diff --git a/clicache/src/impl/ManagedCacheableKey.cpp b/clicache/src/impl/ManagedCacheableKey.cpp
index 2ba65969..154522ab 100644
--- a/clicache/src/impl/ManagedCacheableKey.cpp
+++ b/clicache/src/impl/ManagedCacheableKey.cpp
@@ -126,10 +126,10 @@ namespace apache
         return 0;
       }
 
-      apache::geode::client::CacheableStringPtr ManagedCacheableKeyGeneric::toString() const
+      std::shared_ptr<apache::geode::client::CacheableString> ManagedCacheableKeyGeneric::toString() const
       {
         try {
-          apache::geode::client::CacheableStringPtr cStr;
+          std::shared_ptr<apache::geode::client::CacheableString> cStr;
           Apache::Geode::Client::CacheableString::GetCacheableString(
             m_managedptr->ToString(), cStr);
           return cStr;
diff --git a/clicache/src/impl/ManagedCacheableKey.hpp b/clicache/src/impl/ManagedCacheableKey.hpp
index 7793743c..a8d29e70 100644
--- a/clicache/src/impl/ManagedCacheableKey.hpp
+++ b/clicache/src/impl/ManagedCacheableKey.hpp
@@ -125,7 +125,7 @@ namespace apache
         /// Display this object as 'string', which depends on the implementation in
         /// the managed class
         /// </summary>
-        virtual apache::geode::client::CacheableStringPtr toString() const;
+        virtual std::shared_ptr<apache::geode::client::CacheableString> toString() const;
 
         /// <summary>
         /// return true if this key matches other CacheableKey
diff --git a/clicache/src/impl/ManagedFixedPartitionResolver.cpp b/clicache/src/impl/ManagedFixedPartitionResolver.cpp
index 26f3f3bc..54ece650 100644
--- a/clicache/src/impl/ManagedFixedPartitionResolver.cpp
+++ b/clicache/src/impl/ManagedFixedPartitionResolver.cpp
@@ -214,7 +214,7 @@ namespace apache
         return NULL;
       }
 
-      CacheableKeyPtr ManagedFixedPartitionResolverGeneric::getRoutingObject(const EntryEvent& key)
+      std::shared_ptr<CacheableKey> ManagedFixedPartitionResolverGeneric::getRoutingObject(const EntryEvent& key)
       {
         try {
           return m_managedptr->getRoutingObject(key);
diff --git a/clicache/src/impl/ManagedFixedPartitionResolver.hpp b/clicache/src/impl/ManagedFixedPartitionResolver.hpp
index aba0bf0d..a7ed6144 100644
--- a/clicache/src/impl/ManagedFixedPartitionResolver.hpp
+++ b/clicache/src/impl/ManagedFixedPartitionResolver.hpp
@@ -83,7 +83,7 @@ namespace apache {
         /// key the detail of the entry event.
         /// </param>
 
-        virtual CacheableKeyPtr getRoutingObject(const EntryEvent& key);
+        virtual std::shared_ptr<CacheableKey> getRoutingObject(const EntryEvent& key);
 
         /// <summary>
         /// Returns the name of the FixedPartitionResolver.
diff --git a/clicache/src/impl/ManagedPartitionResolver.cpp b/clicache/src/impl/ManagedPartitionResolver.cpp
index 51279c5c..f36a9d84 100644
--- a/clicache/src/impl/ManagedPartitionResolver.cpp
+++ b/clicache/src/impl/ManagedPartitionResolver.cpp
@@ -218,7 +218,7 @@ namespace apache
         return NULL;
       }
 
-      CacheableKeyPtr ManagedPartitionResolverGeneric::getRoutingObject(const EntryEvent& key)
+      std::shared_ptr<CacheableKey> ManagedPartitionResolverGeneric::getRoutingObject(const EntryEvent& key)
       {
         try {
           return m_managedptr->getRoutingObject(key);
diff --git a/clicache/src/impl/ManagedPartitionResolver.hpp b/clicache/src/impl/ManagedPartitionResolver.hpp
index 9640cf98..3074e34b 100644
--- a/clicache/src/impl/ManagedPartitionResolver.hpp
+++ b/clicache/src/impl/ManagedPartitionResolver.hpp
@@ -85,7 +85,7 @@ namespace apache {
         /// key the detail of the entry event.
         /// </param>
 
-        virtual CacheableKeyPtr getRoutingObject(const EntryEvent& key);
+        virtual std::shared_ptr<CacheableKey> getRoutingObject(const EntryEvent& key);
 
         /// <summary>
         /// Returns the name of the PartitionResolver.
diff --git a/clicache/src/impl/ManagedPersistenceManager.cpp b/clicache/src/impl/ManagedPersistenceManager.cpp
index cdaf9bcf..0b5932a4 100644
--- a/clicache/src/impl/ManagedPersistenceManager.cpp
+++ b/clicache/src/impl/ManagedPersistenceManager.cpp
@@ -209,7 +209,7 @@ namespace apache
       }
 
 
-      void ManagedPersistenceManagerGeneric::write(const CacheableKeyPtr&  key, const CacheablePtr&  value, void *& PersistenceInfo)
+      void ManagedPersistenceManagerGeneric::write(const std::shared_ptr<CacheableKey>&  key, const std::shared_ptr<Cacheable>&  value, void *& PersistenceInfo)
       {
         m_managedptr->write(key, value);
       }
@@ -219,12 +219,12 @@ namespace apache
         throw gcnew System::NotSupportedException;
       }
 
-      void ManagedPersistenceManagerGeneric::init(const RegionPtr& region, const PropertiesPtr& diskProperties)
+      void ManagedPersistenceManagerGeneric::init(const std::shared_ptr<Region>& region, const std::shared_ptr<Properties>& diskProperties)
       {
         m_managedptr->init(region, diskProperties);
       }
 
-      CacheablePtr ManagedPersistenceManagerGeneric::read(const CacheableKeyPtr& key, void *& PersistenceInfo)
+      std::shared_ptr<Cacheable> ManagedPersistenceManagerGeneric::read(const std::shared_ptr<CacheableKey>& key, void *& PersistenceInfo)
       {
         return m_managedptr->read(key);
       }
@@ -234,7 +234,7 @@ namespace apache
         throw gcnew System::NotSupportedException;
       }
 
-      void ManagedPersistenceManagerGeneric::destroy(const CacheableKeyPtr& key, void *& PersistenceInfo)
+      void ManagedPersistenceManagerGeneric::destroy(const std::shared_ptr<CacheableKey>& key, void *& PersistenceInfo)
       {
         m_managedptr->destroy(key);
       }
diff --git a/clicache/src/impl/ManagedPersistenceManager.hpp b/clicache/src/impl/ManagedPersistenceManager.hpp
index 81dfa621..13d17269 100644
--- a/clicache/src/impl/ManagedPersistenceManager.hpp
+++ b/clicache/src/impl/ManagedPersistenceManager.hpp
@@ -45,12 +45,12 @@ namespace apache {
         virtual ~ManagedPersistenceManagerGeneric() { }
 
 
-        virtual void write(const CacheableKeyPtr&  key, const CacheablePtr&  value, void *& PersistenceInfo);
+        virtual void write(const std::shared_ptr<CacheableKey>&  key, const std::shared_ptr<Cacheable>&  value, void *& PersistenceInfo);
         virtual bool writeAll();
-        virtual void init(const RegionPtr& region, const PropertiesPtr& diskProperties);
-        virtual CacheablePtr read(const CacheableKeyPtr& key, void *& PersistenceInfo);
+        virtual void init(const std::shared_ptr<Region>& region, const std::shared_ptr<Properties>& diskProperties);
+        virtual std::shared_ptr<Cacheable> read(const std::shared_ptr<CacheableKey>& key, void *& PersistenceInfo);
         virtual bool readAll();
-        virtual void destroy(const CacheableKeyPtr& key, void *& PersistenceInfo);
+        virtual void destroy(const std::shared_ptr<CacheableKey>& key, void *& PersistenceInfo);
         virtual void close();
 
         inline void setptr(Apache::Geode::Client::IPersistenceManagerProxy^ managedptr)
diff --git a/clicache/src/impl/ManagedResultCollector.cpp b/clicache/src/impl/ManagedResultCollector.cpp
index 49a9cb8e..8319b2a3 100644
--- a/clicache/src/impl/ManagedResultCollector.cpp
+++ b/clicache/src/impl/ManagedResultCollector.cpp
@@ -146,7 +146,7 @@ namespace apache
         return NULL;
       }
 
-      void ManagedResultCollectorGeneric::addResult(const CacheablePtr& result)
+      void ManagedResultCollectorGeneric::addResult(const std::shared_ptr<Cacheable>& result)
       {
         try {
           Object^ rs = Apache::Geode::Client::Serializable::GetManagedValueGeneric<Object^>(result);
@@ -164,15 +164,15 @@ namespace apache
         }
       }
 
-      CacheableVectorPtr ManagedResultCollectorGeneric::getResult(std::chrono::milliseconds timeout)
+      std::shared_ptr<CacheableVector> ManagedResultCollectorGeneric::getResult(std::chrono::milliseconds timeout)
       {
         try {
           //array<IGeodeSerializable^>^ rs = m_managedptr->GetResult(timeout);
-          //apache::geode::client::CacheableVectorPtr rsptr = apache::geode::client::CacheableVector::create();
+          //std::shared_ptr<apache::geode::client::CacheableVector> rsptr = apache::geode::client::CacheableVector::create();
           //for( int index = 0; index < rs->Length; index++ )
           //{
-          //  //apache::geode::client::CacheablePtr valueptr(Apache::Geode::Client::Serializable::GetUnmanagedValueGeneric<IGeodeSerializable^>(rs[ index]));
-          //  apache::geode::client::CacheablePtr valueptr (SafeMSerializableConvert(rs[ index]));
+          //  //std::shared_ptr<apache::geode::client::Cacheable> valueptr(Apache::Geode::Client::Serializable::GetUnmanagedValueGeneric<IGeodeSerializable^>(rs[ index]));
+          //  std::shared_ptr<apache::geode::client::Cacheable> valueptr (SafeMSerializableConvert(rs[ index]));
           //  rsptr->push_back(valueptr);
           //}
           //return rsptr;
diff --git a/clicache/src/impl/ManagedResultCollector.hpp b/clicache/src/impl/ManagedResultCollector.hpp
index 3706b724..c2063975 100644
--- a/clicache/src/impl/ManagedResultCollector.hpp
+++ b/clicache/src/impl/ManagedResultCollector.hpp
@@ -74,8 +74,8 @@ namespace apache {
         /// </summary>
         virtual ~ManagedResultCollectorGeneric() { }
 
-        CacheableVectorPtr getResult(std::chrono::milliseconds timeout = native::DEFAULT_QUERY_RESPONSE_TIMEOUT) override;
-        void addResult(const CacheablePtr& result) override;
+        std::shared_ptr<CacheableVector> getResult(std::chrono::milliseconds timeout = native::DEFAULT_QUERY_RESPONSE_TIMEOUT) override;
+        void addResult(const std::shared_ptr<Cacheable>& result) override;
         void endResults() override;
         void clearResults() override;
 
diff --git a/clicache/src/impl/ManagedTransactionListener.cpp b/clicache/src/impl/ManagedTransactionListener.cpp
index 99a683b6..7caa9735 100644
--- a/clicache/src/impl/ManagedTransactionListener.cpp
+++ b/clicache/src/impl/ManagedTransactionListener.cpp
@@ -200,7 +200,7 @@ namespace apache
         }
         return NULL;
       }
-      void ManagedTransactionListenerGeneric::afterCommit(apache::geode::client::TransactionEventPtr& te)
+      void ManagedTransactionListenerGeneric::afterCommit(std::shared_ptr<apache::geode::client::TransactionEvent>& te)
       {
         try {
           Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
@@ -216,7 +216,7 @@ namespace apache
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
-      void ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr& te)
+      void ManagedTransactionListenerGeneric::afterFailedCommit(std::shared_ptr<apache::geode::client::TransactionEvent>& te)
       {
         try {
           Apache::Geode::Client::TransactionEvent mevent(te.get());
@@ -229,7 +229,7 @@ namespace apache
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
-      void ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr& te)
+      void ManagedTransactionListenerGeneric::afterRollback(std::shared_ptr<apache::geode::client::TransactionEvent>& te)
       {
         try {
           Apache::Geode::Client::TransactionEvent mevent(te.get());
diff --git a/clicache/src/impl/ManagedTransactionListener.hpp b/clicache/src/impl/ManagedTransactionListener.hpp
index cd483758..5767c92f 100644
--- a/clicache/src/impl/ManagedTransactionListener.hpp
+++ b/clicache/src/impl/ManagedTransactionListener.hpp
@@ -51,11 +51,11 @@ namespace apache {
 
         virtual ~ManagedTransactionListenerGeneric( ) { }
 
-        virtual void afterCommit(apache::geode::client::TransactionEventPtr& te);
+        virtual void afterCommit(std::shared_ptr<apache::geode::client::TransactionEvent>& te);
 
-        virtual void afterFailedCommit(apache::geode::client::TransactionEventPtr& te);
+        virtual void afterFailedCommit(std::shared_ptr<apache::geode::client::TransactionEvent>& te);
 
-        virtual void afterRollback(apache::geode::client::TransactionEventPtr& te);
+        virtual void afterRollback(std::shared_ptr<apache::geode::client::TransactionEvent>& te);
 
         virtual void close();
 
diff --git a/clicache/src/impl/ManagedTransactionWriter.cpp b/clicache/src/impl/ManagedTransactionWriter.cpp
index bde9cbef..2ca7e251 100644
--- a/clicache/src/impl/ManagedTransactionWriter.cpp
+++ b/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -201,7 +201,7 @@ namespace apache
         }
         return NULL;
       }
-      void ManagedTransactionWriterGeneric::beforeCommit(apache::geode::client::TransactionEventPtr& te)
+      void ManagedTransactionWriterGeneric::beforeCommit(std::shared_ptr<apache::geode::client::TransactionEvent>& te)
       {
         try {
           Apache::Geode::Client::TransactionEvent  mevent(te.get());
diff --git a/clicache/src/impl/ManagedTransactionWriter.hpp b/clicache/src/impl/ManagedTransactionWriter.hpp
index b4871cbf..f8db0228 100644
--- a/clicache/src/impl/ManagedTransactionWriter.hpp
+++ b/clicache/src/impl/ManagedTransactionWriter.hpp
@@ -60,7 +60,7 @@ namespace apache {
 
         virtual ~ManagedTransactionWriterGeneric( ) { }
 
-        virtual void beforeCommit(apache::geode::client::TransactionEventPtr& te);
+        virtual void beforeCommit(std::shared_ptr<apache::geode::client::TransactionEvent>& te);
 
         inline Apache::Geode::Client::ITransactionWriter^ ptr( ) const
         {
diff --git a/clicache/src/impl/ManagedVisitor.cpp b/clicache/src/impl/ManagedVisitor.cpp
index 568de28a..e619c6ff 100644
--- a/clicache/src/impl/ManagedVisitor.cpp
+++ b/clicache/src/impl/ManagedVisitor.cpp
@@ -30,7 +30,7 @@ namespace apache
     namespace client
     {
 
-      void ManagedVisitorGeneric::visit(const CacheableKeyPtr& key, const CacheablePtr& value)
+      void ManagedVisitorGeneric::visit(const std::shared_ptr<CacheableKey>& key, const std::shared_ptr<Cacheable>& value)
       {
         using namespace Apache::Geode::Client;
         try {
diff --git a/clicache/src/impl/ManagedVisitor.hpp b/clicache/src/impl/ManagedVisitor.hpp
index 865e87cf..98dd7cca 100644
--- a/clicache/src/impl/ManagedVisitor.hpp
+++ b/clicache/src/impl/ManagedVisitor.hpp
@@ -52,7 +52,7 @@ namespace apache
         /// Invokes the managed <c>PropertyVisitor</c> delegate for the given
         /// <c>Property</c> key and value.
         /// </summary>
-        virtual void visit(const CacheableKeyPtr& key, const CacheablePtr& value);
+        virtual void visit(const std::shared_ptr<CacheableKey>& key, const std::shared_ptr<Cacheable>& value);
 
         /// <summary>
         /// Destructor -- does nothing.
diff --git a/clicache/src/impl/PartitionResolver.hpp b/clicache/src/impl/PartitionResolver.hpp
index 543ea074..aaec4d33 100644
--- a/clicache/src/impl/PartitionResolver.hpp
+++ b/clicache/src/impl/PartitionResolver.hpp
@@ -37,7 +37,7 @@ namespace Apache
       public interface class IPartitionResolverProxy
       {
       public:
-        apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev);
+        std::shared_ptr<apache::geode::client::CacheableKey> getRoutingObject(const apache::geode::client::EntryEvent& ev);
         const char * getName();
       };
 
@@ -55,7 +55,7 @@ namespace Apache
             m_resolver = resolver;
           }
 
-          virtual apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev)
+          virtual std::shared_ptr<apache::geode::client::CacheableKey> getRoutingObject(const apache::geode::client::EntryEvent& ev)
           {
             EntryEvent<TKey, TValue> gevent(&ev);
 						Object^ groutingobject = m_resolver->GetRoutingObject(%gevent);
diff --git a/clicache/src/impl/PdxManagedCacheableKey.cpp b/clicache/src/impl/PdxManagedCacheableKey.cpp
index 950cc692..a1f0b51f 100644
--- a/clicache/src/impl/PdxManagedCacheableKey.cpp
+++ b/clicache/src/impl/PdxManagedCacheableKey.cpp
@@ -147,10 +147,10 @@ namespace apache
         return 0;
       }
 
-      apache::geode::client::CacheableStringPtr PdxManagedCacheableKey::toString() const
+      std::shared_ptr<apache::geode::client::CacheableString> PdxManagedCacheableKey::toString() const
       {
         try {
-          apache::geode::client::CacheableStringPtr cStr;
+          std::shared_ptr<apache::geode::client::CacheableString> cStr;
           Apache::Geode::Client::CacheableString::GetCacheableString(
             m_managedptr->ToString(), cStr);
           return cStr;
@@ -284,12 +284,12 @@ namespace apache
         }
       }
 
-      DeltaPtr PdxManagedCacheableKey::clone()
+      std::shared_ptr<Delta> PdxManagedCacheableKey::clone()
       {
         try {
           if (auto cloneable = dynamic_cast<ICloneable^>((Apache::Geode::Client::IGeodeDelta^) m_managedDeltaptr)) {
             auto Mclone = dynamic_cast<Apache::Geode::Client::IPdxSerializable^>(cloneable->Clone());
-            return DeltaPtr(static_cast<PdxManagedCacheableKey*>(SafeGenericM2UMConvert(Mclone)));
+            return std::shared_ptr<Delta>(static_cast<PdxManagedCacheableKey*>(SafeGenericM2UMConvert(Mclone)));
           } else {
             return Delta::clone();
           }
diff --git a/clicache/src/impl/PdxManagedCacheableKey.hpp b/clicache/src/impl/PdxManagedCacheableKey.hpp
index 8a8885cc..1ec73660 100644
--- a/clicache/src/impl/PdxManagedCacheableKey.hpp
+++ b/clicache/src/impl/PdxManagedCacheableKey.hpp
@@ -105,7 +105,7 @@ namespace apache
 
         virtual bool hasDelta();
 
-        virtual apache::geode::client::DeltaPtr clone();
+        virtual std::shared_ptr<apache::geode::client::Delta> clone();
 
         /// <summary>
         /// return the size of this object in bytes
@@ -140,7 +140,7 @@ namespace apache
         /// Display this object as 'string', which depends on the implementation in
         /// the managed class
         /// </summary>
-        virtual apache::geode::client::CacheableStringPtr toString() const;
+        virtual std::shared_ptr<apache::geode::client::CacheableString> toString() const;
 
         /// <summary>
         /// return true if this key matches other CacheableKey
diff --git a/clicache/src/impl/PersistenceManagerProxy.hpp b/clicache/src/impl/PersistenceManagerProxy.hpp
index e450c685..d98f78da 100644
--- a/clicache/src/impl/PersistenceManagerProxy.hpp
+++ b/clicache/src/impl/PersistenceManagerProxy.hpp
@@ -20,6 +20,9 @@
 #include "SafeConvert.hpp"
 #include "../Region.hpp"
 #include "../Properties.hpp"
+#include "begin_native.hpp"
+#include <memory>
+#include "end_native.hpp"
 using namespace System;
 namespace Apache
 {
@@ -27,16 +30,16 @@ namespace Apache
   {
     namespace Client
     {
-
+		namespace native = apache::geode::client;
         public interface class IPersistenceManagerProxy
         {
           public:
-            void write(const CacheableKeyPtr&  key, const CacheablePtr&  value/*, void *& PersistenceInfo*/);
+            void write(const std::shared_ptr<native::CacheableKey>&  key, const std::shared_ptr<native::Cacheable>&  value/*, void *& PersistenceInfo*/);
             bool writeAll();
-            void init(const RegionPtr& region, const PropertiesPtr& diskProperties);
-            CacheablePtr read(const CacheableKeyPtr& key/*, void *& PersistenceInfo*/);
+            void init(const std::shared_ptr<native::Region>& region, const std::shared_ptr<native::Properties>& diskProperties);
+            std::shared_ptr<native::Cacheable> read(const std::shared_ptr<native::CacheableKey>& key/*, void *& PersistenceInfo*/);
             bool readAll();
-            void destroy(const CacheableKeyPtr& key/*, void *& PersistenceInfo*/);
+            void destroy(const std::shared_ptr<native::CacheableKey>& key/*, void *& PersistenceInfo*/);
             void close();
         };
 
@@ -50,7 +53,7 @@ namespace Apache
             {
               m_persistenceManager = persistenceManager;
             }
-            virtual void write(const CacheableKeyPtr&  key, const CacheablePtr&  value/*, void *& PersistenceInfo*/)
+            virtual void write(const std::shared_ptr<native::CacheableKey>&  key, const std::shared_ptr<native::Cacheable>&  value/*, void *& PersistenceInfo*/)
             {
                TKey gKey = Serializable::GetManagedValueGeneric<TKey>(key);
                TValue gValue = Serializable::GetManagedValueGeneric<TValue>(value);
@@ -62,14 +65,14 @@ namespace Apache
               throw gcnew System::NotSupportedException;
             }
 
-            virtual void init(const RegionPtr& region, const PropertiesPtr& diskProperties)
+            virtual void init(const std::shared_ptr<native::Region>& region, const std::shared_ptr<native::Properties>& diskProperties)
             {
               auto gRegion = Region<TKey, TValue>::Create(region);
               auto gProps = Properties<String^, String^>::Create(diskProperties);
               m_persistenceManager->Init(gRegion, gProps);
             }
             
-            virtual CacheablePtr read(const CacheableKeyPtr& key/*, void *& PersistenceInfo*/)
+            virtual std::shared_ptr<native::Cacheable> read(const std::shared_ptr<native::CacheableKey>& key/*, void *& PersistenceInfo*/)
             {
               TKey gKey = Serializable::GetManagedValueGeneric<TKey>(key);
               return Serializable::GetUnmanagedValueGeneric<TValue>(m_persistenceManager->Read(gKey));
@@ -80,7 +83,7 @@ namespace Apache
               throw gcnew System::NotSupportedException;
             }
             
-            virtual void destroy(const CacheableKeyPtr& key/*, void *& PersistenceInfo*/)
+            virtual void destroy(const std::shared_ptr<native::CacheableKey>& key/*, void *& PersistenceInfo*/)
             {
               TKey gKey = Serializable::GetManagedValueGeneric<TKey>(key);
               m_persistenceManager->Destroy(gKey);
diff --git a/clicache/src/impl/ResultCollectorProxy.hpp b/clicache/src/impl/ResultCollectorProxy.hpp
index 01b1b6a3..da8a98ad 100644
--- a/clicache/src/impl/ResultCollectorProxy.hpp
+++ b/clicache/src/impl/ResultCollectorProxy.hpp
@@ -54,7 +54,7 @@ namespace Apache
 
           virtual void AddResult( const Object^ rs ) 
           {
-            //apache::geode::client::CacheablePtr nativeptr(rs);
+            //std::shared_ptr<apache::geode::client::Cacheable> nativeptr(rs);
             //TResult grs =  Serializable::GetManagedValueGeneric<TResult>( nativeptr);
             m_rscoll->AddResult(safe_cast<const TResult>(rs));
           }
diff --git a/clicache/src/impl/SafeConvert.hpp b/clicache/src/impl/SafeConvert.hpp
index ae1ee46e..0b72dacd 100644
--- a/clicache/src/impl/SafeConvert.hpp
+++ b/clicache/src/impl/SafeConvert.hpp
@@ -60,7 +60,7 @@ namespace Apache
       /// to managed <see cref="IGeodeSerializable" /> object.
       /// </summary>
       inline static Apache::Geode::Client::IGeodeSerializable^
-        SafeUMSerializableConvertGeneric(native::SerializablePtr obj)
+        SafeUMSerializableConvertGeneric(std::shared_ptr<native::Serializable> obj)
       {
         if (obj == nullptr) return nullptr;
 
@@ -138,7 +138,7 @@ namespace Apache
       }
 
       generic<class TValue>
-      inline static TValue SafeGenericUMSerializableConvert( native::SerializablePtr obj )
+      inline static TValue SafeGenericUMSerializableConvert( std::shared_ptr<native::Serializable> obj )
       {
 
         if (obj == nullptr) return TValue();
@@ -220,7 +220,7 @@ namespace Apache
         return SafeGenericM2UMConvert<TValue>( mg_obj );
       }
 
-			inline static IPdxSerializable^ SafeUMSerializablePDXConvert( native::SerializablePtr obj )
+      inline static IPdxSerializable^ SafeUMSerializablePDXConvert( std::shared_ptr<native::Serializable> obj )
       {
          if(auto mg_obj = std::dynamic_pointer_cast<native::PdxManagedCacheableKey>( obj ))
            return mg_obj->ptr();
@@ -233,7 +233,7 @@ namespace Apache
       /// to managed <see cref="ICacheableKey" /> object.
       /// </summary>
       generic<class TKey>
-      inline static Client::ICacheableKey^ SafeGenericUMKeyConvert( native::CacheableKeyPtr obj )
+      inline static Client::ICacheableKey^ SafeGenericUMKeyConvert( std::shared_ptr<native::CacheableKey> obj )
       {
         //All cacheables will be ManagedCacheableKey only
         if (obj == nullptr) return nullptr;
diff --git a/contrib/pdxautoserializer/src/impl/CPPCodeGenerator.cpp b/contrib/pdxautoserializer/src/impl/CPPCodeGenerator.cpp
index 22060037..87054956 100644
--- a/contrib/pdxautoserializer/src/impl/CPPCodeGenerator.cpp
+++ b/contrib/pdxautoserializer/src/impl/CPPCodeGenerator.cpp
@@ -220,14 +220,16 @@ void CPPCodeGenerator::startMethod(const Method::Type type,
 
   switch (type) {
     case Method::TODATA: {
-      varVec.push_back("apache::geode::client::PdxWriterPtr __var");
+      varVec.push_back(
+          "std::shared_ptr<apache::geode::client::PdxWriter> __var");
 
       genFunctionHeader("toData", className, "void", varVec, true, false,
                         m_cppFormatter, methodPrefix);
       break;
     }
     case Method::FROMDATA: {
-      varVec.push_back("apache::geode::client::PdxReaderPtr __var ");
+      varVec.push_back(
+          "std::shared_ptr<apache::geode::client::PdxReader> __var ");
 
       genFunctionHeader("fromData", className, "void", varVec, true, false,
                         m_cppFormatter, methodPrefix);
diff --git a/cppcache/include/geode/AttributesFactory.hpp b/cppcache/include/geode/AttributesFactory.hpp
index ef05e20e..22941b6e 100644
--- a/cppcache/include/geode/AttributesFactory.hpp
+++ b/cppcache/include/geode/AttributesFactory.hpp
@@ -172,7 +172,7 @@ class CPPCACHE_EXPORT AttributesFactory {
    * @param regionAttributes the <code>RegionAttributes</code> used to
    * initialize this AttributesFactory
    */
-  AttributesFactory(const RegionAttributesPtr& regionAttributes);
+  AttributesFactory(const std::shared_ptr<RegionAttributes>& regionAttributes);
 
   /**
    *@brief destructor
@@ -184,23 +184,24 @@ class CPPCACHE_EXPORT AttributesFactory {
   /** Sets the cache loader for the next <code>RegionAttributes</code> created.
    * @param cacheLoader the cache loader or nullptr if no loader
    */
-  void setCacheLoader(const CacheLoaderPtr& cacheLoader);
+  void setCacheLoader(const std::shared_ptr<CacheLoader>& cacheLoader);
 
   /** Sets the cache writer for the next <code>RegionAttributes</code> created.
    * @param cacheWriter the cache writer or nullptr if no cache writer
    */
-  void setCacheWriter(const CacheWriterPtr& cacheWriter);
+  void setCacheWriter(const std::shared_ptr<CacheWriter>& cacheWriter);
 
   /** Sets the CacheListener for the next <code>RegionAttributes</code> created.
    * @param aListener a user defined CacheListener, nullptr if no listener
    */
-  void setCacheListener(const CacheListenerPtr& aListener);
+  void setCacheListener(const std::shared_ptr<CacheListener>& aListener);
 
   /** Sets the PartitionResolver for the next <code>RegionAttributes</code>
    * created.
    * @param aResolver a user defined PartitionResolver, nullptr if no resolver
    */
-  void setPartitionResolver(const PartitionResolverPtr& aResolver);
+  void setPartitionResolver(
+      const std::shared_ptr<PartitionResolver>& aResolver);
 
   /**
    * Sets the library path for the library that will be invoked for the loader
@@ -281,16 +282,18 @@ class CPPCACHE_EXPORT AttributesFactory {
    * directly, then
    * this must be used to set the PersistenceManager.
    */
-  void setPersistenceManager(const char* libpath, const char* factoryFuncName,
-                             const PropertiesPtr& config = nullptr);
+  void setPersistenceManager(
+      const char* libpath, const char* factoryFuncName,
+      const std::shared_ptr<Properties>& config = nullptr);
 
   /** Sets the PersistenceManager for the next <code>RegionAttributes</code>
    * created.
    * @param persistenceManager a user defined PersistenceManager, nullptr if no
    * resolver
    */
-  void setPersistenceManager(const PersistenceManagerPtr& persistenceManager,
-                             const PropertiesPtr& config = nullptr);
+  void setPersistenceManager(
+      const std::shared_ptr<PersistenceManager>& persistenceManager,
+      const std::shared_ptr<Properties>& config = nullptr);
 
  public:
   // DISTRIBUTION ATTRIBUTES
diff --git a/cppcache/include/geode/AttributesMutator.hpp b/cppcache/include/geode/AttributesMutator.hpp
index 485f2a8b..363d2712 100644
--- a/cppcache/include/geode/AttributesMutator.hpp
+++ b/cppcache/include/geode/AttributesMutator.hpp
@@ -38,7 +38,7 @@ namespace client {
 class CacheListener;
 class CacheLoader;
 class CacheWriter;
-
+class Region;
 /**
  * @class AttributesMutator AttributesMutator.hpp
  *
@@ -58,12 +58,12 @@ class CacheWriter;
  */
 class CPPCACHE_EXPORT AttributesMutator {
  private:
-  RegionPtr m_region;
+  std::shared_ptr<Region> m_region;
 
  public:
   /** Internal constructor. Use Region::getAttributesMutator() to acquire the
    * mutator for a region. */
-  AttributesMutator(const RegionPtr& region);
+  AttributesMutator(const std::shared_ptr<Region>& region);
 
   virtual ~AttributesMutator();
 
@@ -146,7 +146,7 @@ class CPPCACHE_EXPORT AttributesMutator {
    * <code>aListener</code>.
    * @param aListener cache listener
    */
-  void setCacheListener(const CacheListenerPtr& aListener);
+  void setCacheListener(const std::shared_ptr<CacheListener>& aListener);
 
   /** Sets cache listener for region. The previous cache listener will be
    * replaced with
@@ -163,7 +163,7 @@ class CPPCACHE_EXPORT AttributesMutator {
    * <code>aLoader</code>.
    * @param aLoader cache loader
    */
-  void setCacheLoader(const CacheLoaderPtr& aLoader);
+  void setCacheLoader(const std::shared_ptr<CacheLoader>& aLoader);
 
   /** Sets cache loader for region. The previous cache loader will be replaced
    * with
@@ -179,7 +179,7 @@ class CPPCACHE_EXPORT AttributesMutator {
    * <code>aWriter</code>.
    * @param aWriter cache writer
    */
-  void setCacheWriter(const CacheWriterPtr& aWriter);
+  void setCacheWriter(const std::shared_ptr<CacheWriter>& aWriter);
 
   /** Sets cache writer for region. The previous cache writer will be replaced
    * with
diff --git a/cppcache/include/geode/AuthInitialize.hpp b/cppcache/include/geode/AuthInitialize.hpp
index 0978b22e..0fab2da3 100644
--- a/cppcache/include/geode/AuthInitialize.hpp
+++ b/cppcache/include/geode/AuthInitialize.hpp
@@ -30,7 +30,7 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class Properties;
 /**
  * @class AuthInitialize AuthInitialize.hpp
  * Specifies the mechanism to obtain credentials for a client.
@@ -54,8 +54,8 @@ class CPPCACHE_EXPORT AuthInitialize {
    * @remarks This method can modify the given set of properties. For
    * example it may invoke external agents or even interact with the user.
    */
-  virtual PropertiesPtr getCredentials(const PropertiesPtr& securityprops,
-                                       const char* server) = 0;
+  virtual std::shared_ptr<Properties> getCredentials(
+      const std::shared_ptr<Properties>& securityprops, const char* server) = 0;
 
   /**@brief Invoked before the cache goes down. */
   virtual void close() = 0;
diff --git a/cppcache/include/geode/Cache.hpp b/cppcache/include/geode/Cache.hpp
index c03d827f..f7bb2148 100644
--- a/cppcache/include/geode/Cache.hpp
+++ b/cppcache/include/geode/Cache.hpp
@@ -48,7 +48,7 @@ class CacheFactory;
 class CacheRegionHelper;
 class Pool;
 class CacheImpl;
-
+class AuthInitialize;
 /**
  * @class Cache Cache.hpp
  *
@@ -135,12 +135,12 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
    * If Pool attached with Region is in multiusersecure mode then don't use
    * return instance of region as no credential are attached with this instance.
    * Get region from RegionService instance of Cache.@see
-   * Cache#createAuthenticatedView(PropertiesPtr).
+   * Cache#createAuthenticatedView(std::shared_ptr<Properties>).
    *
    * @param path the region's name, such as <code>AuthRegion</code>.
    * @returns region, or nullptr if no such region exists.
    */
-  virtual RegionPtr getRegion(const char* path) override;
+  virtual std::shared_ptr<Region> getRegion(const char* path) override;
 
   /**
    * Returns a set of root regions in the cache. This set is a snapshot and
@@ -150,13 +150,13 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
    * @param regions the returned set of
    * regions
    */
-  virtual VectorOfRegion rootRegions() override;
+  virtual std::vector<std::shared_ptr<Region>> rootRegions() override;
 
   /**
    * Gets the QueryService from which a new Query can be obtained.
    * @returns A smart pointer to the QueryService.
    */
-  virtual QueryServicePtr getQueryService() override;
+  virtual std::shared_ptr<QueryService> getQueryService() override;
 
   /**
    * Gets the QueryService from which a new Query can be obtained.
@@ -165,7 +165,7 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
    * PoolManager}
    * @returns A smart pointer to the QueryService.
    */
-  virtual QueryServicePtr getQueryService(const char* poolName);
+  virtual std::shared_ptr<QueryService> getQueryService(const char* poolName);
 
   /**
    * Send the "client ready" message to the server from a durable client.
@@ -195,15 +195,16 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
    * there are more than one Pool in Cache.
    */
 
-  virtual RegionServicePtr createAuthenticatedView(
-      PropertiesPtr userSecurityProperties, const char* poolName = nullptr);
+  virtual std::shared_ptr<RegionService> createAuthenticatedView(
+      std::shared_ptr<Properties> userSecurityProperties,
+      const char* poolName = nullptr);
 
   /**
    * Get the CacheTransactionManager instance for this Cache.
    * @return The CacheTransactionManager instance.
    * @throws CacheClosedException if the cache is closed.
    */
-  virtual CacheTransactionManagerPtr getCacheTransactionManager();
+  virtual std::shared_ptr<CacheTransactionManager> getCacheTransactionManager();
 
   /**
    * Returns whether Cache saves unread fields for Pdx types.
@@ -226,7 +227,7 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
    * @throws IllegalStateException if the className is nullptr or invalid.
    * @return the factory
    */
-  virtual PdxInstanceFactoryPtr createPdxInstanceFactory(
+  virtual std::shared_ptr<PdxInstanceFactory> createPdxInstanceFactory(
       const char* className) override;
 
   virtual statistics::StatisticsFactory* getStatisticsFactory() const;
@@ -246,9 +247,9 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
   /**
    * @brief constructors
    */
-  Cache(const std::string& name, PropertiesPtr dsProp,
+  Cache(const std::string& name, std::shared_ptr<Properties> dsProp,
         bool ignorePdxUnreadFields, bool readPdxSerialized,
-        const AuthInitializePtr& authInitialize);
+        const std::shared_ptr<AuthInitialize>& authInitialize);
 
   std::unique_ptr<CacheImpl> m_cacheImpl;
   std::unique_ptr<TypeRegistry> m_typeRegistry;
@@ -256,7 +257,7 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
  protected:
   Cache() = delete;
 
-  static bool isPoolInMultiuserMode(RegionPtr regionPtr);
+  static bool isPoolInMultiuserMode(std::shared_ptr<Region> regionPtr);
 
   friend class CacheFactory;
   friend class CacheRegionHelper;
diff --git a/cppcache/include/geode/CacheAttributes.hpp b/cppcache/include/geode/CacheAttributes.hpp
index 23ce2f62..da1cae8a 100644
--- a/cppcache/include/geode/CacheAttributes.hpp
+++ b/cppcache/include/geode/CacheAttributes.hpp
@@ -51,9 +51,7 @@ namespace client {
  */
 class CacheAttributesFactory;
 
-_GF_PTR_DEF_(CacheAttributes, CacheAttributesPtr);
-
-class CPPCACHE_EXPORT CacheAttributes  {
+class CPPCACHE_EXPORT CacheAttributes {
   /**
    * @brief public static methods
    */
diff --git a/cppcache/include/geode/CacheFactory.hpp b/cppcache/include/geode/CacheFactory.hpp
index cc8381ec..f3397af5 100644
--- a/cppcache/include/geode/CacheFactory.hpp
+++ b/cppcache/include/geode/CacheFactory.hpp
@@ -39,6 +39,7 @@ namespace geode {
 namespace client {
 
 class CppCacheLibrary;
+class AuthInitialize;
 /**
  * @class CacheFactory CacheFactory.hpp
  * Top level class for configuring and using Geode on a client.This should be
@@ -55,13 +56,13 @@ class CPPCACHE_EXPORT CacheFactory
    * @param dsProps
    *        Properties which are applicable at client level.
    */
-  static CacheFactoryPtr createCacheFactory(
-      const PropertiesPtr& dsProps = nullptr);
+  static std::shared_ptr<CacheFactory> createCacheFactory(
+      const std::shared_ptr<Properties>& dsProps = nullptr);
 
   /**
    * To create the instance of {@link Cache}.
    */
-  CachePtr create();
+  std::shared_ptr<Cache> create();
 
   /** Returns the version of the cache implementation.
    * For the 1.0 release of Geode, the string returned is <code>1.0</code>.
@@ -94,7 +95,7 @@ class CPPCACHE_EXPORT CacheFactory
    * @return this CacheFactory
    * @since 3.6
    */
-  CacheFactoryPtr setPdxIgnoreUnreadFields(bool ignore);
+  std::shared_ptr<CacheFactory> setPdxIgnoreUnreadFields(bool ignore);
 
   /**
    * Sets the AuthInitializer defined by the user.
@@ -102,7 +103,7 @@ class CPPCACHE_EXPORT CacheFactory
    * @param authInitialize
    * @return this ClientCacheFactory
    */
-  CacheFactoryPtr setAuthInitialize(const AuthInitializePtr& authInitialize);
+  std::shared_ptr<CacheFactory> setAuthInitialize(const std::shared_ptr<AuthInitialize>& authInitialize);
 
   /** Sets the object preference to PdxInstance type.
    * When a cached object that was serialized as a PDX is read
@@ -122,7 +123,7 @@ class CPPCACHE_EXPORT CacheFactory
    *  @param pdxReadSerialized true to prefer PdxInstance
    *  @return this ClientCacheFactory
    */
-  CacheFactoryPtr setPdxReadSerialized(bool pdxReadSerialized);
+  std::shared_ptr<CacheFactory> setPdxReadSerialized(bool pdxReadSerialized);
 
   /**
    * Sets a geode property that will be used when creating the {link @Cache}.
@@ -131,24 +132,24 @@ class CPPCACHE_EXPORT CacheFactory
    * @return a reference to <code>this</code>
    * @since 3.5
    */
-  CacheFactoryPtr set(const char* name, const char* value);
+  std::shared_ptr<CacheFactory> set(const char* name, const char* value);
 
  private:
-  PropertiesPtr dsProp;
+  std::shared_ptr<Properties> dsProp;
   bool ignorePdxUnreadFields;
   bool pdxReadSerialized;
-  AuthInitializePtr authInitialize;
+  std::shared_ptr<AuthInitialize> authInitialize;
 
-  CachePtr create(const char* name,
-                  const CacheAttributesPtr& attrs = nullptr);
+  std::shared_ptr<Cache> create(
+      const char* name,
+      const std::shared_ptr<CacheAttributes>& attrs = nullptr);
 
   void create_(const char* name, const char* id_data,
-               CachePtr& cptr,
-               bool readPdxSerialized);
+               std::shared_ptr<Cache>& cptr, bool readPdxSerialized);
 
   // no instances allowed
   CacheFactory();
-  CacheFactory(const PropertiesPtr dsProps);
+  CacheFactory(const std::shared_ptr<Properties> dsProps);
 
  private:
   ~CacheFactory();
diff --git a/cppcache/include/geode/CacheListener.hpp b/cppcache/include/geode/CacheListener.hpp
index 9619d561..dd51ab9d 100644
--- a/cppcache/include/geode/CacheListener.hpp
+++ b/cppcache/include/geode/CacheListener.hpp
@@ -34,7 +34,7 @@ namespace client {
 
 class EntryEvent;
 class RegionEvent;
-
+class Region;
 /**
  * @class CacheListener CacheListener.hpp
  * An application plug-in that can be installed on a region.
@@ -184,16 +184,16 @@ class CPPCACHE_EXPORT CacheListener {
    * @see Region::destroyRegion
    */
 
-  virtual void close(const RegionPtr& region);
+  virtual void close(const std::shared_ptr<Region>& region);
   /**
    * Called when all the endpoints assosiated with region are down.
    * This will be called when all the endpoints are down for the first time.
    * If endpoints come up and again go down it will be called again.
    * This will also be called when all endpoints are down and region is attached
    * to the pool.
-   * @param region RegionPtr denotes the assosiated region.
+   * @param region std::shared_ptr<Region> denotes the assosiated region.
    */
-  virtual void afterRegionDisconnected(const RegionPtr& region);
+  virtual void afterRegionDisconnected(const std::shared_ptr<Region>& region);
 
  protected:
   /**
diff --git a/cppcache/include/geode/CacheLoader.hpp b/cppcache/include/geode/CacheLoader.hpp
index 425ed4aa..044bf13f 100644
--- a/cppcache/include/geode/CacheLoader.hpp
+++ b/cppcache/include/geode/CacheLoader.hpp
@@ -32,6 +32,7 @@
 namespace apache {
 namespace geode {
 namespace client {
+class Region;
 
 /**
  * @class CacheLoader CacheLoader.hpp
@@ -67,8 +68,10 @@ class CPPCACHE_EXPORT CacheLoader  {
    *
    *@see Region::get .
    */
-  virtual CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                            const SerializablePtr& aCallbackArgument) = 0;
+  virtual std::shared_ptr<Cacheable> load(
+      const std::shared_ptr<Region>& rp,
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument) = 0;
 
   /** Called when the region containing this callback is destroyed, when
    * the cache is closed.
@@ -85,7 +88,7 @@ class CPPCACHE_EXPORT CacheLoader  {
    * @see Cache::close
    * @see Region::destroyRegion
    */
-  virtual void close(const RegionPtr& rp);
+  virtual void close(const std::shared_ptr<Region>& rp);
 
   virtual ~CacheLoader();
 
diff --git a/cppcache/include/geode/CacheTransactionManager.hpp b/cppcache/include/geode/CacheTransactionManager.hpp
index d7ce9d83..b43175ae 100644
--- a/cppcache/include/geode/CacheTransactionManager.hpp
+++ b/cppcache/include/geode/CacheTransactionManager.hpp
@@ -29,6 +29,7 @@
 namespace apache {
 namespace geode {
 namespace client {
+class TransactionId;
 
 class CPPCACHE_EXPORT CacheTransactionManager {
  public:
@@ -90,33 +91,33 @@ class CPPCACHE_EXPORT CacheTransactionManager {
    *         the thread was not associated with a transaction
    * @since 3.6.2
    */
-  virtual TransactionIdPtr suspend() = 0;
+  virtual std::shared_ptr<TransactionId> suspend() = 0;
 
   /**
-  * On the current thread, resumes a transaction that was previously suspended
-  * using {@link #suspend()}
-  *
-  * @param transactionId
-  *          the transaction to resume
-  * @throws IllegalStateException
-  *           if the thread is associated with a transaction or if
-  *           {@link #isSuspended(TransactionId)} would return false for the
-  *           given transactionId
-  * @since 3.6.2
-  */
-  virtual void resume(TransactionIdPtr transactionId) = 0;
+   * On the current thread, resumes a transaction that was previously suspended
+   * using {@link #suspend()}
+   *
+   * @param transactionId
+   *          the transaction to resume
+   * @throws IllegalStateException
+   *           if the thread is associated with a transaction or if
+   *           {@link #isSuspended(TransactionId)} would return false for the
+   *           given transactionId
+   * @since 3.6.2
+   */
+  virtual void resume(std::shared_ptr<TransactionId> transactionId) = 0;
 
   /**
-  * This method can be used to determine if a transaction with the given
-  * transaction identifier is currently suspended locally. This method does not
-  * check other members for transaction status.
-  *
-  * @param transactionId
-  * @return true if the transaction is in suspended state, false otherwise
-  * @since 3.6.2
-  * @see #exists(TransactionId)
-  */
-  virtual bool isSuspended(TransactionIdPtr transactionId) = 0;
+   * This method can be used to determine if a transaction with the given
+   * transaction identifier is currently suspended locally. This method does not
+   * check other members for transaction status.
+   *
+   * @param transactionId
+   * @return true if the transaction is in suspended state, false otherwise
+   * @since 3.6.2
+   * @see #exists(TransactionId)
+   */
+  virtual bool isSuspended(std::shared_ptr<TransactionId> transactionId) = 0;
 
   /**
    * On the current thread, resumes a transaction that was previously suspended
@@ -135,7 +136,7 @@ class CPPCACHE_EXPORT CacheTransactionManager {
    * @return true if the transaction was resumed, false otherwise
    * @since 3.6.2
    */
-  virtual bool tryResume(TransactionIdPtr transactionId) = 0;
+  virtual bool tryResume(std::shared_ptr<TransactionId> transactionId) = 0;
 
   /**
    * On the current thread, resumes a transaction that was previously suspended
@@ -158,7 +159,7 @@ class CPPCACHE_EXPORT CacheTransactionManager {
    * @since 3.6.2
    * @see #tryResume(TransactionId)
    */
-  virtual bool tryResume(TransactionIdPtr transactionId,
+  virtual bool tryResume(std::shared_ptr<TransactionId> transactionId,
                          std::chrono::milliseconds waitTime) = 0;
 
   /**
@@ -172,15 +173,15 @@ class CPPCACHE_EXPORT CacheTransactionManager {
    * @since 3.6.2
    * @see #isSuspended(TransactionId)
    */
-  virtual bool exists(TransactionIdPtr transactionId) = 0;
+  virtual bool exists(std::shared_ptr<TransactionId> transactionId) = 0;
 
   /** Returns the transaction identifier for the current thread
-  *
-  * @return the transaction identifier or null if no transaction exists
-  *
-  * @since 3.6.2
-  */
-  virtual TransactionIdPtr getTransactionId() = 0;
+   *
+   * @return the transaction identifier or null if no transaction exists
+   *
+   * @since 3.6.2
+   */
+  virtual std::shared_ptr<TransactionId> getTransactionId() = 0;
 
   /** Reports the existence of a Transaction for this thread
    *
diff --git a/cppcache/include/geode/CacheWriter.hpp b/cppcache/include/geode/CacheWriter.hpp
index 6451b7ff..d8692adc 100644
--- a/cppcache/include/geode/CacheWriter.hpp
+++ b/cppcache/include/geode/CacheWriter.hpp
@@ -34,6 +34,7 @@ namespace client {
 
 class EntryEvent;
 class RegionEvent;
+class Region;
 /**
  * @class CacheWriter CacheWriter.hpp
  * An application plug-in that can be installed on the region.
@@ -156,20 +157,20 @@ class CPPCACHE_EXPORT CacheWriter  {
   virtual bool beforeRegionDestroy(const RegionEvent& event);
 
   /** Called when the region containing this callback is destroyed, when
-     * the cache is closed.
-     *
-     * <p>Implementations should clean up any external
-     * resources, such as database connections. Any runtime exceptions this
+   * the cache is closed.
+   *
+   * <p>Implementations should clean up any external
+   * resources, such as database connections. Any runtime exceptions this
    * method
-     * throws will be logged.
-     *
-     * <p>It is possible for this method to be called multiple times on a single
-     * callback instance, so implementations must be tolerant of this.
-     *
-     * @see Cache::close
-     * @see Region::destroyRegion
+   * throws will be logged.
+   *
+   * <p>It is possible for this method to be called multiple times on a single
+   * callback instance, so implementations must be tolerant of this.
+   *
+   * @see Cache::close
+   * @see Region::destroyRegion
    */
-  virtual void close(const RegionPtr& rp);
+  virtual void close(const std::shared_ptr<Region>& rp);
 
   virtual ~CacheWriter();
 
diff --git a/cppcache/include/geode/Cacheable.hpp b/cppcache/include/geode/Cacheable.hpp
index 02c77988..f914c267 100644
--- a/cppcache/include/geode/Cacheable.hpp
+++ b/cppcache/include/geode/Cacheable.hpp
@@ -23,6 +23,7 @@
 /**
  * @file
  */
+#include <memory>
 
 #include "geode_globals.hpp"
 #include "Serializable.hpp"
@@ -31,11 +32,11 @@ namespace apache {
 namespace geode {
 namespace client {
 
-typedef SerializablePtr CacheablePtr;
 typedef Serializable Cacheable;
 
 template <typename TVALUE>
-inline CacheablePtr createValue(const std::shared_ptr<TVALUE>& value) {
+inline std::shared_ptr<Cacheable> createValue(
+    const std::shared_ptr<TVALUE>& value) {
   return std::dynamic_pointer_cast<Cacheable>(value);
 }
 
diff --git a/cppcache/include/geode/CacheableBuiltins.hpp b/cppcache/include/geode/CacheableBuiltins.hpp
index f7a6a053..71076aea 100644
--- a/cppcache/include/geode/CacheableBuiltins.hpp
+++ b/cppcache/include/geode/CacheableBuiltins.hpp
@@ -91,7 +91,7 @@ class CacheableKeyType : public CacheableKey {
   virtual int8_t typeId() const { return TYPEID; }
 
   /** Return a string representation of the object. */
-  virtual CacheableStringPtr toString() const {
+  virtual std::shared_ptr<CacheableString> toString() const {
     char buffer[STRSIZE + 1];
     gf_sprintf(buffer, SPRINTFSYM, m_value);
     return CacheableString::create(buffer);
@@ -340,45 +340,47 @@ class CacheableContainerType : public Cacheable, public TBase {
 #pragma warning(disable : 4231)
 #endif
 
-#define _GF_CACHEABLE_KEY_TYPE_DEF_(p, k, sz)                                 \
-  extern const char tName_##k[];                                              \
-  extern const char tStr_##k[];                                               \
-  TEMPLATE_EXPORT                                                             \
-  CacheableKeyType<p, GeodeTypeIds::k, tName_##k, tStr_##k, sz>;              \
-  typedef CacheableKeyType<p, GeodeTypeIds::k, tName_##k, tStr_##k, sz> _##k; \
-  class CPPCACHE_EXPORT k;                                                    \
-  typedef std::shared_ptr<k> k##Ptr;
+#define _GF_CACHEABLE_KEY_TYPE_DEF_(p, k, sz)                    \
+  extern const char tName_##k[];                                 \
+  extern const char tStr_##k[];                                  \
+  TEMPLATE_EXPORT                                                \
+  CacheableKeyType<p, GeodeTypeIds::k, tName_##k, tStr_##k, sz>; \
+  typedef CacheableKeyType<p, GeodeTypeIds::k, tName_##k, tStr_##k, sz> _##k;
 
 // use a class instead of typedef for bug #283
-#define _GF_CACHEABLE_KEY_TYPE_(p, k, sz)                                      \
-  class CPPCACHE_EXPORT k : public _##k {                                      \
-   protected:                                                                  \
-    inline k() : _##k() {}                                                     \
-    inline k(const p value) : _##k(value) {}                                   \
-    FRIEND_STD_SHARED_PTR(k)                                                   \
-                                                                               \
-   public:                                                                     \
-    /** Factory function registered with serialization registry. */            \
-    static Serializable* createDeserializable() { return new k(); }            \
-    /** Factory function to create a new default instance. */                  \
-    inline static k##Ptr create() { return std::make_shared<k>(); }            \
-    /** Factory function to create an instance with the given value. */        \
-    inline static k##Ptr create(const p value) {                               \
-      return std::make_shared<k>(value);                                       \
-    }                                                                          \
-  };                                                                           \
-  inline CacheableKeyPtr createKey(const p value) { return k::create(value); } \
-  inline CacheablePtr createValue(const p value) { return k::create(value); }
+#define _GF_CACHEABLE_KEY_TYPE_(p, k, sz)                               \
+  class CPPCACHE_EXPORT k : public _##k {                               \
+   protected:                                                           \
+    inline k() : _##k() {}                                              \
+    inline k(const p value) : _##k(value) {}                            \
+    FRIEND_STD_SHARED_PTR(k)                                            \
+                                                                        \
+   public:                                                              \
+    /** Factory function registered with serialization registry. */     \
+    static Serializable* createDeserializable() { return new k(); }     \
+    /** Factory function to create a new default instance. */           \
+    inline static std::shared_ptr<k> create() {                         \
+      return std::make_shared<k>();                                     \
+    }                                                                   \
+    /** Factory function to create an instance with the given value. */ \
+    inline static std::shared_ptr<k> create(const p value) {            \
+      return std::make_shared<k>(value);                                \
+    }                                                                   \
+  };                                                                    \
+  inline std::shared_ptr<CacheableKey> createKey(const p value) {       \
+    return k::create(value);                                            \
+  }                                                                     \
+  inline std::shared_ptr<Cacheable> createValue(const p value) {        \
+    return k::create(value);                                            \
+  }
 
 #define _GF_CACHEABLE_ARRAY_TYPE_DEF_(p, c)               \
   TEMPLATE_EXPORT CacheableArrayType<p, GeodeTypeIds::c>; \
-  typedef CacheableArrayType<p, GeodeTypeIds::c> _##c;    \
-  class CPPCACHE_EXPORT c;                                \
-  typedef std::shared_ptr<CacheableArrayType<p, GeodeTypeIds::c>> c##Ptr;
+  typedef CacheableArrayType<p, GeodeTypeIds::c> _##c;
 
 // use a class instead of typedef for bug #283
 #define _GF_CACHEABLE_ARRAY_TYPE_(p, c)                                       \
-  class CPPCACHE_EXPORT c : public _##c {                                     \
+  class CPPCACHE_EXPORT c : public CacheableArrayType<p, GeodeTypeIds::c> {   \
    protected:                                                                 \
     inline c() : _##c() {}                                                    \
     inline c(int32_t length) : _##c(length) {}                                \
@@ -397,13 +399,15 @@ class CacheableContainerType : public Cacheable, public TBase {
     /** Factory function registered with serialization registry. */           \
     static Serializable* createDeserializable() { return new c(); }           \
     /** Factory function to create a new default instance. */                 \
-    inline static c##Ptr create() { return std::make_shared<c>(); }           \
+    inline static std::shared_ptr<c> create() {                               \
+      return std::make_shared<c>();                                           \
+    }                                                                         \
     /** Factory function to create a cacheable array of given size. */        \
-    inline static c##Ptr create(int32_t length) {                             \
+    inline static std::shared_ptr<c> create(int32_t length) {                 \
       return std::make_shared<c>(length);                                     \
     }                                                                         \
     /** Create a cacheable array copying from the given array. */             \
-    inline static c##Ptr create(const p* value, int32_t length) {             \
+    inline static std::shared_ptr<c> create(const p* value, int32_t length) { \
       return nullptr == value ? nullptr                                       \
                               : std::make_shared<c>(value, length, true);     \
     }                                                                         \
@@ -415,16 +419,14 @@ class CacheableContainerType : public Cacheable, public TBase {
      * not deleted (apart from this class) and is allocated on the heap       \
      * using the "new" operator.                                              \
      */                                                                       \
-    inline static c##Ptr createNoCopy(p* value, int32_t length) {             \
+    inline static std::shared_ptr<c> createNoCopy(p* value, int32_t length) { \
       return nullptr == value ? nullptr : std::make_shared<c>(value, length); \
     }                                                                         \
   };
 
 #define _GF_CACHEABLE_CONTAINER_TYPE_DEF_(p, c)               \
   TEMPLATE_EXPORT CacheableContainerType<p, GeodeTypeIds::c>; \
-  typedef CacheableContainerType<p, GeodeTypeIds::c> _##c;    \
-  class CPPCACHE_EXPORT c;                                    \
-  typedef std::shared_ptr<c> c##Ptr;
+  typedef CacheableContainerType<p, GeodeTypeIds::c> _##c;
 
 // use a class instead of typedef for bug #283
 #define _GF_CACHEABLE_CONTAINER_TYPE_(p, c)                            \
@@ -439,9 +441,11 @@ class CacheableContainerType : public Cacheable, public TBase {
     /** Factory function registered with serialization registry. */    \
     static Serializable* createDeserializable() { return new c(); }    \
     /** Factory function to create a default instance. */              \
-    inline static c##Ptr create() { return std::make_shared<c>(); }    \
+    inline static std::shared_ptr<c> create() {                        \
+      return std::make_shared<c>();                                    \
+    }                                                                  \
     /** Factory function to create an instance with the given size. */ \
-    inline static c##Ptr create(const int32_t n) {                     \
+    inline static std::shared_ptr<c> create(const int32_t n) {         \
       return std::make_shared<c>(n);                                   \
     }                                                                  \
   };
@@ -562,21 +566,23 @@ _GF_CACHEABLE_ARRAY_TYPE_DEF_(int64_t, CacheableInt64Array);
  */
 _GF_CACHEABLE_ARRAY_TYPE_(int64_t, CacheableInt64Array);
 
-_GF_CACHEABLE_ARRAY_TYPE_DEF_(CacheableStringPtr, CacheableStringArray);
+_GF_CACHEABLE_ARRAY_TYPE_DEF_(std::shared_ptr<CacheableString>, CacheableStringArray);
 /**
  * An immutable wrapper for array of strings that can serve as
  * a distributable object for caching.
  */
-_GF_CACHEABLE_ARRAY_TYPE_(CacheableStringPtr, CacheableStringArray);
+_GF_CACHEABLE_ARRAY_TYPE_(std::shared_ptr<CacheableString>,
+                          CacheableStringArray);
 
 // Instantiations for container types (Vector/HashMap/HashSet) Cacheables
 
-_GF_CACHEABLE_CONTAINER_TYPE_DEF_(VectorOfCacheable, CacheableVector);
+_GF_CACHEABLE_CONTAINER_TYPE_DEF_(std::vector<std::shared_ptr<Cacheable>>,
+                                  CacheableVector);
 /**
  * A mutable <code>Cacheable</code> vector wrapper that can serve as
  * a distributable object for caching.
  */
-_GF_CACHEABLE_CONTAINER_TYPE_(VectorOfCacheable, CacheableVector);
+_GF_CACHEABLE_CONTAINER_TYPE_(std::vector<std::shared_ptr<Cacheable>>, CacheableVector);
 
 _GF_CACHEABLE_CONTAINER_TYPE_DEF_(HashMapOfCacheable, CacheableHashMap);
 /**
@@ -592,27 +598,30 @@ _GF_CACHEABLE_CONTAINER_TYPE_DEF_(HashSetOfCacheableKey, CacheableHashSet);
  */
 _GF_CACHEABLE_CONTAINER_TYPE_(HashSetOfCacheableKey, CacheableHashSet);
 
-_GF_CACHEABLE_CONTAINER_TYPE_DEF_(VectorOfCacheable, CacheableArrayList);
+_GF_CACHEABLE_CONTAINER_TYPE_DEF_(std::vector<std::shared_ptr<Cacheable>>,
+                                  CacheableArrayList);
 /**
  * A mutable <code>Cacheable</code> array list wrapper that can serve as
  * a distributable object for caching.
  */
-_GF_CACHEABLE_CONTAINER_TYPE_(VectorOfCacheable, CacheableArrayList);
+_GF_CACHEABLE_CONTAINER_TYPE_(std::vector<std::shared_ptr<Cacheable>>, CacheableArrayList);
 
 // linketlist for JSON formattor issue
-_GF_CACHEABLE_CONTAINER_TYPE_DEF_(VectorOfCacheable, CacheableLinkedList);
+_GF_CACHEABLE_CONTAINER_TYPE_DEF_(std::vector<std::shared_ptr<Cacheable>>,
+                                  CacheableLinkedList);
 /**
  * A mutable <code>Cacheable</code> array list wrapper that can serve as
  * a distributable object for caching.
  */
-_GF_CACHEABLE_CONTAINER_TYPE_(VectorOfCacheable, CacheableLinkedList);
+_GF_CACHEABLE_CONTAINER_TYPE_(std::vector<std::shared_ptr<Cacheable>>, CacheableLinkedList);
 
-_GF_CACHEABLE_CONTAINER_TYPE_DEF_(VectorOfCacheable, CacheableStack);
+_GF_CACHEABLE_CONTAINER_TYPE_DEF_(std::vector<std::shared_ptr<Cacheable>>,
+                                  CacheableStack);
 /**
  * A mutable <code>Cacheable</code> stack wrapper that can serve as
  * a distributable object for caching.
  */
-_GF_CACHEABLE_CONTAINER_TYPE_(VectorOfCacheable, CacheableStack);
+_GF_CACHEABLE_CONTAINER_TYPE_(std::vector<std::shared_ptr<Cacheable>>, CacheableStack);
 
 _GF_CACHEABLE_CONTAINER_TYPE_DEF_(HashMapOfCacheable, CacheableHashTable);
 /**
@@ -643,12 +652,12 @@ _GF_CACHEABLE_CONTAINER_TYPE_DEF_(HashSetOfCacheableKey,
 _GF_CACHEABLE_CONTAINER_TYPE_(HashSetOfCacheableKey, CacheableLinkedHashSet);
 
 template <>
-inline CacheableKeyPtr CacheableKey::create(int32_t value) {
+inline std::shared_ptr<CacheableKey> CacheableKey::create(int32_t value) {
   return CacheableInt32::create(value);
 }
 
 template <>
-inline SerializablePtr Serializable::create(int32_t value) {
+inline std::shared_ptr<Serializable> Serializable::create(int32_t value) {
   return CacheableInt32::create(value);
 }
 
diff --git a/cppcache/include/geode/CacheableDate.hpp b/cppcache/include/geode/CacheableDate.hpp
index a4a44dbb..1ee36ec3 100644
--- a/cppcache/include/geode/CacheableDate.hpp
+++ b/cppcache/include/geode/CacheableDate.hpp
@@ -110,21 +110,23 @@ class CPPCACHE_EXPORT CacheableDate : public CacheableKey {
   /**
    * Factory method for creating an instance of CacheableDate
    */
-  static CacheableDatePtr create() { return std::make_shared<CacheableDate>(); }
+  static std::shared_ptr<CacheableDate> create() {
+    return std::make_shared<CacheableDate>();
+  }
 
-  static CacheableDatePtr create(const time_t& value) {
+  static std::shared_ptr<CacheableDate> create(const time_t& value) {
     return std::make_shared<CacheableDate>(value);
   }
 
-  static CacheableDatePtr create(const time_point& value) {
+  static std::shared_ptr<CacheableDate> create(const time_point& value) {
     return std::make_shared<CacheableDate>(value);
   }
 
-  static CacheableDatePtr create(const duration& value) {
+  static std::shared_ptr<CacheableDate> create(const duration& value) {
     return std::make_shared<CacheableDate>(value);
   }
 
-  virtual CacheableStringPtr toString() const;
+  virtual std::shared_ptr<CacheableString> toString() const;
 
   /** Destructor */
   virtual ~CacheableDate();
@@ -154,11 +156,13 @@ class CPPCACHE_EXPORT CacheableDate : public CacheableKey {
   FRIEND_STD_SHARED_PTR(CacheableDate)
 };
 
-inline CacheableKeyPtr createKey(const CacheableDate::time_point& value) {
+inline std::shared_ptr<CacheableKey> createKey(
+    const CacheableDate::time_point& value) {
   return CacheableDate::create(value);
 }
 
-inline CacheablePtr createValue(const CacheableDate::time_point& value) {
+inline std::shared_ptr<Cacheable> createValue(
+    const CacheableDate::time_point& value) {
   return CacheableDate::create(value);
 }
 
diff --git a/cppcache/include/geode/CacheableEnum.hpp b/cppcache/include/geode/CacheableEnum.hpp
index e9ee088d..c13bde2f 100644
--- a/cppcache/include/geode/CacheableEnum.hpp
+++ b/cppcache/include/geode/CacheableEnum.hpp
@@ -43,8 +43,8 @@ namespace client {
 
 class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
  private:
-  CacheableStringPtr m_enumClassName;
-  CacheableStringPtr m_enumName;
+  std::shared_ptr<CacheableString> m_enumClassName;
+  std::shared_ptr<CacheableString> m_enumName;
   int32_t m_ordinal;
   mutable int32_t m_hashcode;
 
@@ -95,7 +95,7 @@ class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
   /**
    * Display this object as c string.
    */
-  virtual CacheableStringPtr toString() const {
+  virtual std::shared_ptr<CacheableString> toString() const {
     return CacheableString::create("CacheableEnum");
   }
 
@@ -109,8 +109,9 @@ class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
    * enum type.
    * @return a {@link CacheableEnum} representing C++ enum.
    */
-  static CacheableEnumPtr create(const char* enumClassName,
-                                 const char* enumName, int32_t ordinal) {
+  static std::shared_ptr<CacheableEnum> create(const char* enumClassName,
+                                               const char* enumName,
+                                               int32_t ordinal) {
     return std::make_shared<CacheableEnum>(enumClassName, enumName, ordinal);
   }
 
diff --git a/cppcache/include/geode/CacheableFileName.hpp b/cppcache/include/geode/CacheableFileName.hpp
index bab3e528..5b1a0efb 100644
--- a/cppcache/include/geode/CacheableFileName.hpp
+++ b/cppcache/include/geode/CacheableFileName.hpp
@@ -75,8 +75,9 @@ class CPPCACHE_EXPORT CacheableFileName : public CacheableString {
    * Factory method for creating an instance of CacheableFileName from a
    * C string optionally given the length.
    */
-  static CacheableFileNamePtr create(const char* value, int32_t len = 0) {
-    CacheableFileNamePtr str = nullptr;
+  static std::shared_ptr<CacheableFileName> create(const char* value,
+                                                   int32_t len = 0) {
+    std::shared_ptr<CacheableFileName> str = nullptr;
     if (value != nullptr) {
       str = std::make_shared<CacheableFileName>();
       str->initString(value, len);
@@ -88,8 +89,9 @@ class CPPCACHE_EXPORT CacheableFileName : public CacheableString {
    * Factory method for creating an instance of CacheableFileName from a
    * wide-character C string optionally given the length.
    */
-  static CacheableFileNamePtr create(const wchar_t* value, int32_t len = 0) {
-    CacheableFileNamePtr str = nullptr;
+  static std::shared_ptr<CacheableFileName> create(const wchar_t* value,
+                                                   int32_t len = 0) {
+    std::shared_ptr<CacheableFileName> str = nullptr;
     if (value != nullptr) {
       str = std::make_shared<CacheableFileName>();
       str->initString(value, len);
diff --git a/cppcache/include/geode/CacheableKey.hpp b/cppcache/include/geode/CacheableKey.hpp
index a081c451..1a00fba2 100644
--- a/cppcache/include/geode/CacheableKey.hpp
+++ b/cppcache/include/geode/CacheableKey.hpp
@@ -71,7 +71,7 @@ class CPPCACHE_EXPORT CacheableKey : public Cacheable {
    * the method apache::geode::client::createKeyArr may be overloaded.
    */
   template <class PRIM>
-  inline static CacheableKeyPtr create(const PRIM value);
+  inline static std::shared_ptr<CacheableKey> create(const PRIM value);
 
   struct hash {
     inline std::size_t operator()(const CacheableKey& s) const {
diff --git a/cppcache/include/geode/CacheableObjectArray.hpp b/cppcache/include/geode/CacheableObjectArray.hpp
index 2c866047..63e171de 100644
--- a/cppcache/include/geode/CacheableObjectArray.hpp
+++ b/cppcache/include/geode/CacheableObjectArray.hpp
@@ -19,11 +19,12 @@
 
 #ifndef GEODE_CACHEABLEOBJECTARRAY_H_
 #define GEODE_CACHEABLEOBJECTARRAY_H_
+#include <vector>
+#include <memory>
 
 #include "geode_globals.hpp"
 #include "geode_types.hpp"
-#include "VectorT.hpp"
-
+#include "Cacheable.hpp"
 /** @file
  */
 
@@ -35,8 +36,9 @@ namespace client {
  * Implement an immutable Vector of <code>Cacheable</code> objects
  * that can serve as a distributable object for caching.
  */
-class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
-                                             public VectorOfCacheable {
+class CPPCACHE_EXPORT CacheableObjectArray
+    : public Cacheable,
+      public std::vector<std::shared_ptr<Cacheable>> {
  public:
   /**
    *@brief serialize this object
@@ -72,7 +74,7 @@ class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
   /**
    * Factory method for creating the default instance of CacheableObjectArray.
    */
-  inline static CacheableObjectArrayPtr create() {
+  inline static std::shared_ptr<CacheableObjectArray> create() {
     return std::make_shared<CacheableObjectArray>();
   }
 
@@ -80,7 +82,7 @@ class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
    * Factory method for creating an instance of CacheableObjectArray with
    * given size.
    */
-  inline static CacheableObjectArrayPtr create(int32_t n) {
+  inline static std::shared_ptr<CacheableObjectArray> create(int32_t n) {
     return std::make_shared<CacheableObjectArray>(n);
   }
 
@@ -88,9 +90,9 @@ class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
 
  protected:
   /** Constructor, used for deserialization. */
-  inline CacheableObjectArray() : VectorOfCacheable() {}
+  inline CacheableObjectArray() : std::vector<std::shared_ptr<Cacheable>>() {}
   /** Create a vector with n elements allocated. */
-  inline CacheableObjectArray(int32_t n) : VectorOfCacheable(n) {}
+  inline CacheableObjectArray(int32_t n) : std::vector<std::shared_ptr<Cacheable>>(n) {}
 
  private:
   // never implemented.
diff --git a/cppcache/include/geode/CacheableString.hpp b/cppcache/include/geode/CacheableString.hpp
index 8ebf0238..d1d9fc32 100644
--- a/cppcache/include/geode/CacheableString.hpp
+++ b/cppcache/include/geode/CacheableString.hpp
@@ -112,12 +112,13 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    *
    * This should be used only for ASCII strings.
    */
-  static CacheableStringPtr create(const char* value, int32_t len = 0) {
+  static std::shared_ptr<CacheableString> create(const char* value,
+                                                 int32_t len = 0) {
     if (nullptr == value) {
       return nullptr;
     }
 
-    CacheableStringPtr str = std::make_shared<CacheableString>();
+    auto str = std::make_shared<CacheableString>();
     str->initString(value, len);
     return str;
   }
@@ -132,12 +133,13 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    *
    * CAUTION: use this only when you really know what you are doing.
    */
-  static CacheableStringPtr createNoCopy(char* value, int32_t len = 0) {
+  static std::shared_ptr<CacheableString> createNoCopy(char* value,
+                                                       int32_t len = 0) {
     if (nullptr == value) {
       return nullptr;
     }
 
-    CacheableStringPtr str = std::make_shared<CacheableString>();
+    auto str = std::make_shared<CacheableString>();
     str->initStringNoCopy(value, len);
     return str;
   }
@@ -148,12 +150,13 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    *
    * This should be used for non-ASCII strings.
    */
-  static CacheableStringPtr create(const wchar_t* value, int32_t len = 0) {
+  static std::shared_ptr<CacheableString> create(const wchar_t* value,
+                                                 int32_t len = 0) {
     if (nullptr == value) {
       return nullptr;
     }
 
-    CacheableStringPtr str = std::make_shared<CacheableString>();
+    auto str = std::make_shared<CacheableString>();
     str->initString(value, len);
     return str;
   }
@@ -168,12 +171,13 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    *
    * CAUTION: use this only when you really know what you are doing.
    */
-  static CacheableStringPtr createNoCopy(wchar_t* value, int32_t len = 0) {
+  static std::shared_ptr<CacheableString> createNoCopy(wchar_t* value,
+                                                       int32_t len = 0) {
     if (nullptr == value) {
       return nullptr;
     }
 
-    CacheableStringPtr str = std::make_shared<CacheableString>();
+    auto str = std::make_shared<CacheableString>();
     str->initStringNoCopy(value, len);
     return str;
   }
@@ -240,7 +244,7 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    */
   const char* toString() { return reinterpret_cast<const char*>(m_str); }
 
-  virtual CacheableStringPtr toString() const {
+  virtual std::shared_ptr<CacheableString> toString() const {
     // TODO this cast seems odd
     return std::const_pointer_cast<CacheableString>(
         std::static_pointer_cast<const CacheableString>(shared_from_this()));
@@ -289,47 +293,48 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
 };
 
 /** overload of apache::geode::client::createKeyArr to pass char* */
-inline CacheableKeyPtr createKeyArr(const char* value) {
+inline std::shared_ptr<CacheableKey> createKeyArr(const char* value) {
   return CacheableString::create(value);
 }
 
 /** overload of apache::geode::client::createKeyArr to pass wchar_t* */
-inline CacheableKeyPtr createKeyArr(const wchar_t* value) {
+inline std::shared_ptr<CacheableKey> createKeyArr(const wchar_t* value) {
   return CacheableString::create(value);
 }
 
 /** overload of apache::geode::client::createValueArr to pass char* */
-inline CacheablePtr createValueArr(const char* value) {
+inline std::shared_ptr<Cacheable> createValueArr(const char* value) {
   return CacheableString::create(value);
 }
 
 /** overload of apache::geode::client::createValueArr to pass wchar_t* */
-inline CacheablePtr createValueArr(const wchar_t* value) {
+inline std::shared_ptr<Cacheable> createValueArr(const wchar_t* value) {
   return CacheableString::create(value);
 }
 
 template <typename TVALUE>
-inline CacheablePtr createValue(const TVALUE* value) {
+inline std::shared_ptr<Cacheable> createValue(const TVALUE* value) {
   return CacheableString::create(value);
 }
 
 template <class TKEY>
-inline CacheableKeyPtr createKey(const std::shared_ptr<TKEY>& value) {
-  return CacheableKeyPtr(value);
+inline std::shared_ptr<CacheableKey> createKey(
+    const std::shared_ptr<TKEY>& value) {
+  return std::shared_ptr<CacheableKey>(value);
 }
 
 template <typename TKEY>
-inline CacheableKeyPtr createKey(const TKEY* value) {
+inline std::shared_ptr<CacheableKey> createKey(const TKEY* value) {
   return createKeyArr(value);
 }
 
 template <class PRIM>
-inline CacheableKeyPtr CacheableKey::create(const PRIM value) {
+inline std::shared_ptr<CacheableKey> CacheableKey::create(const PRIM value) {
   return createKey(value);
 }
 
 template <class PRIM>
-inline SerializablePtr Serializable::create(const PRIM value) {
+inline std::shared_ptr<Serializable> Serializable::create(const PRIM value) {
   return createKey(value);
 }
 
diff --git a/cppcache/include/geode/CacheableUndefined.hpp b/cppcache/include/geode/CacheableUndefined.hpp
index b287298b..1dd7e786 100644
--- a/cppcache/include/geode/CacheableUndefined.hpp
+++ b/cppcache/include/geode/CacheableUndefined.hpp
@@ -76,7 +76,7 @@ class CPPCACHE_EXPORT CacheableUndefined : public Cacheable {
   /**
    * Factory method for creating the default instance of CacheableUndefined.
    */
-  inline static CacheableUndefinedPtr create() {
+  inline static std::shared_ptr<CacheableUndefined> create() {
     return std::make_shared<CacheableUndefined>();
   }
 
diff --git a/cppcache/include/geode/CqAttributes.hpp b/cppcache/include/geode/CqAttributes.hpp
index b4bbf07d..bbf15b92 100644
--- a/cppcache/include/geode/CqAttributes.hpp
+++ b/cppcache/include/geode/CqAttributes.hpp
@@ -55,7 +55,8 @@ class CPPCACHE_EXPORT CqAttributes {
    * Get the CqListeners set with the CQ.
    * Returns all the Listeners associated with this CQ.
    * @see CqListener
-   * @param[out] std::vector<CqListenerPtr> of CqListnerPtr
+   * @param[out] std::vector<std::shared_ptr<CqListener>> of
+   * std::shared_ptr<CqListner>
    */
   virtual listener_container_type getCqListeners() = 0;
 };
diff --git a/cppcache/include/geode/CqAttributesFactory.hpp b/cppcache/include/geode/CqAttributesFactory.hpp
index ce97d43d..48f1dcb5 100644
--- a/cppcache/include/geode/CqAttributesFactory.hpp
+++ b/cppcache/include/geode/CqAttributesFactory.hpp
@@ -70,14 +70,14 @@ class CPPCACHE_EXPORT CqAttributesFactory  {
    *          the <code>CqAttributes</code> used to initialize this
    *          AttributesFactory
    */
-  CqAttributesFactory(const CqAttributesPtr& cqAttributes);
+  CqAttributesFactory(const std::shared_ptr<CqAttributes>& cqAttributes);
 
   /**
    * Adds a CQ listener to the end of the list of cq listeners on this factory.
    * @param cqListener the CqListener to add to the factory.
    * @throws IllegalArgumentException if <code>cqListener</code> is nullptr
    */
-  void addCqListener(const CqListenerPtr& cqListener);
+  void addCqListener(const std::shared_ptr<CqListener>& cqListener);
 
   /**
    * Removes all Cq listeners and then adds each listener in the specified
@@ -88,16 +88,17 @@ class CPPCACHE_EXPORT CqAttributesFactory  {
    * a
    * nullptr element
    */
-  void initCqListeners(const std::vector<CqListenerPtr>& cqListeners);
+  void initCqListeners(
+      const std::vector<std::shared_ptr<CqListener>>& cqListeners);
 
   /**
    * Creates a <code>CqAttributes</code> with the current settings.
    * @return the newly created <code>CqAttributes</code>
    */
-  CqAttributesPtr create();
+  std::shared_ptr<CqAttributes> create();
 
  private:
-  CqAttributesPtr m_cqAttributes;
+  std::shared_ptr<CqAttributes> m_cqAttributes;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/CqAttributesMutator.hpp b/cppcache/include/geode/CqAttributesMutator.hpp
index 9f910f49..badfdd29 100644
--- a/cppcache/include/geode/CqAttributesMutator.hpp
+++ b/cppcache/include/geode/CqAttributesMutator.hpp
@@ -22,8 +22,7 @@
 
 #include "geode_globals.hpp"
 #include "geode_types.hpp"
-#include "VectorT.hpp"
-
+#include <vector>
 /**
  * @file
  */
@@ -31,7 +30,7 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class CqListener;
 /**
  * @class CqAttributesMutator CqAttributesMutator.hpp
  *
@@ -47,7 +46,7 @@ class CPPCACHE_EXPORT CqAttributesMutator {
    * @param aListener the user defined CQ listener to add to the CqQuery.
    * @throws IllegalArgumentException if <code>aListener</code> is nullptr
    */
-  virtual void addCqListener(const CqListenerPtr& aListener) = 0;
+  virtual void addCqListener(const std::shared_ptr<CqListener>& aListener) = 0;
 
   /**
    * Removes given CQ listener from the list of CQ listeners on this CqQuery.
@@ -57,7 +56,7 @@ class CPPCACHE_EXPORT CqAttributesMutator {
    * @param aListener the CQ listener to remove from the CqQuery.
    * @throws IllegalArgumentException if <code>aListener</code> is nullptr
    */
-  virtual void removeCqListener(const CqListenerPtr& aListener) = 0;
+  virtual void removeCqListener(const std::shared_ptr<CqListener>& aListener) = 0;
 
   /**
    * Adds the given set CqListner on this CQ. If the CQ already has CqListeners,
@@ -69,7 +68,7 @@ class CPPCACHE_EXPORT CqAttributesMutator {
    * has a nullptr element
    */
   virtual void setCqListeners(
-      const std::vector<CqListenerPtr>& newListeners) = 0;
+      const std::vector<std::shared_ptr<CqListener>>& newListeners) = 0;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/CqEvent.hpp b/cppcache/include/geode/CqEvent.hpp
index 283e0f37..cd71e775 100644
--- a/cppcache/include/geode/CqEvent.hpp
+++ b/cppcache/include/geode/CqEvent.hpp
@@ -35,7 +35,7 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class CqQuery;
 /**
  * @class CqEvent CqEvent.hpp
  *
@@ -61,7 +61,7 @@ class CPPCACHE_EXPORT CqEvent {
    * @see CqQuery
    * @return CqQuery object.
    */
-  virtual CqQueryPtr getCq() const = 0;
+  virtual std::shared_ptr<CqQuery> getCq() const = 0;
 
   /**
    * Get the operation on the base region that triggered this event.
@@ -82,7 +82,7 @@ class CPPCACHE_EXPORT CqEvent {
    * nullptr.
    * @return Object key.
    */
-  virtual CacheableKeyPtr getKey() const = 0;
+  virtual std::shared_ptr<CacheableKey> getKey() const = 0;
 
   /**
    * Get the new value of the modification.
@@ -90,7 +90,7 @@ class CPPCACHE_EXPORT CqEvent {
    * operation.
    * @return Object new/modified value.
    */
-  virtual CacheablePtr getNewValue() const = 0;
+  virtual std::shared_ptr<Cacheable> getNewValue() const = 0;
 
   /**
   * Get the delta modification.
@@ -98,7 +98,7 @@ class CPPCACHE_EXPORT CqEvent {
   *
   * @return CacheableBytes delta value.
   */
-  virtual CacheableBytesPtr getDeltaValue() const = 0;
+  virtual std::shared_ptr<CacheableBytes> getDeltaValue() const = 0;
 
  private:
   CqEvent(const CqEvent&);
diff --git a/cppcache/include/geode/CqListener.hpp b/cppcache/include/geode/CqListener.hpp
index 409c06ec..0f466398 100644
--- a/cppcache/include/geode/CqListener.hpp
+++ b/cppcache/include/geode/CqListener.hpp
@@ -31,7 +31,7 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class CacheListener;
 /**
  * @cacheserver
  * Querying is only supported for native clients.
diff --git a/cppcache/include/geode/CqQuery.hpp b/cppcache/include/geode/CqQuery.hpp
index ccdf97d1..3b335d75 100644
--- a/cppcache/include/geode/CqQuery.hpp
+++ b/cppcache/include/geode/CqQuery.hpp
@@ -38,6 +38,7 @@
 namespace apache {
 namespace geode {
 namespace client {
+class Query;
 
 /**
  * @class CqQuery CqQuery.hpp
@@ -64,7 +65,7 @@ class CPPCACHE_EXPORT CqQuery  {
    * Get teh query object generated for this CQs query.
    * @return Query object fort he query string
    */
-  virtual QueryPtr getQuery() const = 0;
+  virtual std::shared_ptr<Query> getQuery() const = 0;
   /**
    * Get the name of the CQ.
    * @return the name of the CQ.
@@ -74,17 +75,17 @@ class CPPCACHE_EXPORT CqQuery  {
    * Get the statistics information of this CQ.
    * @return CqStatistics, the CqStatistics object.
    */
-  virtual const CqStatisticsPtr getStatistics() const = 0;
+  virtual const std::shared_ptr<CqStatistics> getStatistics() const = 0;
   /**
    * Get the Attributes of this CQ.
    * @return CqAttributes, the CqAttributes object.
    */
-  virtual const CqAttributesPtr getCqAttributes() const = 0;
+  virtual const std::shared_ptr<CqAttributes> getCqAttributes() const = 0;
   /**
    * Get the AttributesMutator of this CQ.
    * @return CqAttributesMutator, the CqAttributesMutator object.
    */
-  virtual const CqAttributesMutatorPtr getCqAttributesMutator() const = 0;
+  virtual const std::shared_ptr<CqAttributesMutator> getCqAttributesMutator() const = 0;
 
   /**
    * Start executing the CQ or if this CQ is stopped earlier, resumes execution
@@ -105,7 +106,7 @@ class CPPCACHE_EXPORT CqQuery  {
    * @throws CqException if failed to execute and get initial results.
    * @return CqResults resultset obtained by executing the query.
    */
-  virtual CqResultsPtr executeWithInitialResults(
+  virtual std::shared_ptr<CqResults> executeWithInitialResults(
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
   /**
diff --git a/cppcache/include/geode/DataInput.hpp b/cppcache/include/geode/DataInput.hpp
index 4638487c..61c7846a 100644
--- a/cppcache/include/geode/DataInput.hpp
+++ b/cppcache/include/geode/DataInput.hpp
@@ -537,7 +537,7 @@ class CPPCACHE_EXPORT DataInput {
   template <class PTR>
   inline std::shared_ptr<PTR> readObject(
       bool throwOnError = DINP_THROWONERROR_DEFAULT) {
-    SerializablePtr sPtr = readObjectInternal();
+    auto sPtr = readObjectInternal();
     if (throwOnError) {
       return std::dynamic_pointer_cast<PTR>(sPtr);
     } else {
@@ -556,31 +556,31 @@ class CPPCACHE_EXPORT DataInput {
     return readInt32();
   }
 
-  inline CacheableStringPtr readNativeString() {
-    CacheableStringPtr csPtr;
+  inline std::shared_ptr<CacheableString> readNativeString() {
+    std::shared_ptr<CacheableString> csPtr;
     const int64_t compId = read();
     if (compId == GeodeTypeIds::NullObj) {
       csPtr = nullptr;
     } else if (compId == GeodeTypeIds::CacheableNullString) {
-      csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
+      csPtr = std::shared_ptr<CacheableString>(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializable()));
     } else if (compId ==
                apache::geode::client::GeodeTypeIds::CacheableASCIIString) {
-      csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
+      csPtr = std::shared_ptr<CacheableString>(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializable()));
       csPtr->fromData(*this);
     } else if (compId ==
                apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge) {
-      csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
+      csPtr = std::shared_ptr<CacheableString>(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializableHuge()));
       csPtr->fromData(*this);
     } else if (compId == apache::geode::client::GeodeTypeIds::CacheableString) {
-      csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
+      csPtr = std::shared_ptr<CacheableString>(dynamic_cast<CacheableString*>(
           CacheableString::createUTFDeserializable()));
       csPtr->fromData(*this);
     } else if (compId ==
                apache::geode::client::GeodeTypeIds::CacheableStringHuge) {
-      csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
+      csPtr = std::shared_ptr<CacheableString>(dynamic_cast<CacheableString*>(
           CacheableString::createUTFDeserializableHuge()));
       csPtr->fromData(*this);
     } else {
@@ -591,7 +591,7 @@ class CPPCACHE_EXPORT DataInput {
     return csPtr;
   }
 
-  inline SerializablePtr readDirectObject(int8_t typeId = -1) {
+  inline std::shared_ptr<Serializable> readDirectObject(int8_t typeId = -1) {
     return readObjectInternal(typeId);
   }
 
@@ -599,7 +599,9 @@ class CPPCACHE_EXPORT DataInput {
    * Read a <code>Serializable</code> object from the <code>DataInput</code>.
    * Null objects are handled.
    */
-  inline void readObject(SerializablePtr& ptr) { ptr = readObjectInternal(); }
+  inline void readObject(std::shared_ptr<Serializable>& ptr) {
+    ptr = readObjectInternal();
+  }
 
   inline void readObject(wchar_t* value) {
     uint16_t temp = readInt16();
@@ -899,7 +901,7 @@ class CPPCACHE_EXPORT DataInput {
   const char* m_poolName;
   const Cache* m_cache;
 
-  SerializablePtr readObjectInternal(int8_t typeId = -1);
+  std::shared_ptr<Serializable> readObjectInternal(int8_t typeId = -1);
 
   template <typename mType>
   void readObject(mType** value, int32_t& length) {
diff --git a/cppcache/include/geode/DataOutput.hpp b/cppcache/include/geode/DataOutput.hpp
index fa04bf5c..20dba2d0 100644
--- a/cppcache/include/geode/DataOutput.hpp
+++ b/cppcache/include/geode/DataOutput.hpp
@@ -307,7 +307,7 @@ class CPPCACHE_EXPORT DataOutput {
     // create cacheable string
     // write typeid id.
     // call todata
-    CacheableStringPtr csPtr = CacheableString::create(value);
+    auto csPtr = CacheableString::create(value);
     write(csPtr->typeId());
     csPtr->toData(*this);
   }
diff --git a/cppcache/include/geode/DefaultResultCollector.hpp b/cppcache/include/geode/DefaultResultCollector.hpp
index a9d93f61..8a4a4a00 100644
--- a/cppcache/include/geode/DefaultResultCollector.hpp
+++ b/cppcache/include/geode/DefaultResultCollector.hpp
@@ -28,7 +28,6 @@
 #include "geode_globals.hpp"
 #include "geode_types.hpp"
 
-#include "VectorT.hpp"
 #include "CacheableBuiltins.hpp"
 #include "ResultCollector.hpp"
 
@@ -45,18 +44,18 @@ class CPPCACHE_EXPORT DefaultResultCollector : public ResultCollector {
   DefaultResultCollector();
   virtual ~DefaultResultCollector() noexcept;
 
-  virtual CacheableVectorPtr getResult(
+  virtual std::shared_ptr<CacheableVector> getResult(
       std::chrono::milliseconds timeout =
           DEFAULT_QUERY_RESPONSE_TIMEOUT) override;
 
-  virtual void addResult(const CacheablePtr& resultOfSingleExecution) override;
+  virtual void addResult(const std::shared_ptr<Cacheable>& resultOfSingleExecution) override;
 
   virtual void endResults() override;
 
   virtual void clearResults() override;
 
  private:
-  CacheableVectorPtr resultList;
+  std::shared_ptr<CacheableVector> resultList;
   bool ready;
   std::condition_variable readyCondition;
   std::mutex readyMutex;
diff --git a/cppcache/include/geode/Delta.hpp b/cppcache/include/geode/Delta.hpp
index 8b9f8dcd..da6da6b1 100644
--- a/cppcache/include/geode/Delta.hpp
+++ b/cppcache/include/geode/Delta.hpp
@@ -43,16 +43,16 @@ namespace client {
  * of the class.
  */
 
-class Delta {
+class CPPCACHE_EXPORT Delta {
  public:
   /**
    * <code>hasDelta( )</code> is invoked by Geode during <code>Region::put(
-   * CacheableKeyPtr, CacheablePtr )</code> to determine if the object contains
-   * a delta.
-   * If <code>hasDelta( )</code> returns true, the delta in the object is
-   * serialized by invoking <code>Delta::toDelta( DataOutput& )</code>.
-   * If <code>hasDelta( )</code> returns false, the object is serialized by
-   * invoking <code>Cacheable::toData( DataOutput& )</code>.
+   * std::shared_ptr<CacheableKey>, std::shared_ptr<Cacheable> )</code> to
+   * determine if the object contains a delta. If <code>hasDelta( )</code>
+   * returns true, the delta in the object is serialized by invoking
+   * <code>Delta::toDelta( DataOutput& )</code>. If <code>hasDelta( )</code>
+   * returns false, the object is serialized by invoking
+   * <code>Cacheable::toData( DataOutput& )</code>.
    */
   virtual bool hasDelta() = 0;
 
@@ -88,7 +88,7 @@ class Delta {
    * a buffer, then deserializing from the buffer thus creating a clone of the
    * original.
    */
-  virtual DeltaPtr clone();
+  virtual std::shared_ptr<Delta> clone();
 
   virtual ~Delta() {}
 
diff --git a/cppcache/include/geode/DistributedSystem.hpp b/cppcache/include/geode/DistributedSystem.hpp
index b547e6e5..03666295 100644
--- a/cppcache/include/geode/DistributedSystem.hpp
+++ b/cppcache/include/geode/DistributedSystem.hpp
@@ -29,7 +29,6 @@
 #include "geode_types.hpp"
 #include "ExceptionTypes.hpp"
 #include "Properties.hpp"
-#include "VectorT.hpp"
 
 namespace apache {
 namespace geode {
@@ -67,7 +66,7 @@ class CPPCACHE_EXPORT DistributedSystem {
    **/
   static std::unique_ptr<DistributedSystem> create(
       const std::string& name, Cache* cache,
-      const PropertiesPtr& configPtr = nullptr);
+      const std::shared_ptr<Properties>& configPtr = nullptr);
 
   /**
    * @brief connects from the distributed system
diff --git a/cppcache/include/geode/EntryEvent.hpp b/cppcache/include/geode/EntryEvent.hpp
index b38edc34..6abeffd9 100644
--- a/cppcache/include/geode/EntryEvent.hpp
+++ b/cppcache/include/geode/EntryEvent.hpp
@@ -35,19 +35,22 @@ namespace client {
  * the circumstances of the event. */
 class CPPCACHE_EXPORT EntryEvent {
  protected:
-  RegionPtr m_region;      /**< Region */
-  CacheableKeyPtr m_key;   /**< Cacheable key */
-  CacheablePtr m_oldValue; /**< Old value */
-  CacheablePtr m_newValue; /**< New value */
-  SerializablePtr
+  std::shared_ptr<Region> m_region;      /**< Region */
+  std::shared_ptr<CacheableKey> m_key;   /**< Cacheable key */
+  std::shared_ptr<Cacheable> m_oldValue; /**< Old value */
+  std::shared_ptr<Cacheable> m_newValue; /**< New value */
+  std::shared_ptr<Serializable>
       m_callbackArgument; /**< Callback argument for this event, if any. */
   bool m_remoteOrigin;    /**< True if from a remote (non-local) process */
 
  public:
   /** Constructor, given all values. */
-  EntryEvent(const RegionPtr& region, const CacheableKeyPtr& key,
-             const CacheablePtr& oldValue, const CacheablePtr& newValue,
-             const SerializablePtr& aCallbackArgument, const bool remoteOrigin);
+  EntryEvent(const std::shared_ptr<Region>& region,
+             const std::shared_ptr<CacheableKey>& key,
+             const std::shared_ptr<Cacheable>& oldValue,
+             const std::shared_ptr<Cacheable>& newValue,
+             const std::shared_ptr<Serializable>& aCallbackArgument,
+             const bool remoteOrigin);
 
   /** Destructor. */
   virtual ~EntryEvent();
@@ -56,29 +59,31 @@ class CPPCACHE_EXPORT EntryEvent {
   EntryEvent();
 
   /** @return the region this event occurred in. */
-  inline RegionPtr getRegion() const { return m_region; }
+  inline std::shared_ptr<Region> getRegion() const { return m_region; }
 
   /** @return the key this event describes. */
-  inline CacheableKeyPtr getKey() const { return m_key; }
+  inline std::shared_ptr<CacheableKey> getKey() const { return m_key; }
 
   /** If the prior state of the entry was invalid, or non-existent/destroyed,
    * then the old value will be nullptr.
    * @return the old value in the cache.
    */
-  inline CacheablePtr getOldValue() const { return m_oldValue; }
+  inline std::shared_ptr<Cacheable> getOldValue() const { return m_oldValue; }
 
   /** If the event is a destroy or invalidate operation, then the new value
    * will be nullptr.
    * @return the updated value from this event
    */
-  inline CacheablePtr getNewValue() const { return m_newValue; }
+  inline std::shared_ptr<Cacheable> getNewValue() const { return m_newValue; }
 
   /**
    * Returns the callbackArgument passed to the method that generated
    * this event. See the {@link Region} interface methods that take
    * a callbackArgument parameter.
    */
-  inline SerializablePtr getCallbackArgument() const { return m_callbackArgument; }
+  inline std::shared_ptr<Serializable> getCallbackArgument() const {
+    return m_callbackArgument;
+  }
 
   /** If the event originated in a remote process, returns true. */
   inline bool remoteOrigin() const { return m_remoteOrigin; }
diff --git a/cppcache/include/geode/Exception.hpp b/cppcache/include/geode/Exception.hpp
index c94e030c..a2618e86 100644
--- a/cppcache/include/geode/Exception.hpp
+++ b/cppcache/include/geode/Exception.hpp
@@ -35,11 +35,9 @@ namespace client {
 
 #define GF_EX_MSG_LIMIT 2048
 
-class Exception;
-typedef std::shared_ptr<Exception> ExceptionPtr;
-
 class DistributedSystem;
-
+class CacheableString;
+class StackTrace;
 /**
  * @class Exception Exception.hpp
  * A description of an exception that occurred during a cache operation.
@@ -58,7 +56,7 @@ class CPPCACHE_EXPORT Exception {
    *               retrieved using <code>getCause</code>
    **/
   Exception(const char* msg1, const char* msg2 = nullptr,
-            bool forceTrace = false, const ExceptionPtr& cause = nullptr);
+            bool forceTrace = false, const std::shared_ptr<Exception>& cause = nullptr);
 
   explicit Exception(const std::string& msg1);
 
@@ -108,18 +106,19 @@ class CPPCACHE_EXPORT Exception {
    */
   virtual void raise() { throw *this; }
 
-  inline ExceptionPtr getCause() const { return m_cause; }
+  inline std::shared_ptr<Exception> getCause() const { return m_cause; }
 
  protected:
   /** internal constructor used to clone this exception */
-  Exception(const CacheableStringPtr& message, const StackTracePtr& stack,
-            const ExceptionPtr& cause);
+  Exception(const std::shared_ptr<CacheableString>& message,
+            const std::shared_ptr<StackTrace>& stack,
+            const std::shared_ptr<Exception>& cause);
 
   static bool s_exceptionStackTraceEnabled;
 
-  CacheableStringPtr m_message;  // error message
-  StackTracePtr m_stack;
-  ExceptionPtr m_cause;
+  std::shared_ptr<CacheableString> m_message;  // error message
+  std::shared_ptr<StackTrace> m_stack;
+  std::shared_ptr<Exception> m_cause;
 
  private:
   static void setStackTraces(bool stackTraceEnabled);
diff --git a/cppcache/include/geode/ExceptionTypes.hpp b/cppcache/include/geode/ExceptionTypes.hpp
index d7a09898..2dd5ddda 100644
--- a/cppcache/include/geode/ExceptionTypes.hpp
+++ b/cppcache/include/geode/ExceptionTypes.hpp
@@ -25,16 +25,17 @@
  */
 
 #include "geode_globals.hpp"
-#include "Exception.hpp"
-
+#include "geode/Exception.hpp"
+#include <memory>
 namespace apache {
 namespace geode {
 namespace client {
+class StackTrace;
+class CacheableString;
 
 #define _GF_EXCEPTION_DEF(x)                                            \
   const char _exception_name_##x[] = "apache::geode::client::" #x;      \
   class x;                                                              \
-  typedef std::shared_ptr<x> x##Ptr;                                    \
   class CPPCACHE_EXPORT x : public apache::geode::client::Exception {   \
    public:                                                              \
     using Exception::Exception;                                         \
@@ -43,11 +44,12 @@ namespace client {
     }                                                                   \
     virtual ~x() {}                                                     \
     virtual const char* getName() const { return _exception_name_##x; } \
-    virtual void raise() { throw *this; }                               \
+    virtual void raise() { throw * this; }                              \
                                                                         \
    protected:                                                           \
-    x(const CacheableStringPtr& message, const StackTracePtr& stack,    \
-      const ExceptionPtr& cause)                                        \
+    x(const std::shared_ptr<CacheableString>& message,                  \
+      const std::shared_ptr<StackTrace>& stack,                         \
+      const std::shared_ptr<Exception>& cause)                          \
         : Exception(message, stack, cause) {}                           \
                                                                         \
    private:                                                             \
diff --git a/cppcache/include/geode/Execution.hpp b/cppcache/include/geode/Execution.hpp
index 935c6795..f82a60a6 100644
--- a/cppcache/include/geode/Execution.hpp
+++ b/cppcache/include/geode/Execution.hpp
@@ -25,7 +25,6 @@
 
 #include "geode_globals.hpp"
 #include "geode_types.hpp"
-#include "VectorT.hpp"
 #include "CacheableBuiltins.hpp"
 #include "ResultCollector.hpp"
 
@@ -59,7 +58,7 @@ class CPPCACHE_EXPORT Execution {
    * @throws UnsupportedOperationException if not called after
    *    FunctionService::onRegion(Region).
    */
-  virtual ExecutionPtr withFilter(CacheableVectorPtr routingObj) = 0;
+  virtual std::shared_ptr<Execution> withFilter(std::shared_ptr<CacheableVector> routingObj) = 0;
   /**
    * Specifies the user data passed to the function when it is executed.
    * @param args user data passed to the function execution
@@ -67,7 +66,7 @@ class CPPCACHE_EXPORT Execution {
    * @throws IllegalArgumentException if the input parameter is nullptr
    *
    */
-  virtual ExecutionPtr withArgs(CacheablePtr args) = 0;
+  virtual std::shared_ptr<Execution> withArgs(std::shared_ptr<Cacheable> args) = 0;
   /**
    * Specifies the {@link ResultCollector} that will receive the results after
    * the function has been executed.
@@ -75,7 +74,7 @@ class CPPCACHE_EXPORT Execution {
    * @throws IllegalArgumentException if {@link ResultCollector} is nullptr
    * @see ResultCollector
    */
-  virtual ExecutionPtr withCollector(ResultCollectorPtr rs) = 0;
+  virtual std::shared_ptr<Execution> withCollector(std::shared_ptr<ResultCollector> rs) = 0;
   /**
    * Executes the function using its name
    * <p>
@@ -85,7 +84,7 @@ class CPPCACHE_EXPORT Execution {
    * @return either a default result collector or one specified by {@link
    * #withCollector(ResultCollector)}
    */
-  virtual ResultCollectorPtr execute(
+  virtual std::shared_ptr<ResultCollector> execute(
       const char* func,
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
@@ -104,10 +103,11 @@ class CPPCACHE_EXPORT Execution {
    * @return either a default result collector or one specified by {@link
    * #withCollector(ResultCollector)}
    */
-  virtual ResultCollectorPtr execute(const CacheableVectorPtr& routingObj,
-                                     const CacheablePtr& args,
-                                     const ResultCollectorPtr& rs,
-                                     const char* func, std::chrono::milliseconds timeout) = 0;
+  virtual std::shared_ptr<ResultCollector> execute(
+      const std::shared_ptr<CacheableVector>& routingObj,
+      const std::shared_ptr<Cacheable>& args,
+      const std::shared_ptr<ResultCollector>& rs, const char* func,
+      std::chrono::milliseconds timeout) = 0;
 };
 
 }  // namespace client
diff --git a/cppcache/include/geode/FixedPartitionResolver.hpp b/cppcache/include/geode/FixedPartitionResolver.hpp
index 23f9d4ae..e6519b5a 100644
--- a/cppcache/include/geode/FixedPartitionResolver.hpp
+++ b/cppcache/include/geode/FixedPartitionResolver.hpp
@@ -35,7 +35,7 @@ class EntryEvent;
  * <p>
  * Geode uses the partition name returned by
  * {@link FixedPartitionResolver#getPartitionName(EntryEvent,
- * CacheableHashSetPtr)}
+ * std::shared_ptr<CacheableHashSet>)}
  * to determine on which member the data is being managed. Say, for example, you
  * want to
  * partition all Trades according to quarters. You can implement
@@ -45,7 +45,7 @@ class EntryEvent;
  *
  * public class QuarterPartitionResolver implements FixedPartitionResolver{<br>
  * &nbsp &nbsp public const char* getPartitionName(EntryEvent event,
- * CacheableHashSetPtr
+ * std::shared_ptr<CacheableHashSet>
  * allAvailablePartitions) {<br>
  * &nbsp &nbsp Date date = sdf.parse((String)opDetails.getKey());<br>
  * &nbsp &nbsp Calendar cal = Calendar.getInstance();<br>
diff --git a/cppcache/include/geode/FunctionService.hpp b/cppcache/include/geode/FunctionService.hpp
index 8041eff5..c33286d3 100644
--- a/cppcache/include/geode/FunctionService.hpp
+++ b/cppcache/include/geode/FunctionService.hpp
@@ -31,7 +31,9 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class Region;
+class Pool;
+class RegionService;
 /**
  * @class FunctionService FunctionService.hpp
  * entry point for function execution
@@ -57,7 +59,7 @@ class CPPCACHE_EXPORT FunctionService {
    * @throws NullPointerException
    *                 if the region passed in is nullptr
    */
-  static ExecutionPtr onRegion(const RegionPtr& region);
+  static std::shared_ptr<Execution> onRegion(const std::shared_ptr<Region>& region);
 
   /**
    * Returns a {@link Execution} object that can be used to execute a data
@@ -72,7 +74,7 @@ class CPPCACHE_EXPORT FunctionService {
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
-  inline static ExecutionPtr onServer(const PoolPtr& pool) {
+  inline static std::shared_ptr<Execution> onServer(const std::shared_ptr<Pool>& pool) {
     return onServerWithPool(pool);
   }
 
@@ -90,7 +92,7 @@ class CPPCACHE_EXPORT FunctionService {
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
-  inline static ExecutionPtr onServer(const RegionServicePtr& cache) {
+  inline static std::shared_ptr<Execution> onServer(const std::shared_ptr<RegionService>& cache) {
     return onServerWithCache(cache);
   }
 
@@ -107,7 +109,7 @@ class CPPCACHE_EXPORT FunctionService {
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
-  inline static ExecutionPtr onServers(const PoolPtr& pool) {
+  inline static std::shared_ptr<Execution> onServers(const std::shared_ptr<Pool>& pool) {
     return onServersWithPool(pool);
   }
 
@@ -125,20 +127,23 @@ class CPPCACHE_EXPORT FunctionService {
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
-  inline static ExecutionPtr onServers(const RegionServicePtr& cache) {
+  inline static std::shared_ptr<Execution> onServers(const std::shared_ptr<RegionService>& cache) {
     return onServersWithCache(cache);
   }
 
   virtual ~FunctionService() {}
 
  private:
-  static ExecutionPtr onServerWithPool(const PoolPtr& pool);
+  static std::shared_ptr<Execution> onServerWithPool(
+      const std::shared_ptr<Pool>& pool);
 
-  static ExecutionPtr onServerWithCache(const RegionServicePtr& cache);
+  static std::shared_ptr<Execution> onServerWithCache(
+      const std::shared_ptr<RegionService>& cache);
 
-  static ExecutionPtr onServersWithPool(const PoolPtr& pool);
+  static std::shared_ptr<Execution> onServersWithPool(
+      const std::shared_ptr<Pool>& pool);
 
-  static ExecutionPtr onServersWithCache(const RegionServicePtr& cache);
+  static std::shared_ptr<Execution> onServersWithCache(const std::shared_ptr<RegionService>& cache);
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/GeodeCppCache.hpp b/cppcache/include/geode/GeodeCppCache.hpp
deleted file mode 100644
index 59fe70df..00000000
--- a/cppcache/include/geode/GeodeCppCache.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GEODECPPCACHE_H_
-#define GEODE_GEODECPPCACHE_H_
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @file
- */
-
-#include "geode_globals.hpp"
-#include "Cacheable.hpp"
-#include "CacheableKey.hpp"
-#include "CacheableBuiltins.hpp"
-#include "CacheableDate.hpp"
-#include "CacheableFileName.hpp"
-#include "CacheableObjectArray.hpp"
-#include "CacheableString.hpp"
-#include "CacheableUndefined.hpp"
-#include "CacheFactory.hpp"
-#include "Cache.hpp"
-#include "GeodeCache.hpp"
-#include "CacheAttributes.hpp"
-#include "CacheStatistics.hpp"
-#include "CqAttributesFactory.hpp"
-#include "CqAttributes.hpp"
-#include "CqListener.hpp"
-#include "CqQuery.hpp"
-#include "CqServiceStatistics.hpp"
-#include "DataInput.hpp"
-#include "DataOutput.hpp"
-#include "Delta.hpp"
-#include "DistributedSystem.hpp"
-#include "EntryEvent.hpp"
-#include "Exception.hpp"
-#include "ExceptionTypes.hpp"
-#include "Execution.hpp"
-#include "ExpirationAction.hpp"
-#include "ExpirationAttributes.hpp"
-#include "FunctionService.hpp"
-#include "HashMapT.hpp"
-#include "HashSetT.hpp"
-#include "Query.hpp"
-#include "QueryService.hpp"
-#include "RegionEvent.hpp"
-#include "Region.hpp"
-#include "Pool.hpp"
-#include "PoolManager.hpp"
-#include "PoolFactory.hpp"
-#include "RegionService.hpp"
-#include "ResultCollector.hpp"
-#include "ResultSet.hpp"
-#include "Serializable.hpp"
-#include <memory>
-#include "StructSet.hpp"
-#include "VectorT.hpp"
-#include "TransactionId.hpp"
-#include "UserFunctionExecutionException.hpp"
-#include "PdxInstanceFactory.hpp"
-#include "PdxInstance.hpp"
-#include "WritablePdxInstance.hpp"
-#include "PdxWrapper.hpp"
-#include "PdxSerializer.hpp"
-#include "CacheableEnum.hpp"
-#include "CqStatusListener.hpp"
-#include "PdxFieldTypes.hpp"
-
-#endif  // GEODE_GEODECPPCACHE_H_
diff --git a/cppcache/include/geode/HashFunction.hpp b/cppcache/include/geode/HashFunction.hpp
index 7abd2f8b..8f41a69d 100644
--- a/cppcache/include/geode/HashFunction.hpp
+++ b/cppcache/include/geode/HashFunction.hpp
@@ -32,10 +32,11 @@ namespace geode {
 namespace client {
 
 /** typedef for the hash function used by the hashing schemes. */
-typedef int32_t (*Hasher)(const SharedBasePtr&);
+typedef int32_t (*Hasher)(const std::shared_ptr<SharedBase>&);
 
 /** typedef for the hashing key equality function. */
-typedef bool (*EqualTo)(const SharedBasePtr&, const SharedBasePtr&);
+typedef bool (*EqualTo)(const std::shared_ptr<SharedBase>&,
+                        const std::shared_ptr<SharedBase>&);
 
 class HashSB {
  private:
@@ -47,7 +48,9 @@ class HashSB {
  public:
   HashSB(const Hasher hashFn) : m_hashFn(hashFn) {}
 
-  int32_t operator()(const SharedBasePtr& p) const { return m_hashFn(p); }
+  int32_t operator()(const std::shared_ptr<SharedBase>& p) const {
+    return m_hashFn(p);
+  }
 };
 
 class EqualToSB {
@@ -60,7 +63,8 @@ class EqualToSB {
  public:
   EqualToSB(const EqualTo equalFn) : m_equalFn(equalFn) {}
 
-  bool operator()(const SharedBasePtr& x, const SharedBasePtr& y) const {
+  bool operator()(const std::shared_ptr<SharedBase>& x,
+                  const std::shared_ptr<SharedBase>& y) const {
     return m_equalFn(x, y);
   }
 };
diff --git a/cppcache/include/geode/HashMapT.hpp b/cppcache/include/geode/HashMapT.hpp
index 8e322619..685268aa 100644
--- a/cppcache/include/geode/HashMapT.hpp
+++ b/cppcache/include/geode/HashMapT.hpp
@@ -33,17 +33,17 @@ namespace apache {
 namespace geode {
 namespace client {
 
-typedef std::unordered_map<CacheableKeyPtr, CacheablePtr,
-                           dereference_hash<CacheableKeyPtr>,
-                           dereference_equal_to<CacheableKeyPtr>>
+typedef std::unordered_map<std::shared_ptr<CacheableKey>,
+                           std::shared_ptr<Cacheable>,
+                           dereference_hash<std::shared_ptr<CacheableKey>>,
+                           dereference_equal_to<std::shared_ptr<CacheableKey>>>
     HashMapOfCacheable;
-typedef std::shared_ptr<HashMapOfCacheable> HashMapOfCacheablePtr;
 
-typedef std::unordered_map<CacheableKeyPtr, ExceptionPtr,
-                           dereference_hash<CacheableKeyPtr>,
-                           dereference_equal_to<CacheableKeyPtr>>
+typedef std::unordered_map<std::shared_ptr<CacheableKey>,
+                           std::shared_ptr<Exception>,
+                           dereference_hash<std::shared_ptr<CacheableKey>>,
+                           dereference_equal_to<std::shared_ptr<CacheableKey>>>
     HashMapOfException;
-typedef std::shared_ptr<HashMapOfException> HashMapOfExceptionPtr;
 
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/HashSetT.hpp b/cppcache/include/geode/HashSetT.hpp
index 488cebba..3e7f24ca 100644
--- a/cppcache/include/geode/HashSetT.hpp
+++ b/cppcache/include/geode/HashSetT.hpp
@@ -31,10 +31,10 @@ namespace apache {
 namespace geode {
 namespace client {
 
-typedef std::unordered_set<CacheableKeyPtr, dereference_hash<CacheableKeyPtr>,
-                           dereference_equal_to<CacheableKeyPtr>>
+typedef std::unordered_set<std::shared_ptr<CacheableKey>,
+                           dereference_hash<std::shared_ptr<CacheableKey>>,
+                           dereference_equal_to<std::shared_ptr<CacheableKey>>>
     HashSetOfCacheableKey;
-typedef std::shared_ptr<HashSetOfCacheableKey> HashSetOfCacheableKeyPtr;
 
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/PartitionResolver.hpp b/cppcache/include/geode/PartitionResolver.hpp
index 3a4f1b6f..8b07704c 100644
--- a/cppcache/include/geode/PartitionResolver.hpp
+++ b/cppcache/include/geode/PartitionResolver.hpp
@@ -29,7 +29,7 @@ namespace geode {
 namespace client {
 
 class EntryEvent;
-
+class CacheableKey;
 /**
  * Implementers of interface <code>PartitionResolver</code> enable custom
  * partitioning on the <code>PartitionedRegion</code>.
@@ -90,7 +90,8 @@ class CPPCACHE_EXPORT PartitionResolver {
    * @return object associated with entry event which allows the Partitioned
    * Region to store associated data together
    */
-  virtual CacheableKeyPtr getRoutingObject(const EntryEvent& opDetails) = 0;
+  virtual std::shared_ptr<CacheableKey> getRoutingObject(
+      const EntryEvent& opDetails) = 0;
 
  protected:
   /**
diff --git a/cppcache/include/geode/PdxInstance.hpp b/cppcache/include/geode/PdxInstance.hpp
index e8dc9faf..26935a63 100644
--- a/cppcache/include/geode/PdxInstance.hpp
+++ b/cppcache/include/geode/PdxInstance.hpp
@@ -27,7 +27,9 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class WritablePdxInstance;
+class CacheableDate;
+class CacheableObjectArray;
 /**
  * PdxInstance provides run time access to the fields of a PDX without
  * deserializing the PDX. Preventing deserialization saves time
@@ -61,7 +63,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
    *
    * @see serializationRegistry->addPdxType
    */
-  virtual PdxSerializablePtr getObject() = 0;
+  virtual std::shared_ptr<PdxSerializable> getObject() = 0;
 
   /**
    * Checks if the named field exists and returns the result.
@@ -74,10 +76,12 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
   virtual bool hasField(const char* fieldname) = 0;
 
   /**
-   * Reads the named field and set its value in CacheablePtr type out param.
-   * CacheablePtr type is corresponding to java object type.
+   * Reads the named field and set its value in std::shared_ptr<Cacheable> type
+   * out param. std::shared_ptr<Cacheable> type is corresponding to java object
+   * type.
    * @param fieldname name of the field to read
-   * @param value value of the field to be set with CacheablePtr type.
+   * @param value value of the field to be set with std::shared_ptr<Cacheable>
+   * type.
    * @throws IllegalStateException if PdxInstance doesn't has the named field.
    * For deserialization C++ Native Client requires the domain class to be
    * registered.
@@ -85,7 +89,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
    * @see serializationRegistry->addPdxType
    * @see PdxInstance#hasField
    */
-  virtual CacheablePtr getCacheableField(const char* fieldname) const = 0;
+  virtual std::shared_ptr<Cacheable> getCacheableField(const char* fieldname) const = 0;
 
   /**
    * Reads the named field and set its value in bool type out param.
@@ -360,15 +364,17 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
                         int32_t& length) const = 0;
 
   /**
-   * Reads the named field and set its value in CacheableDatePtr type out param.
-   * CacheableDatePtr type is corresponding to java Java.util.date type.
+   * Reads the named field and set its value in std::shared_ptr<CacheableDate>
+   * type out param. std::shared_ptr<CacheableDate> type is corresponding to
+   * java Java.util.date type.
    * @param fieldname name of the field to read
-   * @param value value of the field to be set with CacheableDatePtr type.
+   * @param value value of the field to be set with
+   * std::shared_ptr<CacheableDate> type.
    * @throws IllegalStateException if PdxInstance doesn't has the named field.
    *
    * @see PdxInstance#hasField
    */
-  virtual CacheableDatePtr getCacheableDateField(
+  virtual std::shared_ptr<CacheableDate> getCacheableDateField(
       const char* fieldname) const = 0;
 
   /**
@@ -388,20 +394,20 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
                         int32_t*& elementLength) const = 0;
 
   /**
-   * Reads the named field and set its value in CacheableObjectArrayPtr type out
-   * param.
-   * For deserialization C++ Native Client requires the domain class to be
-   * registered.
-   * CacheableObjectArrayPtr type is corresponding to java Object[] type.
+   * Reads the named field and set its value in
+   * std::shared_ptr<CacheableObjectArray> type out param. For deserialization
+   * C++ Native Client requires the domain class to be registered.
+   * std::shared_ptr<CacheableObjectArray> type is corresponding to java
+   * Object[] type.
    * @param fieldname name of the field to read.
-   * @param value value of the field to be set with CacheableObjectArrayPtr
-   * type.
+   * @param value value of the field to be set with
+   * std::shared_ptr<CacheableObjectArray> type.
    * @throws IllegalStateException if PdxInstance doesn't has the named field.
    *
    * @see serializationRegistry->addPdxType
    * @see PdxInstance#hasField
    */
-  virtual CacheableObjectArrayPtr getCacheableObjectArrayField(
+  virtual std::shared_ptr<CacheableObjectArray> getCacheableObjectArrayField(
       const char* fieldname) const = 0;
 
   /**
@@ -424,7 +430,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
    * made to the returned value will not modify this PdxInstance.
    * @return a {@link WritablePdxInstance}
    */
-  virtual WritablePdxInstancePtr createWriter() = 0;
+  virtual std::shared_ptr<WritablePdxInstance> createWriter() = 0;
 
   /**
    * Generates a hashcode based on the identity fields of
@@ -457,7 +463,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
    *
    * @see serializationRegistry->addPdxType
    */
-  virtual CacheableStringPtr toString() const = 0;
+  virtual std::shared_ptr<CacheableString> toString() const = 0;
 
   /**
    * @brief serialize this object. This is an internal method.
@@ -528,7 +534,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
    * Return an unmodifiable list of the field names on this PdxInstance.
    * @return an unmodifiable list of the field names on this PdxInstance
    */
-  virtual CacheableStringArrayPtr getFieldNames() = 0;
+  virtual std::shared_ptr<CacheableStringArray> getFieldNames() = 0;
 
   // From PdxSerializable
   /**
@@ -536,13 +542,13 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
    * method.
    * @param PdxWriter to serialize the PDX object
    */
-  virtual void toData(PdxWriterPtr output) = 0;
+  virtual void toData(std::shared_ptr<PdxWriter> output) = 0;
 
   /**
    * @brief Deserialize this object. This is an internal method.
    * @param PdxReader to Deserialize the PDX object
    */
-  virtual void fromData(PdxReaderPtr input) = 0;
+  virtual void fromData(std::shared_ptr<PdxReader> input) = 0;
 
   /**
    * Return the full name of the class that this pdx instance represents.
diff --git a/cppcache/include/geode/PdxInstanceFactory.hpp b/cppcache/include/geode/PdxInstanceFactory.hpp
index b7928aa9..2f1e0bf5 100644
--- a/cppcache/include/geode/PdxInstanceFactory.hpp
+++ b/cppcache/include/geode/PdxInstanceFactory.hpp
@@ -80,8 +80,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeChar(const char* fieldName,
-                                          char16_t value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeChar(const char* fieldName,
+                                                        char16_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -93,8 +93,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeChar(const char* fieldName,
-                                          char value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeChar(const char* fieldName,
+                                                        char value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -106,8 +106,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeBoolean(const char* fieldName,
-                                             bool value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeBoolean(
+      const char* fieldName, bool value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -119,8 +119,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeByte(const char* fieldName,
-                                          int8_t value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeByte(const char* fieldName,
+                                                        int8_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -132,8 +132,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeShort(const char* fieldName,
-                                           int16_t value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeShort(const char* fieldName,
+                                                         int16_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -145,8 +145,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeInt(const char* fieldName,
-                                         int32_t value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeInt(const char* fieldName,
+                                                       int32_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -158,8 +158,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeLong(const char* fieldName,
-                                          int64_t value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeLong(const char* fieldName,
+                                                        int64_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -171,8 +171,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeFloat(const char* fieldName,
-                                           float value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeFloat(const char* fieldName,
+                                                         float value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -184,21 +184,21 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeDouble(const char* fieldName,
-                                            double value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeDouble(const char* fieldName,
+                                                          double value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
    * The fields type is <code>CacheableDatePtr</code>.
-   * <p>Java Date is mapped to C++ CacheableDatePtr.</p>
+   * <p>Java Date is mapped to C++ std::shared_ptr<CacheableDate>.</p>
    * @param fieldName the name of the field to write
    * @param value the value of the field to write
    * @return this PdxInstanceFactory
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeDate(const char* fieldName,
-                                          CacheableDatePtr value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeDate(
+      const char* fieldName, std::shared_ptr<CacheableDate> value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -210,8 +210,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeWideString(const char* fieldName,
-                                                const wchar_t* value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeWideString(
+      const char* fieldName, const wchar_t* value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -223,13 +223,13 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeString(const char* fieldName,
-                                            const char* value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeString(
+      const char* fieldName, const char* value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
    * The fields type is <code>CacheablePtr</code>.
-   * <p>Java object is mapped to C++ CacheablePtr.</p>
+   * <p>Java object is mapped to C++ std::shared_ptr<Cacheable>.</p>
    * It is best to use one of the other writeXXX methods if your field type
    * will always be XXX. This method allows the field value to be anything
    * that is an instance of Object. This gives you more flexibility but more
@@ -243,8 +243,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeObject(const char* fieldName,
-                                            CacheablePtr value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeObject(
+      const char* fieldName, std::shared_ptr<Cacheable> value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -257,9 +257,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeBooleanArray(const char* fieldName,
-                                                  bool* value,
-                                                  int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeBooleanArray(
+      const char* fieldName, bool* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -272,9 +271,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeWideCharArray(const char* fieldName,
-                                                   wchar_t* value,
-                                                   int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeWideCharArray(
+      const char* fieldName, wchar_t* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -287,8 +285,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeCharArray(const char* fieldName,
-                                               char* value, int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeCharArray(
+      const char* fieldName, char* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -301,9 +299,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeByteArray(const char* fieldName,
-                                               int8_t* value,
-                                               int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeByteArray(
+      const char* fieldName, int8_t* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -316,9 +313,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeShortArray(const char* fieldName,
-                                                int16_t* value,
-                                                int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeShortArray(
+      const char* fieldName, int16_t* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -331,9 +327,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeIntArray(const char* fieldName,
-                                              int32_t* value,
-                                              int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeIntArray(
+      const char* fieldName, int32_t* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -346,9 +341,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeLongArray(const char* fieldName,
-                                               int64_t* value,
-                                               int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeLongArray(
+      const char* fieldName, int64_t* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -361,9 +355,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeFloatArray(const char* fieldName,
-                                                float* value,
-                                                int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeFloatArray(
+      const char* fieldName, float* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -376,9 +369,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeDoubleArray(const char* fieldName,
-                                                 double* value,
-                                                 int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeDoubleArray(
+      const char* fieldName, double* value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -391,9 +383,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeStringArray(const char* fieldName,
-                                                 char** value,
-                                                 int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeStringArray(
+      const char* fieldName, char** value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -406,14 +397,13 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeWideStringArray(const char* fieldName,
-                                                     wchar_t** value,
-                                                     int32_t length) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeWideStringArray(
+      const char* fieldName, wchar_t** value, int32_t length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
    * The fields type is <code>CacheableObjectArrayPtr</code>.
-   * Java Object[] is mapped to C++ CacheableObjectArrayPtr.
+   * Java Object[] is mapped to C++ std::shared_ptr<CacheableObjectArray>.
    * For how each element of the array is a mapped to C++ see {@link
    * #writeObject}.
    * Note that this call may serialize elements that are not compatible with
@@ -424,8 +414,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeObjectArray(
-      const char* fieldName, CacheableObjectArrayPtr value) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> writeObjectArray(
+      const char* fieldName, std::shared_ptr<CacheableObjectArray> value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -440,7 +430,7 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxInstanceFactoryPtr writeArrayOfByteArrays(
+  virtual std::shared_ptr<PdxInstanceFactory> writeArrayOfByteArrays(
       const char* fieldName, int8_t** value, int32_t arrayLength,
       int32_t* elementLength) = 0;
 
@@ -467,7 +457,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory {
    * @return this PdxInstanceFactory
    * @throws IllegalStateException if the named field does not exist.
    */
-  virtual PdxInstanceFactoryPtr markIdentityField(const char* fieldName) = 0;
+  virtual std::shared_ptr<PdxInstanceFactory> markIdentityField(
+      const char* fieldName) = 0;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/PdxReader.hpp b/cppcache/include/geode/PdxReader.hpp
index 8fc763c4..d86a86ee 100644
--- a/cppcache/include/geode/PdxReader.hpp
+++ b/cppcache/include/geode/PdxReader.hpp
@@ -28,8 +28,8 @@ namespace geode {
 namespace client {
 
 class PdxReader;
-typedef std::shared_ptr<PdxReader> PdxReaderPtr;
-
+class CacheableObjectArray;
+class CacheableDate;
 /**
  * A PdxReader will be passed to PdxSerializable.fromData or
  * during deserialization of a PDX. The domain class needs to deserialize field
@@ -42,7 +42,7 @@ typedef std::shared_ptr<PdxReader> PdxReaderPtr;
  *
  * @note Implementations of PdxReader that are internal to the Native
  *       Client library may be returned to clients via instances of
- *       PdxReaderPtr. For those implementations, any
+ *       std::shared_ptr<PdxReader>. For those implementations, any
  *       non-<tt>nullptr</tt>, non-empty strings returned from
  *       PdxReader::readString() or PdxReader::readWideString() must
  *       be freed with DataInput::freeUTFMemory(). Arrays returned
@@ -189,15 +189,15 @@ class CPPCACHE_EXPORT PdxReader {
   virtual wchar_t* readWideString(const char* fieldName) = 0;
 
   /**
-   * Read a CacheablePtr value from the <code>PdxReader</code>.
-   * <p>C++ CacheablePtr is mapped to Java object</p>
+   * Read a std::shared_ptr<Cacheable> value from the <code>PdxReader</code>.
+   * <p>C++ std::shared_ptr<Cacheable> is mapped to Java object</p>
    * @param fieldName name of the field to read
-   * @return value of type CacheablePtr.
+   * @return value of type std::shared_ptr<Cacheable>.
    * @throws IllegalStateException if PdxReader doesn't has the named field.
    *
    * @see PdxReader#hasField
    */
-  virtual CacheablePtr readObject(const char* fieldName) = 0;
+  virtual std::shared_ptr<Cacheable> readObject(const char* fieldName) = 0;
 
   /**
    * Read a char* value from the <code>PdxReader</code> and sets array length.
@@ -340,15 +340,17 @@ class CPPCACHE_EXPORT PdxReader {
                                         int32_t& length) = 0;
 
   /**
-   * Read a CacheableObjectArrayPtr value from the <code>PdxReader</code>.
-   * C++ CacheableObjectArrayPtr is mapped to Java Object[].
+   * Read a std::shared_ptr<CacheableObjectArray> value from the
+   * <code>PdxReader</code>. C++ std::shared_ptr<CacheableObjectArray> is mapped
+   * to Java Object[].
    * @param fieldName name of the field to read
-   * @return value of type CacheableObjectArrayPtr.
+   * @return value of type std::shared_ptr<CacheableObjectArray>.
    * @throws IllegalStateException if PdxReader doesn't has the named field.
    *
    * @see PdxReader#hasField
    */
-  virtual CacheableObjectArrayPtr readObjectArray(const char* fieldName) = 0;
+  virtual std::shared_ptr<CacheableObjectArray> readObjectArray(
+      const char* fieldName) = 0;
 
   /**
    * Read a int8_t** value from the <code>PdxReader</code> and sets
@@ -368,15 +370,16 @@ class CPPCACHE_EXPORT PdxReader {
                                          int32_t** elementLength) = 0;
 
   /**
-   * Read a CacheableDatePtr value from the <code>PdxReader</code>.
-   * <p>C++ CacheableDatePtr is mapped to Java Date</p>
+   * Read a std::shared_ptr<CacheableDate> value from the
+   * <code>PdxReader</code>. <p>C++ std::shared_ptr<CacheableDate> is mapped to
+   * Java Date</p>
    * @param fieldName name of the field to read
-   * @return value of type CacheableDatePtr.
+   * @return value of type std::shared_ptr<CacheableDate>.
    * @throws IllegalStateException if PdxReader doesn't has the named field.
    *
    * @see PdxReader#hasField
    */
-  virtual CacheableDatePtr readDate(const char* fieldName) = 0;
+  virtual std::shared_ptr<CacheableDate> readDate(const char* fieldName) = 0;
 
   /**
    * Checks if the named field exists and returns the result.
@@ -411,7 +414,7 @@ class CPPCACHE_EXPORT PdxReader {
    *
    * @return an object that represents the unread fields.
    */
-  virtual PdxUnreadFieldsPtr readUnreadFields() = 0;
+  virtual std::shared_ptr<PdxUnreadFields> readUnreadFields() = 0;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/PdxSerializable.hpp b/cppcache/include/geode/PdxSerializable.hpp
index fa411dd1..4ce1711c 100644
--- a/cppcache/include/geode/PdxSerializable.hpp
+++ b/cppcache/include/geode/PdxSerializable.hpp
@@ -25,6 +25,8 @@
 namespace apache {
 namespace geode {
 namespace client {
+class PdxWriter;
+class PdxReader;
 
 class CPPCACHE_EXPORT PdxSerializable : public CacheableKey {
  public:
@@ -36,8 +38,8 @@ class CPPCACHE_EXPORT PdxSerializable : public CacheableKey {
   // Solaris compiler gives "hides the virtual function" warnings when
   // compiling child classes while other compilers silently
   // accept but will cause problems with overloaded calls (in this case
-  //   no implicit conversion from PdxWriterPtr to DataOutput etc exists
-  //   so no imminent danger)
+  //   no implicit conversion from std::shared_ptr<PdxWriter> to DataOutput etc
+  //   exists so no imminent danger)
   // see
   // http://www.oracle.com/technetwork/server-storage/solarisstudio/documentation/cplusplus-faq-355066.html#Coding1
   // using Serializable::toData;
@@ -47,13 +49,13 @@ class CPPCACHE_EXPORT PdxSerializable : public CacheableKey {
    *@brief serialize this object in geode PDX format
    *@param PdxWriter to serialize the PDX object
    **/
-  virtual void toData(PdxWriterPtr output) /*const*/ = 0;
+  virtual void toData(std::shared_ptr<PdxWriter> output) /*const*/ = 0;
 
   /**
    *@brief Deserialize this object
    *@param PdxReader to Deserialize the PDX object
    **/
-  virtual void fromData(PdxReaderPtr input) = 0;
+  virtual void fromData(std::shared_ptr<PdxReader> input) = 0;
 
   /**
    *@brief return the typeId byte of the instance being serialized.
@@ -94,7 +96,7 @@ class CPPCACHE_EXPORT PdxSerializable : public CacheableKey {
    * the subclasses.
    * The default implementation renders the classname.
    */
-  virtual CacheableStringPtr toString() const;
+  virtual std::shared_ptr<CacheableString> toString() const;
 
   /**
    * Get the Type for the Object. Equivalent to the C# Type->GetType() API.
diff --git a/cppcache/include/geode/PdxSerializer.hpp b/cppcache/include/geode/PdxSerializer.hpp
index f2a0e94a..ca93e5c4 100644
--- a/cppcache/include/geode/PdxSerializer.hpp
+++ b/cppcache/include/geode/PdxSerializer.hpp
@@ -60,7 +60,8 @@ class CPPCACHE_EXPORT PdxSerializer  {
    * @param className the class name whose object need to de-serialize
    * @param pr the PdxReader stream to use for reading the object data
    */
-  virtual void* fromData(const char* className, PdxReaderPtr pr) = 0;
+  virtual void* fromData(const char* className,
+                         std::shared_ptr<PdxReader> pr) = 0;
 
   /**
    * Serializes this object in geode PDX format.
@@ -68,7 +69,7 @@ class CPPCACHE_EXPORT PdxSerializer  {
    * @param pw the PdxWriter object to use for serializing the object
    */
   virtual bool toData(void* userObject, const char* className,
-                      PdxWriterPtr pw) = 0;
+                      std::shared_ptr<PdxWriter> pw) = 0;
 
   /**
    * Get the function pointer to the user deallocator
diff --git a/cppcache/include/geode/PdxWrapper.hpp b/cppcache/include/geode/PdxWrapper.hpp
index 139384b5..a52fade9 100644
--- a/cppcache/include/geode/PdxWrapper.hpp
+++ b/cppcache/include/geode/PdxWrapper.hpp
@@ -44,7 +44,7 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
    * the Java side.
    */
   PdxWrapper(void* userObject, const char* className,
-             PdxSerializerPtr pdxSerializerPtr);
+             std::shared_ptr<PdxSerializer> pdxSerializerPtr);
 
   /**
    * Returns the pointer to the user object which is deserialized with a
@@ -71,12 +71,12 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
    *@brief serialize this object in geode PDX format
    *@param PdxWriter to serialize the PDX object
    **/
-  void toData(PdxWriterPtr output);
+  void toData(std::shared_ptr<PdxWriter> output);
   /**
    *@brief Deserialize this object
    *@param PdxReader to Deserialize the PDX object
    **/
-  void fromData(PdxReaderPtr input);
+  void fromData(std::shared_ptr<PdxReader> input);
   /**
    *@brief serialize this object
    **/
@@ -106,19 +106,20 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
    * the subclasses.
    * The default implementation renders the classname.
    */
-  CacheableStringPtr toString() const;
+  std::shared_ptr<CacheableString> toString() const;
 
   virtual ~PdxWrapper();
 
  private:
   /** hide default constructor */
   PdxWrapper();
-  PdxWrapper(const char* className, PdxSerializerPtr pdxSerializerPtr);
+  PdxWrapper(const char* className,
+             std::shared_ptr<PdxSerializer> pdxSerializerPtr);
 
   FRIEND_STD_SHARED_PTR(PdxWrapper)
 
   void* m_userObject;
-  PdxSerializerPtr m_serializer;
+  std::shared_ptr<PdxSerializer> m_serializer;
   UserDeallocator m_deallocator;
   UserObjectSizer m_sizer;
   char* m_className;
diff --git a/cppcache/include/geode/PdxWriter.hpp b/cppcache/include/geode/PdxWriter.hpp
index b59f5efb..3325c343 100644
--- a/cppcache/include/geode/PdxWriter.hpp
+++ b/cppcache/include/geode/PdxWriter.hpp
@@ -29,9 +29,8 @@ namespace apache {
 namespace geode {
 namespace client {
 
-class PdxWriter;
-typedef std::shared_ptr<PdxWriter> PdxWriterPtr;
-
+class CacheableObjectArray;
+class PdxUnreadFields;
 /**
  * A PdxWriter will be passed to PdxSerializable.toData
  * when it is serializing the domain class. The domain class needs to serialize
@@ -60,7 +59,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeChar(const char* fieldName, char value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeChar(const char* fieldName,
+                                               char value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form
@@ -72,7 +72,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeChar(const char* fieldName, char16_t value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeChar(const char* fieldName,
+                                               char16_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -84,7 +85,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeBoolean(const char* fieldName, bool value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeBoolean(const char* fieldName,
+                                                  bool value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -96,7 +98,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeByte(const char* fieldName, int8_t value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeByte(const char* fieldName,
+                                               int8_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -108,7 +111,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeShort(const char* fieldName, int16_t value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeShort(const char* fieldName,
+                                                int16_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -120,7 +124,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeInt(const char* fieldName, int32_t value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeInt(const char* fieldName,
+                                              int32_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -132,7 +137,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeLong(const char* fieldName, int64_t value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeLong(const char* fieldName,
+                                               int64_t value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -144,7 +150,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeFloat(const char* fieldName, float value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeFloat(const char* fieldName,
+                                                float value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -156,20 +163,21 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeDouble(const char* fieldName, double value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeDouble(const char* fieldName,
+                                                 double value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
    * The fields type is <code>CacheableDatePtr</code>.
-   * <p>C++ CacheableDatePtr is mapped to Java Date</p>
+   * <p>C++ std::shared_ptr<CacheableDate> is mapped to Java Date</p>
    * @param fieldName the name of the field to write
    * @param value the value of the field to write
    * @return this PdxWriter
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeDate(const char* fieldName,
-                                 CacheableDatePtr date) = 0;
+  virtual std::shared_ptr<PdxWriter> writeDate(
+      const char* fieldName, std::shared_ptr<CacheableDate> date) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -181,8 +189,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeString(const char* fieldName,
-                                   const char* value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeString(const char* fieldName,
+                                                 const char* value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -194,13 +202,13 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty
    */
-  virtual PdxWriterPtr writeWideString(const char* fieldName,
-                                       const wchar_t* value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeWideString(const char* fieldName,
+                                                     const wchar_t* value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
    * The fields type is <code>CacheablePtr</code>.
-   * <p>C++ CacheablePtr is mapped to Java object.</p>
+   * <p>C++ std::shared_ptr<Cacheable> is mapped to Java object.</p>
    * It is best to use one of the other writeXXX methods if your field type
    * will always be XXX. This method allows the field value to be anything
    * that is an instance of Object. This gives you more flexibility but more
@@ -214,8 +222,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeObject(const char* fieldName,
-                                   CacheablePtr value) = 0;
+  virtual std::shared_ptr<PdxWriter> writeObject(
+      const char* fieldName, std::shared_ptr<Cacheable> value) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -228,8 +236,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeBooleanArray(const char* fieldName, bool* array,
-                                         int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeBooleanArray(const char* fieldName,
+                                                       bool* array,
+                                                       int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -242,8 +251,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeWideCharArray(const char* fieldName, wchar_t* array,
-                                          int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeWideCharArray(const char* fieldName,
+                                                        wchar_t* array,
+                                                        int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -256,8 +266,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeCharArray(const char* fieldName, char* array,
-                                      int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeCharArray(const char* fieldName,
+                                                    char* array,
+                                                    int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -270,8 +281,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeByteArray(const char* fieldName, int8_t* array,
-                                      int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeByteArray(const char* fieldName,
+                                                    int8_t* array,
+                                                    int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -284,8 +296,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeShortArray(const char* fieldName, int16_t* array,
-                                       int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeShortArray(const char* fieldName,
+                                                     int16_t* array,
+                                                     int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -298,8 +311,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeIntArray(const char* fieldName, int32_t* array,
-                                     int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeIntArray(const char* fieldName,
+                                                   int32_t* array,
+                                                   int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -312,8 +326,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeLongArray(const char* fieldName, int64_t* array,
-                                      int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeLongArray(const char* fieldName,
+                                                    int64_t* array,
+                                                    int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -326,8 +341,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeFloatArray(const char* fieldName, float* array,
-                                       int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeFloatArray(const char* fieldName,
+                                                     float* array,
+                                                     int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -340,8 +356,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeDoubleArray(const char* fieldName, double* array,
-                                        int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeDoubleArray(const char* fieldName,
+                                                      double* array,
+                                                      int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -354,8 +371,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeStringArray(const char* fieldName, char** array,
-                                        int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeStringArray(const char* fieldName,
+                                                      char** array,
+                                                      int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -368,13 +386,14 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeWideStringArray(const char* fieldName,
-                                            wchar_t** array, int length) = 0;
+  virtual std::shared_ptr<PdxWriter> writeWideStringArray(const char* fieldName,
+                                                          wchar_t** array,
+                                                          int length) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
    * The fields type is <code>CacheableObjectArrayPtr</code>.
-   * C++ CacheableObjectArrayPtr is mapped to Java Object[].
+   * C++ std::shared_ptr<CacheableObjectArray> is mapped to Java Object[].
    * For how each element of the array is a mapped to C++ see {@link
    * #writeObject}.
    * Note that this call may serialize elements that are not compatible with
@@ -385,8 +404,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeObjectArray(const char* fieldName,
-                                        CacheableObjectArrayPtr array) = 0;
+  virtual std::shared_ptr<PdxWriter> writeObjectArray(
+      const char* fieldName, std::shared_ptr<CacheableObjectArray> array) = 0;
 
   /**
    * Writes the named field with the given value to the serialized form.
@@ -401,9 +420,9 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if the named field has already been written
    * or fieldName is nullptr or empty.
    */
-  virtual PdxWriterPtr writeArrayOfByteArrays(const char* fieldName,
-                                              int8_t** array, int arrayLength,
-                                              int* elementLength) = 0;
+  virtual std::shared_ptr<PdxWriter> writeArrayOfByteArrays(
+      const char* fieldName, int8_t** array, int arrayLength,
+      int* elementLength) = 0;
 
   /**
    * Indicate that the given field name should be included in hashCode and
@@ -425,10 +444,11 @@ class CPPCACHE_EXPORT PdxWriter {
    * write* method.
    *
    * @param fieldName the name of the field to mark as an identity field.
-   * @returns this PdxWriterPtr
+   * @returns this std::shared_ptr<PdxWriter>
    * @throws IllegalStateException if the named field does not exist.
    */
-  virtual PdxWriterPtr markIdentityField(const char* fieldName) = 0;
+  virtual std::shared_ptr<PdxWriter> markIdentityField(
+      const char* fieldName) = 0;
 
   /**
    * Writes the given unread fields to the serialized form.
@@ -442,7 +462,8 @@ class CPPCACHE_EXPORT PdxWriter {
    * @throws IllegalStateException if one of the writeXXX methods has already
    * been called.
    */
-  virtual PdxWriterPtr writeUnreadFields(PdxUnreadFieldsPtr unread) = 0;
+  virtual std::shared_ptr<PdxWriter> writeUnreadFields(
+      std::shared_ptr<PdxUnreadFields> unread) = 0;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/PersistenceManager.hpp b/cppcache/include/geode/PersistenceManager.hpp
index 4b9c065c..8baebb25 100644
--- a/cppcache/include/geode/PersistenceManager.hpp
+++ b/cppcache/include/geode/PersistenceManager.hpp
@@ -37,9 +37,10 @@
 namespace apache {
 namespace geode {
 namespace client {
-
-typedef PersistenceManagerPtr (*getPersistenceManagerInstance)(
-    const RegionPtr&);
+class PersistenceManager;
+class Region;
+typedef std::shared_ptr<PersistenceManager> (*getPersistenceManagerInstance)(
+    const std::shared_ptr<Region>&);
 
 /**
  * @class PersistenceManager PersistenceManager.hpp
@@ -55,23 +56,23 @@ class CPPCACHE_EXPORT PersistenceManager {
    */
  public:
   /**
-  * Returns the current persistence manager.
-  * @return persistence manager
-  */
-  static PersistenceManagerPtr getPersistenceManager();
+   * Returns the current persistence manager.
+   * @return persistence manager
+   */
+  static std::shared_ptr<PersistenceManager> getPersistenceManager();
 
   /**
-  * Writes a key, value pair of region to the disk. The actual file or database
-  * related write operations should be implemented
-  * in this method by the class implementing this method.
-  * @param key the key to write.
-  * @param value the value to write
-  * @param PersistenceInfo related persistence information.
-  * @throws RegionDestroyedException is the region is already destroyed.
-  * @throws OutofMemoryException if the disk is full
-  * @throws DiskFailureException if the write fails due to disk fail.
-  */
-  virtual void write(const CacheableKeyPtr& key, const CacheablePtr& value,
+   * Writes a key, value pair of region to the disk. The actual file or database
+   * related write operations should be implemented
+   * in this method by the class implementing this method.
+   * @param key the key to write.
+   * @param value the value to write
+   * @param PersistenceInfo related persistence information.
+   * @throws RegionDestroyedException is the region is already destroyed.
+   * @throws OutofMemoryException if the disk is full
+   * @throws DiskFailureException if the write fails due to disk fail.
+   */
+  virtual void write(const std::shared_ptr<CacheableKey>& key, const std::shared_ptr<Cacheable>& value,
                      void*& PersistenceInfo) = 0;
 
   /**
@@ -88,17 +89,17 @@ class CPPCACHE_EXPORT PersistenceManager {
    * @throws InitfailedException if the persistence manager cannot be
    * initialized.
    */
-  virtual void init(const RegionPtr& region,
-                    const PropertiesPtr& diskProperties) = 0;
+  virtual void init(const std::shared_ptr<Region>& region,
+                    const std::shared_ptr<Properties>& diskProperties) = 0;
 
   /**
-  * Reads the value for the key from the disk.
-  * @param key is the key for which the value has to be read.
-  * @param PersistenceInfo related persistence information.
-  * @returns value of type CacheablePtr.
-  * @throws DiskCorruptException if the data to be read is corrupt.
-  */
-  virtual CacheablePtr read(const CacheableKeyPtr& key,
+   * Reads the value for the key from the disk.
+   * @param key is the key for which the value has to be read.
+   * @param PersistenceInfo related persistence information.
+   * @returns value of type std::shared_ptr<Cacheable>.
+   * @throws DiskCorruptException if the data to be read is corrupt.
+   */
+  virtual std::shared_ptr<Cacheable> read(const std::shared_ptr<CacheableKey>& key,
                             void*& PersistenceInfo) = 0;
 
   /**
@@ -108,13 +109,13 @@ class CPPCACHE_EXPORT PersistenceManager {
   virtual bool readAll() = 0;
 
   /**
-  * destroys the entry specified by the key in the argument.
-  * @param key is the key of the entry which is being destroyed.
-  * @param PersistenceInfo related persistence information.
-  * @throws RegionDestroyedException is the region is already destroyed.
-  * @throws EntryNotFoundException if the entry is not found on the disk.
-  */
-  virtual void destroy(const CacheableKeyPtr& key, void*& PersistenceInfo) = 0;
+   * destroys the entry specified by the key in the argument.
+   * @param key is the key of the entry which is being destroyed.
+   * @param PersistenceInfo related persistence information.
+   * @throws RegionDestroyedException is the region is already destroyed.
+   * @throws EntryNotFoundException if the entry is not found on the disk.
+   */
+  virtual void destroy(const std::shared_ptr<CacheableKey>& key, void*& PersistenceInfo) = 0;
 
   /**
    * Closes the persistence manager instance.
@@ -122,7 +123,7 @@ class CPPCACHE_EXPORT PersistenceManager {
    */
   virtual void close() = 0;
 
-  PersistenceManager(const RegionPtr& regionPtr);
+  PersistenceManager(const std::shared_ptr<Region>& regionPtr);
   PersistenceManager();
   /**
     * @brief destructor
@@ -132,7 +133,7 @@ class CPPCACHE_EXPORT PersistenceManager {
  protected:
   /** Region for this persistence manager.
    */
-  const RegionPtr m_regionPtr;
+  const std::shared_ptr<Region> m_regionPtr;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/Pool.hpp b/cppcache/include/geode/Pool.hpp
index 95fae983..2a0352ba 100644
--- a/cppcache/include/geode/Pool.hpp
+++ b/cppcache/include/geode/Pool.hpp
@@ -198,7 +198,7 @@ class CPPCACHE_EXPORT Pool : public std::enable_shared_from_this<Pool> {
    * <p> If a pool has no locators, then it cannot discover servers or locators
    * at runtime.
    */
-  virtual const CacheableStringArrayPtr getLocators() const = 0;
+  virtual const std::shared_ptr<CacheableStringArray> getLocators() const = 0;
 
   /**
    * Returns an unmodifiable list of
@@ -207,7 +207,7 @@ class CPPCACHE_EXPORT Pool : public std::enable_shared_from_this<Pool> {
    * when the pool was created or were discovered using this pools {@link
    * #getLocators locators}.
    */
-  virtual const CacheableStringArrayPtr getServers() = 0;
+  virtual const std::shared_ptr<CacheableStringArray> getServers() = 0;
 
   /**
    * Destroys this pool closing any connections it produced.
@@ -238,7 +238,7 @@ class CPPCACHE_EXPORT Pool : public std::enable_shared_from_this<Pool> {
    * @see Cache#getQueryService
    * @return the QueryService
    */
-  virtual QueryServicePtr getQueryService() = 0;
+  virtual std::shared_ptr<QueryService> getQueryService() = 0;
 
   virtual ~Pool();
 
@@ -277,8 +277,8 @@ class CPPCACHE_EXPORT Pool : public std::enable_shared_from_this<Pool> {
   int getPendingEventCount() const;
 
  protected:
-  Pool(PoolAttributesPtr attr);
-  PoolAttributesPtr m_attrs;
+  Pool(std::shared_ptr<PoolAttributes> attr);
+  std::shared_ptr<PoolAttributes> m_attrs;
 
  private:
   /**
@@ -291,8 +291,8 @@ class CPPCACHE_EXPORT Pool : public std::enable_shared_from_this<Pool> {
    * @returns Logical instance of cache to do operations on behalf of one
    * particular user.
    */
-  virtual RegionServicePtr createSecureUserCache(PropertiesPtr credentials,
-                                                 CacheImpl* cacheImpl);
+  virtual std::shared_ptr<RegionService> createSecureUserCache(
+      std::shared_ptr<Properties> credentials, CacheImpl* cacheImpl);
 
   Pool(const Pool&);
 
diff --git a/cppcache/include/geode/PoolFactory.hpp b/cppcache/include/geode/PoolFactory.hpp
index 98146118..85356df8 100644
--- a/cppcache/include/geode/PoolFactory.hpp
+++ b/cppcache/include/geode/PoolFactory.hpp
@@ -37,7 +37,7 @@ namespace client {
 
 class CacheImpl;
 class PoolAttributes;
-
+class Pool;
 /**
  * This interface provides for the configuration and creation of instances of
  * {@link Pool}.
@@ -490,7 +490,7 @@ class CPPCACHE_EXPORT PoolFactory {
    * @throws IllegalStateException if a locator or server has not been added.
    * @return the newly created pool.
    */
-  PoolPtr create(const char* name);
+  std::shared_ptr<Pool> create(const char* name);
 
   /**
    * By default setPRSingleHopEnabled is true<br>
@@ -520,7 +520,7 @@ class CPPCACHE_EXPORT PoolFactory {
   PoolFactory(const Cache& cache);
   PoolFactory(const PoolFactory&);
   void addCheck(const char* host, int port);
-  PoolAttributesPtr m_attrs;
+  std::shared_ptr<PoolAttributes> m_attrs;
   bool m_isSubscriptionRedundancy;
   bool m_addedServerOrLocator;
   const Cache& m_cache;
diff --git a/cppcache/include/geode/PoolManager.hpp b/cppcache/include/geode/PoolManager.hpp
index 26dd85a5..a0bb05b8 100644
--- a/cppcache/include/geode/PoolManager.hpp
+++ b/cppcache/include/geode/PoolManager.hpp
@@ -36,7 +36,9 @@ namespace geode {
 namespace client {
 
 class ThinClientPoolDM;
-typedef std::unordered_map<std::string, PoolPtr> HashMapOfPools;
+class FunctionService;
+
+typedef std::unordered_map<std::string, std::shared_ptr<Pool>> HashMapOfPools;
 
 /**
  * Manages creation and access to {@link Pool connection pools} for clients.
@@ -58,7 +60,7 @@ class CPPCACHE_EXPORT PoolManager {
    * which is used to configure and create new {@link Pool}s.
    * @return the new pool factory
    */
-  PoolFactoryPtr createFactory();
+  std::shared_ptr<PoolFactory> createFactory();
 
   /**
    * Returns a map containing all the pools in this manager.
@@ -79,7 +81,7 @@ class CPPCACHE_EXPORT PoolManager {
    * @return the existing connection pool or <code>nullptr</code> if it does not
    * exist.
    */
-  PoolPtr find(const char* name);
+  std::shared_ptr<Pool> find(const char* name);
 
   /**
    * Find the pool used by the given region.
@@ -88,7 +90,7 @@ class CPPCACHE_EXPORT PoolManager {
    * region does
    * not have a pool.
    */
-  PoolPtr find(RegionPtr region);
+  std::shared_ptr<Pool> find(std::shared_ptr<Region> region);
 
   /**
    * Unconditionally destroys all created pools that are in this manager.
@@ -102,9 +104,9 @@ class CPPCACHE_EXPORT PoolManager {
  private:
   void removePool(const char* name);
 
-  void addPool(const char* name, const PoolPtr& pool);
+  void addPool(const char* name, const std::shared_ptr<Pool>& pool);
 
-  PoolPtr getDefaultPool();
+  std::shared_ptr<Pool> getDefaultPool();
 
   class Impl;
   std::unique_ptr<Impl, void (*)(Impl*)> m_pimpl;
diff --git a/cppcache/include/geode/Properties.hpp b/cppcache/include/geode/Properties.hpp
index 82afa740..562143f2 100644
--- a/cppcache/include/geode/Properties.hpp
+++ b/cppcache/include/geode/Properties.hpp
@@ -49,8 +49,8 @@ class CPPCACHE_EXPORT Properties : public Serializable {
  public:
   class Visitor {
    public:
-    virtual void visit(const CacheableKeyPtr& key,
-                       const CacheablePtr& value) = 0;
+    virtual void visit(const std::shared_ptr<CacheableKey>& key,
+                       const std::shared_ptr<Cacheable>& value) = 0;
     virtual ~Visitor() {}
   };
 
@@ -59,14 +59,14 @@ class CPPCACHE_EXPORT Properties : public Serializable {
    *
    * @throws NullPointerException if the key is null
    */
-  CacheableStringPtr find(const char* key);
+  std::shared_ptr<CacheableString> find(const char* key);
   /**
    * Return the value for the given <code>CacheableKey</code>,
    * or nullptr if not found.
    *
    * @throws NullPointerException if the key is nullptr
    */
-  CacheablePtr find(const CacheableKeyPtr& key);
+  std::shared_ptr<Cacheable> find(const std::shared_ptr<CacheableKey>& key);
 
   /**
    * Add or update the string value for key.
@@ -87,7 +87,8 @@ class CPPCACHE_EXPORT Properties : public Serializable {
    *
    * @throws NullPointerException if the key is nullptr
    */
-  void insert(const CacheableKeyPtr& key, const CacheablePtr& value);
+  void insert(const std::shared_ptr<CacheableKey>& key,
+              const std::shared_ptr<Cacheable>& value);
 
   template <class _Rep, class _Period>
   void insert(const char* key,
@@ -107,7 +108,7 @@ class CPPCACHE_EXPORT Properties : public Serializable {
    *
    * @throws NullPointerException if the key is nullptr
    */
-  void remove(const CacheableKeyPtr& key);
+  void remove(const std::shared_ptr<CacheableKey>& key);
 
   /** Execute the Visitor's <code>visit( const char* key, const char* value
    * )</code>
@@ -121,10 +122,10 @@ class CPPCACHE_EXPORT Properties : public Serializable {
   /** Add the contents of other to this instance, replacing any existing
    * values with those from other.
    */
-  void addAll(const PropertiesPtr& other);
+  void addAll(const std::shared_ptr<Properties>& other);
 
   /** Factory method, returns an empty collection. */
-  static PropertiesPtr create();
+  static std::shared_ptr<Properties> create();
 
   /** Read property values from a file, overriding what is currently
    * in the properties object.
diff --git a/cppcache/include/geode/Query.hpp b/cppcache/include/geode/Query.hpp
index 436d5473..5b3c6057 100644
--- a/cppcache/include/geode/Query.hpp
+++ b/cppcache/include/geode/Query.hpp
@@ -65,7 +65,7 @@ class CPPCACHE_EXPORT Query {
    * @returns A smart pointer to the SelectResults which can either be a
    * ResultSet or a StructSet.
    */
-  virtual SelectResultsPtr execute(
+  virtual std::shared_ptr<SelectResults> execute(
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
   /**
@@ -87,8 +87,8 @@ class CPPCACHE_EXPORT Query {
    * ResultSet or a StructSet.
    */
 
-  virtual SelectResultsPtr execute(
-      CacheableVectorPtr paramList,
+  virtual std::shared_ptr<SelectResults> execute(
+      std::shared_ptr<CacheableVector> paramList,
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
   /**
    * Get the query string provided when a new Query was created from a
diff --git a/cppcache/include/geode/QueryService.hpp b/cppcache/include/geode/QueryService.hpp
index 97af16cb..30545845 100644
--- a/cppcache/include/geode/QueryService.hpp
+++ b/cppcache/include/geode/QueryService.hpp
@@ -45,7 +45,7 @@ namespace client {
  */
 class CPPCACHE_EXPORT QueryService {
  public:
-  typedef std::vector<CqQueryPtr> query_container_type;
+  typedef std::vector<std::shared_ptr<CqQuery>> query_container_type;
 
   /**
    * Get a new Query with the specified query string.
@@ -53,7 +53,7 @@ class CPPCACHE_EXPORT QueryService {
    * @param querystr The query string with which to create a new Query.
    * @returns A smart pointer to the Query.
    */
-  virtual QueryPtr newQuery(const char* querystr) = 0;
+  virtual std::shared_ptr<Query> newQuery(const char* querystr) = 0;
 
   /**
    * @nativeclient
@@ -88,9 +88,9 @@ class CPPCACHE_EXPORT QueryService {
    *
    * @endnativeclient
    */
-  virtual CqQueryPtr newCq(const char* name, const char* querystr,
-                           const CqAttributesPtr& cqAttr,
-                           bool isDurable = false) = 0;
+  virtual std::shared_ptr<CqQuery> newCq(
+      const char* name, const char* querystr,
+      const std::shared_ptr<CqAttributes>& cqAttr, bool isDurable = false) = 0;
   /**
    * @nativeclient
    * Constructs a new named continuous query, represented by an instance of
@@ -123,8 +123,9 @@ class CPPCACHE_EXPORT QueryService {
    *
    * @endnativeclient
    */
-  virtual CqQueryPtr newCq(const char* querystr, const CqAttributesPtr& cqAttr,
-                           bool isDurable = false) = 0;
+  virtual std::shared_ptr<CqQuery> newCq(
+      const char* querystr, const std::shared_ptr<CqAttributes>& cqAttr,
+      bool isDurable = false) = 0;
   /**
    * @nativeclient
    * Close all CQs, and release resources
@@ -144,7 +145,7 @@ class CPPCACHE_EXPORT QueryService {
    * @return the CqQuery or nullptr if not found
    * @endnativeclient
    */
-  virtual CqQueryPtr getCq(const char* name) = 0;
+  virtual std::shared_ptr<CqQuery> getCq(const char* name) = 0;
   /**
    * @nativeclient
    * Executes all the cqs on this client.
@@ -163,7 +164,7 @@ class CPPCACHE_EXPORT QueryService {
    * @return the CqServiceStatistics
    * @endnativeclient
    */
-  virtual CqServiceStatisticsPtr getCqServiceStatistics() = 0;
+  virtual std::shared_ptr<CqServiceStatistics> getCqServiceStatistics() = 0;
 
   /**
    * Gets all the durable CQs registered by this client.
@@ -171,7 +172,7 @@ class CPPCACHE_EXPORT QueryService {
    * @return List of names of registered durable CQs, empty list if no durable
    * cqs.
    */
-  virtual CacheableArrayListPtr getAllDurableCqsFromServer() = 0;
+  virtual std::shared_ptr<CacheableArrayList> getAllDurableCqsFromServer() = 0;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/include/geode/Region.hpp b/cppcache/include/geode/Region.hpp
index 22c1585a..4ddf362d 100644
--- a/cppcache/include/geode/Region.hpp
+++ b/cppcache/include/geode/Region.hpp
@@ -49,6 +49,7 @@
 namespace apache {
 namespace geode {
 namespace client {
+class Pool;
 
 static constexpr std::chrono::milliseconds DEFAULT_RESPONSE_TIMEOUT =
     std::chrono::seconds(15);
@@ -102,21 +103,21 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   /** Returns the parent region, or nullptr if a root region.
    * @throws RegionDestroyedException
    */
-  virtual RegionPtr getParentRegion() const = 0;
+  virtual std::shared_ptr<Region> getParentRegion() const = 0;
 
   /** Return the RegionAttributes for this region.
    */
-  virtual RegionAttributesPtr getAttributes() const = 0;
+  virtual std::shared_ptr<RegionAttributes> getAttributes() const = 0;
 
   /** Return the a mutator object for changing a subset of the region
    * attributes.
    * @throws RegionDestroyedException.
    */
-  virtual AttributesMutatorPtr getAttributesMutator() const = 0;
+  virtual std::shared_ptr<AttributesMutator> getAttributesMutator() const = 0;
 
   // virtual void updateAccessOrModifiedTime() = 0;
 
-  virtual CacheStatisticsPtr getStatistics() const = 0;
+  virtual std::shared_ptr<CacheStatistics> getStatistics() const = 0;
 
   /** Invalidates this region. The invalidation will cascade to
    * all the subregions and cached entries. After
@@ -135,7 +136,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * This operation is not distributed.
    */
   virtual void invalidateRegion(
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Invalidates this region. The invalidation will cascade to
   * all the subregions and cached entries. After
@@ -157,7 +158,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
 
   */
   virtual void localInvalidateRegion(
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Destroys the whole region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> invoked in the process.
@@ -196,7 +197,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see  invalidateRegion
    */
   virtual void destroyRegion(
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
   /**
    * Removes all entries from this region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> or <code>CacheListener</code>
@@ -204,7 +205,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void clear(const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void clear(const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
   /**
    * Removes all entries from this region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> or <code>CacheListener</code>
@@ -212,7 +213,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void localClear(const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void localClear(const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Destroys the whole region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> invoked in the process.
@@ -234,34 +235,34 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see  localInvalidateRegion
    */
   virtual void localDestroyRegion(
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Returns the subregion identified by the path, nullptr if no such subregion
    */
-  virtual RegionPtr getSubregion(const char* path) = 0;
+  virtual std::shared_ptr<Region> getSubregion(const char* path) = 0;
 
   /** Creates a subregion with the specified attributes */
-  virtual RegionPtr createSubregion(
+  virtual std::shared_ptr<Region> createSubregion(
       const char* subregionName,
-      const RegionAttributesPtr& aRegionAttributes) = 0;
+      const std::shared_ptr<RegionAttributes>& aRegionAttributes) = 0;
 
-  /** Populates the passed in VectorOfRegion with subregions of the current
-   * region
+  /** Populates the passed in std::vector<std::shared_ptr<Region>> with
+   * subregions of the current region
    * @param recursive determines whether the method recursively fills in
    * subregions
    * @param[out] sr subregions
    * @throws RegionDestroyedException
    */
-  virtual VectorOfRegion subregions(const bool recursive) = 0;
+  virtual std::vector<std::shared_ptr<Region>> subregions(const bool recursive) = 0;
 
   /** Return the meta-object RegionEntry for key.
    * @throws IllegalArgumentException, RegionDestroyedException.
    */
-  virtual RegionEntryPtr getEntry(const CacheableKeyPtr& key) = 0;
+  virtual std::shared_ptr<RegionEntry> getEntry(const std::shared_ptr<CacheableKey>& key) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline RegionEntryPtr getEntry(const KEYTYPE& key) {
+  inline std::shared_ptr<RegionEntry> getEntry(const KEYTYPE& key) {
     return getEntry(createKey(key));
   }
 
@@ -306,13 +307,15 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws RegionDestroyedException if the method is called on a destroyed
    *region
    **/
-  virtual CacheablePtr get(const CacheableKeyPtr& key,
-                           const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual std::shared_ptr<Cacheable> get(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline CacheablePtr get(const KEYTYPE& key,
-                          const SerializablePtr& callbackArg = nullptr) {
+  inline std::shared_ptr<Cacheable> get(
+      const KEYTYPE& key,
+      const std::shared_ptr<Serializable>& callbackArg = nullptr) {
     return get(createKey(key), callbackArg);
   }
 
@@ -361,27 +364,30 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws TimeoutException if operation timed out
    * @throws OutOfMemoryException if  not enoough memory for the value
    */
-  virtual void put(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void put(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Cacheable>& value,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void put(const KEYTYPE& key, const VALUETYPE& value,
-                  const SerializablePtr& arg = nullptr) {
+                  const std::shared_ptr<Serializable>& arg = nullptr) {
     put(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void put(const KEYTYPE& key, const CacheablePtr& value,
-                  const SerializablePtr& arg = nullptr) {
+  inline void put(const KEYTYPE& key, const std::shared_ptr<Cacheable>& value,
+                  const std::shared_ptr<Serializable>& arg = nullptr) {
     put(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
-  inline void put(const CacheableKeyPtr& key, const VALUETYPE& value,
-                  const SerializablePtr& arg = nullptr) {
+  inline void put(const std::shared_ptr<CacheableKey>& key,
+                  const VALUETYPE& value,
+                  const std::shared_ptr<Serializable>& arg = nullptr) {
     put(key, createValue(value), arg);
   }
 
@@ -406,7 +412,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   virtual void putAll(
       const HashMapOfCacheable& map,
       std::chrono::milliseconds timeout = DEFAULT_RESPONSE_TIMEOUT,
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /**
    * Places a new value into an entry in this region with the specified key
@@ -432,27 +438,31 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws RegionDestroyedException if region no longer valid
    * @throws OutOfMemoryException if not enoough memory for the value
    */
-  virtual void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                        const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void localPut(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Cacheable>& value,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
-                       const SerializablePtr& arg = nullptr) {
+                       const std::shared_ptr<Serializable>& arg = nullptr) {
     localPut(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void localPut(const KEYTYPE& key, const CacheablePtr& value,
-                       const SerializablePtr& arg = nullptr) {
+  inline void localPut(const KEYTYPE& key,
+                       const std::shared_ptr<Cacheable>& value,
+                       const std::shared_ptr<Serializable>& arg = nullptr) {
     localPut(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
-  inline void localPut(const CacheableKeyPtr& key, const VALUETYPE& value,
-                       const SerializablePtr& arg = nullptr) {
+  inline void localPut(const std::shared_ptr<CacheableKey>& key,
+                       const VALUETYPE& value,
+                       const std::shared_ptr<Serializable>& arg = nullptr) {
     localPut(key, createValue(value), arg);
   }
 
@@ -502,27 +512,31 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws OutOfMemoryException if no memory for new entry
    * @throws EntryExistsException if an entry with this key already exists
    */
-  virtual void create(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void create(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Cacheable>& value,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void create(const KEYTYPE& key, const VALUETYPE& value,
-                     const SerializablePtr& arg = nullptr) {
+                     const std::shared_ptr<Serializable>& arg = nullptr) {
     create(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void create(const KEYTYPE& key, const CacheablePtr& value,
-                     const SerializablePtr& arg = nullptr) {
+  inline void create(const KEYTYPE& key,
+                     const std::shared_ptr<Cacheable>& value,
+                     const std::shared_ptr<Serializable>& arg = nullptr) {
     create(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
-  inline void create(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const SerializablePtr& arg = nullptr) {
+  inline void create(const std::shared_ptr<CacheableKey>& key,
+                     const VALUETYPE& value,
+                     const std::shared_ptr<Serializable>& arg = nullptr) {
     create(key, createValue(value), arg);
   }
 
@@ -551,28 +565,31 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws OutOfMemoryException if no memory for new entry
    * @throws EntryExistsException if an entry with this key already exists
    */
-  virtual void localCreate(const CacheableKeyPtr& key,
-                           const CacheablePtr& value,
-                           const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void localCreate(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Cacheable>& value,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
-                          const SerializablePtr& arg = nullptr) {
+                          const std::shared_ptr<Serializable>& arg = nullptr) {
     localCreate(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void localCreate(const KEYTYPE& key, const CacheablePtr& value,
-                          const SerializablePtr& arg = nullptr) {
+  inline void localCreate(const KEYTYPE& key,
+                          const std::shared_ptr<Cacheable>& value,
+                          const std::shared_ptr<Serializable>& arg = nullptr) {
     localCreate(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
-  inline void localCreate(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const SerializablePtr& arg = nullptr) {
+  inline void localCreate(const std::shared_ptr<CacheableKey>& key,
+                          const VALUETYPE& value,
+                          const std::shared_ptr<Serializable>& arg = nullptr) {
     localCreate(key, createValue(value), arg);
   }
 
@@ -598,12 +615,14 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see destroy
    * @see CacheListener::afterInvalidate
    */
-  virtual void invalidate(const CacheableKeyPtr& key,
-                          const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void invalidate(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void invalidate(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
+  inline void invalidate(const KEYTYPE& key,
+                         const std::shared_ptr<Serializable>& arg = nullptr) {
     invalidate(createKey(key), arg);
   }
 
@@ -628,13 +647,13 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterInvalidate
    */
   virtual void localInvalidate(
-      const CacheableKeyPtr& key,
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void localInvalidate(const KEYTYPE& key,
-                              const SerializablePtr& arg = nullptr) {
+  inline void localInvalidate(
+      const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
     localInvalidate(createKey(key), arg);
   }
 
@@ -682,12 +701,14 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterDestroy
    * @see CacheWriter::beforeDestroy
    */
-  virtual void destroy(const CacheableKeyPtr& key,
-                       const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void destroy(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void destroy(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
+  inline void destroy(const KEYTYPE& key,
+                      const std::shared_ptr<Serializable>& arg = nullptr) {
     destroy(createKey(key), arg);
   }
 
@@ -715,13 +736,14 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterDestroy
    * @see CacheWriter::beforeDestroy
    */
-  virtual void localDestroy(const CacheableKeyPtr& key,
-                            const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void localDestroy(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localDestroy(const KEYTYPE& key,
-                           const SerializablePtr& arg = nullptr) {
+                           const std::shared_ptr<Serializable>& arg = nullptr) {
     localDestroy(createKey(key), arg);
   }
 
@@ -773,31 +795,35 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterDestroy
    * @see CacheWriter::beforeDestroy
    */
-  virtual bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual bool remove(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Cacheable>& value,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
-                     const SerializablePtr& arg = nullptr) {
+                     const std::shared_ptr<Serializable>& arg = nullptr) {
     return remove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool remove(const KEYTYPE& key, const CacheablePtr& value,
-                     const SerializablePtr& arg = nullptr) {
+  inline bool remove(const KEYTYPE& key,
+                     const std::shared_ptr<Cacheable>& value,
+                     const std::shared_ptr<Serializable>& arg = nullptr) {
     return remove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
-  inline bool remove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const SerializablePtr& arg = nullptr) {
+  inline bool remove(const std::shared_ptr<CacheableKey>& key,
+                     const VALUETYPE& value,
+                     const std::shared_ptr<Serializable>& arg = nullptr) {
     return remove(key, createValue(value), arg);
   }
 
-  bool remove(const CacheableKeyPtr& key) { return removeEx(key); }
+  bool remove(const std::shared_ptr<CacheableKey>& key) { return removeEx(key); }
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE>
@@ -851,12 +877,14 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterDestroy
    * @see CacheWriter::beforeDestroy
    */
-  virtual bool removeEx(const CacheableKeyPtr& key,
-                        const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual bool removeEx(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool removeEx(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
+  inline bool removeEx(const KEYTYPE& key,
+                       const std::shared_ptr<Serializable>& arg = nullptr) {
     return removeEx(createKey(key), arg);
   }
 
@@ -887,28 +915,31 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterDestroy
    * @see CacheWriter::beforeDestroy
    */
-  virtual bool localRemove(const CacheableKeyPtr& key,
-                           const CacheablePtr& value,
-                           const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual bool localRemove(
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Cacheable>& value,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
-                          const SerializablePtr& arg = nullptr) {
+                          const std::shared_ptr<Serializable>& arg = nullptr) {
     return localRemove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool localRemove(const KEYTYPE& key, const CacheablePtr& value,
-                          const SerializablePtr& arg = nullptr) {
+  inline bool localRemove(const KEYTYPE& key,
+                          const std::shared_ptr<Cacheable>& value,
+                          const std::shared_ptr<Serializable>& arg = nullptr) {
     return localRemove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
-  inline bool localRemove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const SerializablePtr& arg = nullptr) {
+  inline bool localRemove(const std::shared_ptr<CacheableKey>& key,
+                          const VALUETYPE& value,
+                          const std::shared_ptr<Serializable>& arg = nullptr) {
     return localRemove(key, createValue(value), arg);
   }
 
@@ -939,13 +970,13 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    */
 
   virtual bool localRemoveEx(
-      const CacheableKeyPtr& key,
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool localRemoveEx(const KEYTYPE& key,
-                            const SerializablePtr& arg = nullptr) {
+  inline bool localRemoveEx(
+      const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
     return localRemoveEx(createKey(key), arg);
   }
 
@@ -953,7 +984,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * Return all the keys in the local process for this region. This includes
    * keys for which the entry is invalid.
    */
-  virtual VectorOfCacheableKey keys() = 0;
+  virtual std::vector<std::shared_ptr<CacheableKey>>  keys() = 0;
 
   /**
    * Return the set of keys defined in the server process associated to this
@@ -980,21 +1011,21 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws UnsupportedOperationException if the member type is not CLIENT
    *                                       or region is not a native client one.
    */
-  virtual VectorOfCacheableKey serverKeys() = 0;
+  virtual std::vector<std::shared_ptr<CacheableKey>>  serverKeys() = 0;
 
   /**
    * Return all values in the local process for this region. No value is
    * included for entries that are invalidated.
    */
-  virtual VectorOfCacheable values() = 0;
+  virtual std::vector<std::shared_ptr<Cacheable>> values() = 0;
 
-  virtual VectorOfRegionEntry entries(bool recursive) = 0;
+  virtual std::vector<std::shared_ptr<RegionEntry>> entries(bool recursive) = 0;
 
   /**
    * Returns the <code>cache</code> associated with this region.
    * @return the cache
    */
-  virtual RegionServicePtr getRegionService() const = 0;
+  virtual std::shared_ptr<RegionService> getRegionService() const = 0;
 
   virtual bool isDestroyed() const = 0;
 
@@ -1003,7 +1034,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * It is not propagated to the Geode cache server
    * to which it is connected.
    */
-  virtual bool containsValueForKey(const CacheableKeyPtr& keyPtr) const = 0;
+  virtual bool containsValueForKey(const std::shared_ptr<CacheableKey>& keyPtr) const = 0;
 
   /**
    * Convenience method allowing key to be a const char*
@@ -1021,28 +1052,28 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * server
    * to which it is connected with.
    */
-  virtual bool containsKey(const CacheableKeyPtr& keyPtr) const = 0;
+  virtual bool containsKey(const std::shared_ptr<CacheableKey>& keyPtr) const = 0;
   /**
    * The cache of the server, to which it is connected with, is searched
    * for the key to see if the key is present.
    * @throws UnsupportedOperationException if the region's scope is
    * ScopeType::LOCAL.
    */
-  virtual bool containsKeyOnServer(const CacheableKeyPtr& keyPtr) const = 0;
+  virtual bool containsKeyOnServer(const std::shared_ptr<CacheableKey>& keyPtr) const = 0;
   /**
    * Returns the list of keys on which this client is interested and will be
    * notified of changes.
    * @throws UnsupportedOperationException if the region's scope is
    * ScopeType::LOCAL.
    */
-  virtual VectorOfCacheableKey getInterestList() const = 0;
+  virtual std::vector<std::shared_ptr<CacheableKey>>  getInterestList() const = 0;
   /**
    * Returns the list of regular expresssions on which this client is
    * interested and will be notified of changes.
    * @throws UnsupportedOperationException if the region's scope is
    * ScopeType::LOCAL.
    */
-  virtual VectorOfCacheableString getInterestListRegex() const = 0;
+  virtual std::vector<std::shared_ptr<CacheableString>> getInterestListRegex() const = 0;
   /**
    * Convenience method allowing key to be a const char*
    * This operations checks for the key in the local cache .
@@ -1089,7 +1120,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws UnknownException For other exceptions.
    * @throws TimeoutException if operation timed out
    */
-  virtual void registerKeys(const VectorOfCacheableKey& keys,
+  virtual void registerKeys(const std::vector<std::shared_ptr<CacheableKey>> & keys,
                             bool isDurable = false,
                             bool getInitialValues = false,
                             bool receiveValues = true) = 0;
@@ -1119,7 +1150,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws UnknownException For other exceptions.
    * @throws TimeoutException if operation timed out
    */
-  virtual void unregisterKeys(const VectorOfCacheableKey& keys) = 0;
+  virtual void unregisterKeys(const std::vector<std::shared_ptr<CacheableKey>> & keys) = 0;
 
   /**
    * Registers to get updates for all keys from the server.
@@ -1300,8 +1331,8 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see get
    */
   virtual HashMapOfCacheable getAll(
-      const VectorOfCacheableKey& keys,
-      const SerializablePtr& aCallbackArgument = nullptr) = 0;
+      const std::vector<std::shared_ptr<CacheableKey>>& keys,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /**
    * Executes the query on the server based on the predicate.
@@ -1329,7 +1360,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @returns A smart pointer to the SelectResults which can either be a
    * ResultSet or a StructSet.
    */
-  virtual SelectResultsPtr query(
+  virtual std::shared_ptr<SelectResults> query(
       const char* predicate,
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
@@ -1379,7 +1410,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @returns A smart pointer to the single ResultSet or StructSet item, or
    * nullptr of no results are available.
    */
-  virtual SerializablePtr selectValue(
+  virtual std::shared_ptr<Serializable> selectValue(
       const char* predicate,
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
@@ -1410,8 +1441,9 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws UnknownException For other exceptions.
    * @see destroy
    */
-  virtual void removeAll(const VectorOfCacheableKey& keys,
-                         const SerializablePtr& aCallbackArgument = nullptr) = 0;
+  virtual void removeAll(
+      const std::vector<std::shared_ptr<CacheableKey>>& keys,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
 
   /**
    * Get the size of region. For native client regions, this will give the
@@ -1419,18 +1451,18 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    */
   virtual uint32_t size() = 0;
 
-  virtual const PoolPtr& getPool() = 0;
+  virtual const std::shared_ptr<Pool>& getPool() = 0;
 
-  inline CachePtr& getCache() { return m_cache; }
+  inline std::shared_ptr<Cache>& getCache() { return m_cache; }
 
   Region(const Region&) = delete;
   Region& operator=(const Region&) = delete;
 
  protected:
-  Region(const CachePtr& cache);
+  Region(const std::shared_ptr<Cache>& cache);
   virtual ~Region();
 
-  mutable CachePtr m_cache;
+  mutable std::shared_ptr<Cache> m_cache;
 
   FRIEND_STD_SHARED_PTR(Region)
 };
diff --git a/cppcache/include/geode/RegionAttributes.hpp b/cppcache/include/geode/RegionAttributes.hpp
index 18478dc1..b0b75007 100644
--- a/cppcache/include/geode/RegionAttributes.hpp
+++ b/cppcache/include/geode/RegionAttributes.hpp
@@ -83,21 +83,21 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
    * <code>CacheLoader</code> , nullptr if there is no CacheLoader for this
    * region.
    */
-  CacheLoaderPtr getCacheLoader();
+  std::shared_ptr<CacheLoader> getCacheLoader();
 
   /** Gets the cache writer for the region.
    * @return  a pointer that points to the region's ,
    * <code>CacheWriter</code> , nullptr if there is no CacheWriter for this
    * region
    */
-  CacheWriterPtr getCacheWriter();
+  std::shared_ptr<CacheWriter> getCacheWriter();
 
   /** Gets the cache listener for the region.
    * @return  a pointer that points to the region's ,
    * <code>CacheListener</code> , nullptr if there is no CacheListener defined
    * for this region.
    */
-  CacheListenerPtr getCacheListener();
+  std::shared_ptr<CacheListener> getCacheListener();
 
   /** Gets the partition resolver for the partition region.
    * @return  a pointer that points to the region's ,
@@ -105,7 +105,7 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
    * defined
    * for this region.
    */
-  PartitionResolverPtr getPartitionResolver();
+  std::shared_ptr<PartitionResolver> getPartitionResolver();
 
   /** Gets the <code>timeToLive</code> expiration attributes for the region as a
    * whole.
@@ -297,7 +297,7 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
   /**
    * This method returns the properties pointer which is set for persistence.
    */
-  PropertiesPtr getPersistenceProperties();
+  std::shared_ptr<Properties> getPersistenceProperties();
 
   /** Gets the persistence for the region.
    * @return  a pointer that points to the region's ,
@@ -305,7 +305,7 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
    * for this
    * region.
    */
-  PersistenceManagerPtr getPersistenceManager();
+  std::shared_ptr<PersistenceManager> getPersistenceManager();
 
   /** TODO
    * Returns the name of the {@link Pool} that this region
@@ -338,7 +338,7 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
   void setCacheWriter(const char* libpath, const char* factoryFuncName);
   void setPartitionResolver(const char* libpath, const char* factoryFuncName);
   void setPersistenceManager(const char* lib, const char* func,
-                             const PropertiesPtr& config);
+                             const std::shared_ptr<Properties>& config);
   void setEndpoints(const char* endpoints);
   void setPoolName(const char* poolName);
   void setCloningEnabled(bool isClonable);
@@ -365,10 +365,10 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
   ExpirationAction::Action m_entryTimeToLiveExpirationAction;
   ExpirationAction::Action m_entryIdleTimeoutExpirationAction;
   ExpirationAction::Action m_lruEvictionAction;
-  CacheWriterPtr m_cacheWriter;
-  CacheLoaderPtr m_cacheLoader;
-  CacheListenerPtr m_cacheListener;
-  PartitionResolverPtr m_partitionResolver;
+  std::shared_ptr<CacheWriter> m_cacheWriter;
+  std::shared_ptr<CacheLoader> m_cacheLoader;
+  std::shared_ptr<CacheListener> m_cacheListener;
+  std::shared_ptr<PartitionResolver> m_partitionResolver;
   uint32_t m_lruEntriesLimit;
   bool m_caching;
   uint32_t m_maxValueDistLimit;
@@ -392,8 +392,8 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
   bool m_clientNotificationEnabled;
   char* m_persistenceLibrary;
   char* m_persistenceFactory;
-  PropertiesPtr m_persistenceProperties;
-  PersistenceManagerPtr m_persistenceManager;
+  std::shared_ptr<Properties> m_persistenceProperties;
+  std::shared_ptr<PersistenceManager> m_persistenceManager;
   char* m_poolName;
   bool m_isClonable;
   bool m_isConcurrencyChecksEnabled;
diff --git a/cppcache/include/geode/RegionEntry.hpp b/cppcache/include/geode/RegionEntry.hpp
index 024ad265..85fdf6ef 100644
--- a/cppcache/include/geode/RegionEntry.hpp
+++ b/cppcache/include/geode/RegionEntry.hpp
@@ -34,7 +34,7 @@ namespace geode {
 namespace client {
 
 class RegionInternal;
-
+class Region;
 /**
  * @class RegionEntry RegionEntry.hpp
  * An object in a Region that represents an entry, i.e., a key-value pair.
@@ -54,20 +54,20 @@ class CPPCACHE_EXPORT RegionEntry {
    *
    * @return the key for this entry
    */
-  CacheableKeyPtr getKey();
+  std::shared_ptr<CacheableKey> getKey();
 
   /** Returns the value of this entry in the local cache. Does not invoke
    * a <code>CacheLoader</code>,
    *
    * @return the value or <code>nullptr</code> if this entry is invalid
    */
-  CacheablePtr getValue();
+  std::shared_ptr<Cacheable> getValue();
 
   /** Returns the region that contains this entry.
    *
    * @return the Region that contains this entry
    */
-  RegionPtr getRegion();
+  std::shared_ptr<Region> getRegion();
 
   /** Returns the statistics for this entry.
    *
@@ -75,7 +75,7 @@ class CPPCACHE_EXPORT RegionEntry {
    * @throws StatisticsDisabledException if statistics have been disabled for
    * this region
    */
-  CacheStatisticsPtr getStatistics();
+  std::shared_ptr<CacheStatistics> getStatistics();
 
   /**
    * Returns whether this entry has been destroyed.
@@ -95,12 +95,13 @@ class CPPCACHE_EXPORT RegionEntry {
     * @brief constructors
     * created by region
     */
-  RegionEntry(const RegionPtr& region, const CacheableKeyPtr& key,
-              const CacheablePtr& value);
-  RegionPtr m_region;
-  CacheableKeyPtr m_key;
-  CacheablePtr m_value;
-  CacheStatisticsPtr m_statistics;
+  RegionEntry(const std::shared_ptr<Region>& region,
+              const std::shared_ptr<CacheableKey>& key,
+              const std::shared_ptr<Cacheable>& value);
+  std::shared_ptr<Region> m_region;
+  std::shared_ptr<CacheableKey> m_key;
+  std::shared_ptr<Cacheable> m_value;
+  std::shared_ptr<CacheStatistics> m_statistics;
   bool m_destroyed;
   friend class RegionInternal;
 
diff --git a/cppcache/include/geode/RegionEvent.hpp b/cppcache/include/geode/RegionEvent.hpp
index 70013ee3..61524776 100644
--- a/cppcache/include/geode/RegionEvent.hpp
+++ b/cppcache/include/geode/RegionEvent.hpp
@@ -36,8 +36,8 @@ namespace client {
 
 class CPPCACHE_EXPORT RegionEvent {
  protected:
-  const RegionPtr m_region; /**< Region for this event. */
-  const SerializablePtr
+  const std::shared_ptr<Region> m_region; /**< Region for this event. */
+  const std::shared_ptr<Serializable>
       m_callbackArgument;    /**< Callback argument for this event, if any. */
   const bool m_remoteOrigin; /**< True if from a remote process. */
 
@@ -45,21 +45,24 @@ class CPPCACHE_EXPORT RegionEvent {
   /** Constructor. */
   RegionEvent();
   /** Constructor, given the values. */
-  RegionEvent(const RegionPtr& region, const SerializablePtr& aCallbackArgument,
+  RegionEvent(const std::shared_ptr<Region>& region,
+              const std::shared_ptr<Serializable>& aCallbackArgument,
               const bool remoteOrigin);
 
   /** Destructor. */
   ~RegionEvent();
 
   /** Return the region this event occurred in. */
-  inline RegionPtr getRegion() const { return m_region; }
+  inline std::shared_ptr<Region> getRegion() const { return m_region; }
 
   /**
    * Returns the callbackArgument passed to the method that generated
    * this event. See the {@link Region} interface methods that take
    * a callbackArgument parameter.
    */
-  inline SerializablePtr getCallbackArgument() const { return m_callbackArgument; }
+  inline std::shared_ptr<Serializable> getCallbackArgument() const {
+    return m_callbackArgument;
+  }
 
   /** If the event originated in a remote process, returns true. */
   inline bool remoteOrigin() const { return m_remoteOrigin; }
diff --git a/cppcache/include/geode/RegionFactory.hpp b/cppcache/include/geode/RegionFactory.hpp
index 405a8253..9fbd6967 100644
--- a/cppcache/include/geode/RegionFactory.hpp
+++ b/cppcache/include/geode/RegionFactory.hpp
@@ -50,32 +50,36 @@ class CPPCACHE_EXPORT RegionFactory {
    * this cache
    * @throws CacheClosedException if the cache is closed
    */
-  RegionPtr create(const char* name);
+  std::shared_ptr<Region> create(const char* name);
 
   /** Sets the cache loader for the next <code>RegionAttributes</code> created.
    * @param cacheLoader the cache loader or nullptr if no loader
    * @return a reference to <code>this</code>
    */
-  RegionFactory& setCacheLoader(const CacheLoaderPtr& cacheLoader);
+  RegionFactory& setCacheLoader(
+      const std::shared_ptr<CacheLoader>& cacheLoader);
 
   /** Sets the cache writer for the next <code>RegionAttributes</code> created.
    * @param cacheWriter the cache writer or nullptr if no cache writer
    * @return a reference to <code>this</code>
    */
-  RegionFactory& setCacheWriter(const CacheWriterPtr& cacheWriter);
+  RegionFactory& setCacheWriter(
+      const std::shared_ptr<CacheWriter>& cacheWriter);
 
   /** Sets the CacheListener for the next <code>RegionAttributes</code> created.
    * @param aListener a user defined CacheListener, nullptr if no listener
    * @return a reference to <code>this</code>
    */
-  RegionFactory& setCacheListener(const CacheListenerPtr& aListener);
+  RegionFactory& setCacheListener(
+      const std::shared_ptr<CacheListener>& aListener);
 
   /** Sets the PartitionResolver for the next <code>RegionAttributes</code>
    * created.
    * @param aResolver a user defined PartitionResolver, nullptr if no resolver
    * @return a reference to <code>this</code>
    */
-  RegionFactory& setPartitionResolver(const PartitionResolverPtr& aResolver);
+  RegionFactory& setPartitionResolver(
+      const std::shared_ptr<PartitionResolver>& aResolver);
 
   /**
    * Sets the library path for the library that will be invoked for the loader
@@ -156,9 +160,9 @@ class CPPCACHE_EXPORT RegionFactory {
    * this must be used to set the PersistenceManager.
    * @return a reference to <code>this</code>
    */
-  RegionFactory& setPersistenceManager(const char* libpath,
-                                       const char* factoryFuncName,
-                                       const PropertiesPtr& config = nullptr);
+  RegionFactory& setPersistenceManager(
+      const char* libpath, const char* factoryFuncName,
+      const std::shared_ptr<Properties>& config = nullptr);
 
   /** Sets the PersistenceManager for the next <code>RegionAttributes</code>
    * created.
@@ -167,8 +171,8 @@ class CPPCACHE_EXPORT RegionFactory {
    * @return a reference to <code>this</code>
    */
   RegionFactory& setPersistenceManager(
-      const PersistenceManagerPtr& persistenceManager,
-      const PropertiesPtr& config = nullptr);
+      const std::shared_ptr<PersistenceManager>& persistenceManager,
+      const std::shared_ptr<Properties>& config = nullptr);
 
   // MAP ATTRIBUTES
   /** Sets the entry initial capacity for the next <code>RegionAttributes</code>
@@ -261,7 +265,7 @@ class CPPCACHE_EXPORT RegionFactory {
 
   RegionShortcut m_preDefinedRegion;
 
-  AttributesFactoryPtr m_attributeFactory;
+  std::shared_ptr<AttributesFactory> m_attributeFactory;
 
   CacheImpl* m_cacheImpl;
 
diff --git a/cppcache/include/geode/RegionService.hpp b/cppcache/include/geode/RegionService.hpp
index 108b476c..17bfbd13 100644
--- a/cppcache/include/geode/RegionService.hpp
+++ b/cppcache/include/geode/RegionService.hpp
@@ -22,7 +22,7 @@
 
 #include "geode_globals.hpp"
 #include "geode_types.hpp"
-#include "VectorT.hpp"
+#include <vector>
 
 /**
  * @file
@@ -34,7 +34,7 @@ namespace client {
 
 class Region;
 class QueryService;
-
+class PdxInstanceFactory;
 /**
  * A RegionService provides access to existing {@link Region regions} that exist
  * in a {@link GeodeCache Geode cache}.
@@ -89,13 +89,13 @@ class CPPCACHE_EXPORT RegionService {
    * @param name the region's name, such as <code>root</code>.
    * @returns region, or nullptr if no such region exists.
    */
-  virtual RegionPtr getRegion(const char* name) = 0;
+  virtual std::shared_ptr<Region> getRegion(const char* name) = 0;
 
   /**
   * Gets the QueryService from which a new Query can be obtained.
   * @returns A smart pointer to the QueryService.
   */
-  virtual QueryServicePtr getQueryService() = 0;
+  virtual std::shared_ptr<QueryService> getQueryService() = 0;
 
   /**
    * Returns a set of root regions in the cache. This set is a snapshot and
@@ -105,7 +105,7 @@ class CPPCACHE_EXPORT RegionService {
    * @param regions the returned set of
    * regions
    */
-  virtual VectorOfRegion rootRegions() = 0;
+  virtual std::vector<std::shared_ptr<Region>> rootRegions() = 0;
 
   /**
   * Returns a factory that can create a {@link PdxInstance}.
@@ -114,7 +114,7 @@ class CPPCACHE_EXPORT RegionService {
   * when it is fully deserialized.
   * @return the factory
   */
-  virtual PdxInstanceFactoryPtr createPdxInstanceFactory(
+  virtual std::shared_ptr<PdxInstanceFactory> createPdxInstanceFactory(
       const char* className) = 0;
 };
 }  // namespace client
diff --git a/cppcache/include/geode/ResultCollector.hpp b/cppcache/include/geode/ResultCollector.hpp
index 7465b886..cb3c35b6 100644
--- a/cppcache/include/geode/ResultCollector.hpp
+++ b/cppcache/include/geode/ResultCollector.hpp
@@ -50,14 +50,14 @@ namespace client {
  *  Example:
  *  <br>
  *  <pre>
- *  ResultCollectorPtr rc = FunctionService::onRegion(region)
+ * auto rc = FunctionService::onRegion(region)
  *                                      ->withArgs(args)
  *                                      ->withFilter(keySet)
  *                                      ->withCollector(new
  * MyCustomResultCollector())
  *                                      .execute(Function);
  *  //Application can do something else here before retrieving the result
- *  CacheableVectorPtr functionResult = rc.getResult();
+ * auto functionResult = rc.getResult();
  * </pre>
  *
  * @see FunctionService
@@ -84,7 +84,7 @@ class CPPCACHE_EXPORT ResultCollector {
    * @throws FunctionException if result retrieval fails
    * @see UserFunctionExecutionException
    */
-  virtual CacheableVectorPtr getResult(
+  virtual std::shared_ptr<CacheableVector> getResult(
       std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
   /**
@@ -93,7 +93,8 @@ class CPPCACHE_EXPORT ResultCollector {
    * @param resultOfSingleExecution
    * @since 5.8LA
    */
-  virtual void addResult(const CacheablePtr& resultOfSingleExecution) = 0;
+  virtual void addResult(
+      const std::shared_ptr<Cacheable>& resultOfSingleExecution) = 0;
 
   /**
    * Geode will invoke this method when function execution has completed
diff --git a/cppcache/include/geode/ResultSet.hpp b/cppcache/include/geode/ResultSet.hpp
index 30f0dea2..8048b238 100644
--- a/cppcache/include/geode/ResultSet.hpp
+++ b/cppcache/include/geode/ResultSet.hpp
@@ -25,7 +25,6 @@
 #include "ExceptionTypes.hpp"
 
 #include "SelectResults.hpp"
-#include "VectorT.hpp"
 
 #include "SelectResultsIterator.hpp"
 
@@ -65,7 +64,7 @@ class CPPCACHE_EXPORT ResultSet : public SelectResults {
    * @throws IllegalArgumentException if the index is out of bounds.
    * @returns A smart pointer to the item indexed.
    */
-  virtual const SerializablePtr operator[](int32_t index) const = 0;
+  virtual const std::shared_ptr<Serializable> operator[](int32_t index) const = 0;
 
   /**
    * Get a SelectResultsIterator with which to iterate over the items in the
diff --git a/cppcache/include/geode/SelectResults.hpp b/cppcache/include/geode/SelectResults.hpp
index 82405f2d..ee754040 100644
--- a/cppcache/include/geode/SelectResults.hpp
+++ b/cppcache/include/geode/SelectResults.hpp
@@ -64,7 +64,8 @@ class CPPCACHE_EXPORT SelectResults {
    * @throws IllegalArgumentException if the index is out of bounds.
    * @returns A smart pointer to the item indexed.
    */
-  virtual const SerializablePtr operator[](int32_t index) const = 0;
+  virtual const std::shared_ptr<Serializable> operator[](
+      int32_t index) const = 0;
 
   /**
    * Get a SelectResultsIterator with which to iterate over the items in the
diff --git a/cppcache/include/geode/SelectResultsIterator.hpp b/cppcache/include/geode/SelectResultsIterator.hpp
index 4a1b2707..a24a531a 100644
--- a/cppcache/include/geode/SelectResultsIterator.hpp
+++ b/cppcache/include/geode/SelectResultsIterator.hpp
@@ -59,7 +59,7 @@ class CPPCACHE_EXPORT SelectResultsIterator {
    * @returns a smart pointer to the next item from the iterator or nullptr if
    * no further items are available.
    */
-  const SerializablePtr next();
+  const std::shared_ptr<Serializable> next();
 
   /**
    * Move the iterator to point to the next item to get.
@@ -74,7 +74,7 @@ class CPPCACHE_EXPORT SelectResultsIterator {
    * @returns A smart pointer to the current item pointed to by the
    * SelectResultsIterator.
    */
-  const SerializablePtr current() const;
+  const std::shared_ptr<Serializable> current() const;
 
   /**
    * Reset the SelectResultsIterator to point to the start of the items.
@@ -85,14 +85,14 @@ class CPPCACHE_EXPORT SelectResultsIterator {
   /**
    * Constructor - meant only for internal use.
    */
-  SelectResultsIterator(const CacheableVectorPtr& vectorSR,
-                        SelectResultsPtr srp);
+  SelectResultsIterator(const std::shared_ptr<CacheableVector>& vectorSR,
+                        std::shared_ptr<SelectResults> srp);
 
-  CacheableVectorPtr m_vectorSR;
+  std::shared_ptr<CacheableVector> m_vectorSR;
   int32_t m_nextIndex;
   // this is to ensure that a reference of SelectResults is kept alive
   // if an iterator object is present
-  SelectResultsPtr m_srp;
+  std::shared_ptr<SelectResults> m_srp;
 
   friend class ResultSetImpl;
   friend class StructSetImpl;
diff --git a/cppcache/include/geode/Serializable.hpp b/cppcache/include/geode/Serializable.hpp
index 751b4d78..c156349d 100644
--- a/cppcache/include/geode/Serializable.hpp
+++ b/cppcache/include/geode/Serializable.hpp
@@ -34,7 +34,10 @@ namespace client {
 
 class DataOutput;
 class DataInput;
-
+class Cache;
+class PdxSerializable;
+class Serializable;
+class CacheableString;
 typedef void (*CliCallbackMethod)(Cache &cache);
 
 /** @brief signature of functions passed to registerType. Such functions
@@ -109,7 +112,7 @@ class CPPCACHE_EXPORT Serializable
    * the subclasses.
    * The default implementation renders the classname.
    */
-  virtual CacheableStringPtr toString() const;
+  virtual std::shared_ptr<CacheableString> toString() const;
 
   /** Factory method that creates the Serializable object that matches the type
    * of value.
@@ -119,7 +122,7 @@ class CPPCACHE_EXPORT Serializable
    * apache::geode::client::createValueArr may be overloaded.
    */
   template <class PRIM>
-  inline static SerializablePtr create(const PRIM value);
+  inline static std::shared_ptr<Serializable> create(const PRIM value);
 
   /**
    * @brief destructor
diff --git a/cppcache/include/geode/Serializer.hpp b/cppcache/include/geode/Serializer.hpp
index 29e955f2..c4a9176d 100644
--- a/cppcache/include/geode/Serializer.hpp
+++ b/cppcache/include/geode/Serializer.hpp
@@ -29,7 +29,6 @@
 #include "geode_globals.hpp"
 #include "DataOutput.hpp"
 #include "DataInput.hpp"
-#include "VectorT.hpp"
 #include "HashMapT.hpp"
 #include "HashSetT.hpp"
 #include "GeodeTypeIds.hpp"
@@ -303,14 +302,14 @@ inline void writeObject(apache::geode::client::DataOutput& output,
   }
 }
 
-inline uint32_t objectSize(const VectorOfCacheable& value) {
+inline uint32_t objectSize(const std::vector<std::shared_ptr<Cacheable>>& value) {
   size_t objectSize = 0;
   for (const auto& iter : value) {
     if (iter) {
       objectSize += iter->objectSize();
     }
   }
-  objectSize += sizeof(CacheablePtr) * value.size();
+  objectSize += sizeof(std::shared_ptr<Cacheable>) * value.size();
   return static_cast<uint32_t>(objectSize);
 }
 
@@ -347,7 +346,7 @@ inline uint32_t objectSize(const HashMapOfCacheable& value) {
     }
   }
   objectSize += static_cast<uint32_t>(
-      (sizeof(CacheableKeyPtr) + sizeof(CacheablePtr)) * value.size());
+      (sizeof(std::shared_ptr<CacheableKey>) + sizeof(std::shared_ptr<Cacheable>)) * value.size());
   return objectSize;
 }
 
@@ -381,7 +380,7 @@ inline uint32_t objectSize(const HashSetOfCacheableKey& value) {
       objectSize += iter->objectSize();
     }
   }
-  objectSize += static_cast<uint32_t>(sizeof(CacheableKeyPtr) * value.size());
+  objectSize += static_cast<uint32_t>(sizeof(std::shared_ptr<CacheableKey>) * value.size());
   return objectSize;
 }
 
diff --git a/cppcache/include/geode/Struct.hpp b/cppcache/include/geode/Struct.hpp
index cea08c38..a98c3a19 100644
--- a/cppcache/include/geode/Struct.hpp
+++ b/cppcache/include/geode/Struct.hpp
@@ -51,7 +51,8 @@ class CPPCACHE_EXPORT Struct : public Serializable {
   /**
    * Constructor - meant only for internal use.
    */
-  Struct(StructSet* ssPtr, std::vector<SerializablePtr>& fieldValues);
+  Struct(StructSet* ssPtr,
+         std::vector<std::shared_ptr<Serializable>>& fieldValues);
 
   /**
    * Factory function for registration of <code>Struct</code>.
@@ -65,7 +66,7 @@ class CPPCACHE_EXPORT Struct : public Serializable {
    * @returns A smart pointer to the field value or nullptr if index out of
    * bounds.
    */
-  const SerializablePtr operator[](int32_t index) const;
+  const std::shared_ptr<Serializable> operator[](int32_t index) const;
 
   /**
    * Get the field value for the given field name.
@@ -74,14 +75,15 @@ class CPPCACHE_EXPORT Struct : public Serializable {
    * @returns A smart pointer to the field value.
    * @throws IllegalArgumentException if the field name is not found.
    */
-  const SerializablePtr operator[](const std::string& fieldName) const;
+  const std::shared_ptr<Serializable> operator[](
+      const std::string& fieldName) const;
 
   /**
    * Get the parent StructSet of this Struct.
    *
    * @returns A smart pointer to the parent StructSet of this Struct.
    */
-  const StructSetPtr getStructSet() const;
+  const std::shared_ptr<StructSet> getStructSet() const;
 
   /**
    * Check whether another field value is available to iterate over in this
@@ -104,7 +106,7 @@ class CPPCACHE_EXPORT Struct : public Serializable {
    * @returns A smart pointer to the next item in the Struct or nullptr if no
    * more available.
    */
-  const SerializablePtr next();
+  const std::shared_ptr<Serializable> next();
 
   /**
    * Deserializes the Struct object from the DataInput. @TODO KN: better comment
@@ -153,7 +155,7 @@ class CPPCACHE_EXPORT Struct : public Serializable {
 
   typedef std::unordered_map<std::string, int32_t> FieldNames;
   FieldNames m_fieldNames;
-  std::vector<SerializablePtr> m_fieldValues;
+  std::vector<std::shared_ptr<Serializable>> m_fieldValues;
 
   StructSet* m_parent;
 
diff --git a/cppcache/include/geode/StructSet.hpp b/cppcache/include/geode/StructSet.hpp
index 116add74..143a8526 100644
--- a/cppcache/include/geode/StructSet.hpp
+++ b/cppcache/include/geode/StructSet.hpp
@@ -65,7 +65,8 @@ class CPPCACHE_EXPORT StructSet : public CqResults {
    * @throws IllegalArgumentException if the index is out of bounds.
    * @returns A smart pointer to the item indexed.
    */
-  virtual const SerializablePtr operator[](int32_t index) const = 0;
+  virtual const std::shared_ptr<Serializable> operator[](
+      int32_t index) const = 0;
 
   /**
    * Get the index number of the specified field name in the StructSet.
diff --git a/cppcache/include/geode/SystemProperties.hpp b/cppcache/include/geode/SystemProperties.hpp
index 93720339..8262cd75 100644
--- a/cppcache/include/geode/SystemProperties.hpp
+++ b/cppcache/include/geode/SystemProperties.hpp
@@ -52,7 +52,7 @@ class CPPCACHE_EXPORT SystemProperties {
    * If useMemType is true, use the given member type; if false, always set
    * member type to SERVER.
    */
-  SystemProperties(const PropertiesPtr& propertiesPtr,
+  SystemProperties(const std::shared_ptr<Properties>& propertiesPtr,
                    const char* configFile = nullptr);
 
   /**
@@ -312,9 +312,9 @@ class CPPCACHE_EXPORT SystemProperties {
   }
 
   /** Returns securityPropertiesPtr.
-   * @return  PropertiesPtr value.
+   * @return  std::shared_ptr<Properties> value.
    */
-  PropertiesPtr getSecurityProperties() const {
+  std::shared_ptr<Properties> getSecurityProperties() const {
     return m_securityPropertiesPtr;
   }
 
@@ -426,10 +426,10 @@ class CPPCACHE_EXPORT SystemProperties {
   std::chrono::milliseconds m_notifyAckInterval;
   std::chrono::milliseconds m_notifyDupCheckLife;
 
-  PropertiesPtr m_securityPropertiesPtr;
+  std::shared_ptr<Properties> m_securityPropertiesPtr;
 
-  CacheableStringPtr m_securityClientDhAlgo;
-  CacheableStringPtr m_securityClientKsPath;
+  std::shared_ptr<CacheableString> m_securityClientDhAlgo;
+  std::shared_ptr<CacheableString> m_securityClientKsPath;
 
   char* m_durableClientId;
   std::chrono::seconds m_durableTimeout;
diff --git a/cppcache/include/geode/TypeRegistry.hpp b/cppcache/include/geode/TypeRegistry.hpp
index 1229dafa..7b65fe6e 100644
--- a/cppcache/include/geode/TypeRegistry.hpp
+++ b/cppcache/include/geode/TypeRegistry.hpp
@@ -27,6 +27,7 @@
 namespace apache {
 namespace geode {
 namespace client {
+class PdxSerializer;
 
 class TypeRegistry {
  public:
@@ -55,7 +56,7 @@ class TypeRegistry {
    * user domain classes.
    * @see PdxSerializer
    */
-  void registerPdxSerializer(PdxSerializerPtr pdxSerializer);
+  void registerPdxSerializer(std::shared_ptr<PdxSerializer> pdxSerializer);
 
  protected:
  private:
diff --git a/cppcache/include/geode/UserFunctionExecutionException.hpp b/cppcache/include/geode/UserFunctionExecutionException.hpp
index 0d0efb62..ad748588 100644
--- a/cppcache/include/geode/UserFunctionExecutionException.hpp
+++ b/cppcache/include/geode/UserFunctionExecutionException.hpp
@@ -28,8 +28,6 @@ namespace geode {
 namespace client {
 
 class UserFunctionExecutionException;
-typedef std::shared_ptr<UserFunctionExecutionException>
-    UserFunctionExecutionExceptionPtr;
 
 /**
  * @brief UserFunctionExecutionException class is used to encapsulate geode
@@ -49,7 +47,7 @@ class UserFunctionExecutionException : public Serializable {
   /**
    * @brief constructors
    */
-  UserFunctionExecutionException(CacheableStringPtr msg);
+  UserFunctionExecutionException(std::shared_ptr<CacheableString> msg);
 
   /**
    *@brief serialize this object
@@ -97,18 +95,18 @@ class UserFunctionExecutionException : public Serializable {
   virtual int8_t typeId() const;
 
   /**
-   *@brief return as CacheableStringPtr the Exception message returned from
-   *geode sendException api.
+   *@brief return as std::shared_ptr<CacheableString> the Exception message
+   *returned from geode sendException api.
    **/
-  CacheableStringPtr getMessage() { return m_message; }
+  std::shared_ptr<CacheableString> getMessage() { return m_message; }
 
   /**
-   *@brief return as CacheableStringPtr the Exception name returned from geode
-   *sendException api.
+   *@brief return as std::shared_ptr<CacheableString> the Exception name
+   *returned from geode sendException api.
    **/
-  CacheableStringPtr getName() {
+  std::shared_ptr<CacheableString> getName() {
     const char* msg = "UserFunctionExecutionException";
-    CacheableStringPtr str = CacheableString::create(msg);
+    auto str = CacheableString::create(msg);
     return str;
   }
 
@@ -117,7 +115,7 @@ class UserFunctionExecutionException : public Serializable {
   UserFunctionExecutionException(const UserFunctionExecutionException& other);
   void operator=(const UserFunctionExecutionException& other);
 
-  CacheableStringPtr m_message;  // error message
+  std::shared_ptr<CacheableString> m_message;  // error message
 };
 
 }  // namespace client
diff --git a/cppcache/include/geode/VectorT.hpp b/cppcache/include/geode/VectorT.hpp
deleted file mode 100644
index d3225a58..00000000
--- a/cppcache/include/geode/VectorT.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#ifndef GEODE_VECTORT_H_
-#define GEODE_VECTORT_H_
-
-#include <vector>
-#include <memory>
-
-#include "geode_globals.hpp"
-#include "Cacheable.hpp"
-#include "CacheableKey.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-
-// TODO move to more appropriate location
-typedef std::vector<RegionEntryPtr> VectorOfRegionEntry;
-typedef std::vector<RegionPtr> VectorOfRegion;
-typedef std::vector<CacheablePtr> VectorOfCacheable;
-typedef std::shared_ptr<VectorOfCacheable> VectorOfCacheablePtr;
-typedef std::vector<CacheableKeyPtr> VectorOfCacheableKey;
-typedef std::shared_ptr<VectorOfCacheableKey> VectorOfCacheableKeyPtr;
-typedef std::vector<CacheableStringPtr> VectorOfCacheableString;
-
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif  // GEODE_VECTORT_H_
diff --git a/cppcache/include/geode/WritablePdxInstance.hpp b/cppcache/include/geode/WritablePdxInstance.hpp
index d4ea0db5..ec075de9 100644
--- a/cppcache/include/geode/WritablePdxInstance.hpp
+++ b/cppcache/include/geode/WritablePdxInstance.hpp
@@ -28,7 +28,7 @@
 namespace apache {
 namespace geode {
 namespace client {
-
+class CacheableObjectArray;
 /**
  * WritablePdxInstance is a {@link PdxInstance} that also supports field
  * modification
@@ -51,15 +51,17 @@ class CPPCACHE_EXPORT WritablePdxInstance : public PdxInstance {
    * The setField method has copy-on-write semantics.
    * So for the modifications to be stored in the cache the WritablePdxInstance
    * must be put into a region after setField has been called one or more times.
-   * CacheablePtr type is corresponding to java object type.
+   * std::shared_ptr<Cacheable> type is corresponding to java object type.
    * @param fieldName
    *          name of the field whose value will be set
    * @param value
-   *          value that will be set to the field of type CacheablePtr
+   *          value that will be set to the field of type
+   * std::shared_ptr<Cacheable>
    * @throws IllegalStateException if the named field does not exist
    * or if the type of the value is not compatible with the field.
    */
-  virtual void setField(const char* fieldName, CacheablePtr value) = 0;
+  virtual void setField(const char* fieldName,
+                        std::shared_ptr<Cacheable> value) = 0;
 
   /**
    * Set the existing named field to the given value.
@@ -209,15 +211,18 @@ class CPPCACHE_EXPORT WritablePdxInstance : public PdxInstance {
    * The setField method has copy-on-write semantics.
    * So for the modifications to be stored in the cache the WritablePdxInstance
    * must be put into a region after setField has been called one or more times.
-   * CacheableDatePtr type is corresponding to java Java.util.date type.
+   * std::shared_ptr<CacheableDate> type is corresponding to java Java.util.date
+   * type.
    * @param fieldName
    *          name of the field whose value will be set
    * @param value
-   *          value that will be set to the field of type CacheableDatePtr
+   *          value that will be set to the field of type
+   * std::shared_ptr<CacheableDate>
    * @throws IllegalStateException if the named field does not exist
    * or if the type of the value is not compatible with the field.
    */
-  virtual void setField(const char* fieldName, CacheableDatePtr value) = 0;
+  virtual void setField(const char* fieldName,
+                        std::shared_ptr<CacheableDate> value) = 0;
 
   /**
    * Set the existing named field to the given value.
@@ -496,17 +501,18 @@ class CPPCACHE_EXPORT WritablePdxInstance : public PdxInstance {
    * The setField method has copy-on-write semantics.
    * So for the modifications to be stored in the cache the WritablePdxInstance
    * must be put into a region after setField has been called one or more times.
-   * CacheableObjectArrayPtr type is corresponding to java Object[] type.
+   * std::shared_ptr<CacheableObjectArray> type is corresponding to java
+   * Object[] type.
    * @param fieldName
    *          name of the field whose value will be set
    * @param value
    *          value that will be set to the field of type
-   * CacheableObjectArrayPtr
+   * std::shared_ptr<CacheableObjectArray>
    * @throws IllegalStateException if the named field does not exist
    * or if the type of the value is not compatible with the field.
    */
   virtual void setField(const char* fieldName,
-                        CacheableObjectArrayPtr value) = 0;
+                        std::shared_ptr<CacheableObjectArray> value) = 0;
 
  protected:
   /**
diff --git a/cppcache/include/geode/geode_types.hpp b/cppcache/include/geode/geode_types.hpp
index 882893a3..224686d5 100644
--- a/cppcache/include/geode/geode_types.hpp
+++ b/cppcache/include/geode/geode_types.hpp
@@ -32,79 +32,7 @@ namespace apache {
 namespace geode {
 namespace client {
 
-class CacheFactory;
 
-#define _GF_PTR_DEF_(a, b) \
-  class CPPCACHE_EXPORT a; \
-  typedef std::shared_ptr<a> b;
-
-_GF_PTR_DEF_(CacheFactory, CacheFactoryPtr);
-_GF_PTR_DEF_(RegionService, RegionServicePtr);
-_GF_PTR_DEF_(GeodeCache, GeodeCachePtr);
-_GF_PTR_DEF_(Cache, CachePtr);
-_GF_PTR_DEF_(RegionFactory, RegionFactoryPtr);
-_GF_PTR_DEF_(AttributesFactory, AttributesFactoryPtr);
-_GF_PTR_DEF_(Region, RegionPtr);
-_GF_PTR_DEF_(AttributesMutator, AttributesMutatorPtr);
-_GF_PTR_DEF_(MapEntry, MapEntryPtr);
-_GF_PTR_DEF_(RegionEntry, RegionEntryPtr);
-_GF_PTR_DEF_(EventId, EventIdPtr);
-_GF_PTR_DEF_(CacheStatistics, CacheStatisticsPtr);
-_GF_PTR_DEF_(PersistenceManager, PersistenceManagerPtr);
-_GF_PTR_DEF_(Properties, PropertiesPtr);
-_GF_PTR_DEF_(FunctionService, FunctionServicePtr);
-_GF_PTR_DEF_(CacheLoader, CacheLoaderPtr);
-_GF_PTR_DEF_(CacheListener, CacheListenerPtr);
-_GF_PTR_DEF_(CacheWriter, CacheWriterPtr);
-_GF_PTR_DEF_(MembershipListener, MembershipListenerPtr);
-_GF_PTR_DEF_(RegionAttributes, RegionAttributesPtr);
-_GF_PTR_DEF_(CacheableDate, CacheableDatePtr);
-_GF_PTR_DEF_(CacheableFileName, CacheableFileNamePtr);
-_GF_PTR_DEF_(CacheableKey, CacheableKeyPtr);
-_GF_PTR_DEF_(CacheableObjectArray, CacheableObjectArrayPtr);
-_GF_PTR_DEF_(CacheableString, CacheableStringPtr);
-_GF_PTR_DEF_(CacheableUndefined, CacheableUndefinedPtr);
-_GF_PTR_DEF_(Serializable, SerializablePtr);
-_GF_PTR_DEF_(PdxSerializable, PdxSerializablePtr);
-_GF_PTR_DEF_(StackTrace, StackTracePtr);
-_GF_PTR_DEF_(SelectResults, SelectResultsPtr);
-_GF_PTR_DEF_(CqResults, CqResultsPtr);
-_GF_PTR_DEF_(ResultSet, ResultSetPtr);
-_GF_PTR_DEF_(StructSet, StructSetPtr);
-_GF_PTR_DEF_(Struct, StructPtr);
-_GF_PTR_DEF_(Query, QueryPtr);
-_GF_PTR_DEF_(QueryService, QueryServicePtr);
-_GF_PTR_DEF_(AuthInitialize, AuthInitializePtr);
-_GF_PTR_DEF_(CqQuery, CqQueryPtr);
-_GF_PTR_DEF_(CqListener, CqListenerPtr);
-_GF_PTR_DEF_(CqAttributes, CqAttributesPtr);
-_GF_PTR_DEF_(CqServiceStatistics, CqServiceStatisticsPtr);
-_GF_PTR_DEF_(CqStatistics, CqStatisticsPtr);
-_GF_PTR_DEF_(CqAttributesMutator, CqAttributesMutatorPtr);
-_GF_PTR_DEF_(ClientHealthStats, ClientHealthStatsPtr);
-_GF_PTR_DEF_(Pool, PoolPtr);
-_GF_PTR_DEF_(PoolFactory, PoolFactoryPtr);
-_GF_PTR_DEF_(PoolAttributes, PoolAttributesPtr);
-_GF_PTR_DEF_(ResultCollector, ResultCollectorPtr);
-_GF_PTR_DEF_(Execution, ExecutionPtr);
-_GF_PTR_DEF_(Delta, DeltaPtr);
-_GF_PTR_DEF_(PartitionResolver, PartitionResolverPtr);
-_GF_PTR_DEF_(FixedPartitionResolver, FixedPartitionResolverPtr);
-_GF_PTR_DEF_(CacheTransactionManager, CacheTransactionManagerPtr);
-_GF_PTR_DEF_(TransactionId, TransactionIdPtr);
-_GF_PTR_DEF_(EntryEvent, EntryEventPtr);
-_GF_PTR_DEF_(PdxReader, PdxReaderPtr);
-_GF_PTR_DEF_(PdxWriter, PdxWriterPtr);
-_GF_PTR_DEF_(PdxWrapper, PdxWrapperPtr);
-_GF_PTR_DEF_(PdxSerializer, PdxSerializerPtr);
-_GF_PTR_DEF_(PdxInstanceFactory, PdxInstanceFactoryPtr);
-_GF_PTR_DEF_(PdxInstance, PdxInstancePtr);
-_GF_PTR_DEF_(WritablePdxInstance, WritablePdxInstancePtr);
-_GF_PTR_DEF_(PdxUnreadFields, PdxUnreadFieldsPtr);
-_GF_PTR_DEF_(CacheableEnum, CacheableEnumPtr);
-_GF_PTR_DEF_(CqStatusListener, CqStatusListenerPtr);
-_GF_PTR_DEF_(InternalCacheTransactionManager2PC,
-             InternalCacheTransactionManager2PCPtr);
 }  // namespace client
 }  // namespace geode
 }  // namespace apache
diff --git a/cppcache/integration-test/BuiltinCacheableWrappers.hpp b/cppcache/integration-test/BuiltinCacheableWrappers.hpp
index ed2f58bb..c1332ee2 100644
--- a/cppcache/integration-test/BuiltinCacheableWrappers.hpp
+++ b/cppcache/integration-test/BuiltinCacheableWrappers.hpp
@@ -25,10 +25,16 @@
 #include <wchar.h>
 
 #include <ace/Date_Time.h>
+
 #include "CacheHelper.hpp"
 #include "CacheRegionHelper.hpp"
 #include "CacheableWrapper.hpp"
 #include "CacheImpl.hpp"
+
+#include <geode/CacheableFileName.hpp>
+#include <geode/CacheableUndefined.hpp>
+#include <geode/CacheableObjectArray.hpp>
+
 using namespace apache::geode::client;
 
 namespace CacheableHelper {
@@ -201,7 +207,7 @@ class CacheableBooleanWrapper : public CacheableWrapper {
         CacheableHelper::random<uint8_t>(UCHAR_MAX) % 2);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableBoolean* obj =
         dynamic_cast<const CacheableBoolean*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -230,7 +236,7 @@ class CacheableByteWrapper : public CacheableWrapper {
         CacheableByte::create(CacheableHelper::random<uint8_t>(UCHAR_MAX));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableByte* obj = dynamic_cast<const CacheableByte*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
     return CacheableHelper::crc32<uint8_t>(obj->value());
@@ -258,7 +264,7 @@ class CacheableDoubleWrapper : public CacheableWrapper {
         CacheableHelper::random(static_cast<double>(maxSize)));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableDouble* obj =
         dynamic_cast<const CacheableDouble*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -295,7 +301,7 @@ class CacheableDateWrapper : public CacheableWrapper {
     m_cacheableObject = CacheableDate::create(epoctime);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableDate* obj = dynamic_cast<const CacheableDate*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
     return CacheableHelper::crc32<int64_t>(obj->milliseconds());
@@ -347,7 +353,7 @@ class CacheableFileNameWrapper : public CacheableWrapper {
         randStr.data(), static_cast<int32_t>(randStr.size()));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableFileName* obj =
         dynamic_cast<const CacheableFileName*>(object.get());
     return (obj != nullptr
@@ -377,7 +383,7 @@ class CacheableFloatWrapper : public CacheableWrapper {
         CacheableHelper::random(static_cast<float>(maxSize)));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableFloat* obj =
         dynamic_cast<const CacheableFloat*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -406,7 +412,7 @@ class CacheableInt16Wrapper : public CacheableWrapper {
         CacheableInt16::create(CacheableHelper::random<int16_t>(SHRT_MAX));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableInt16* obj =
         dynamic_cast<const CacheableInt16*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -435,7 +441,7 @@ class CacheableInt32Wrapper : public CacheableWrapper {
         CacheableInt32::create(CacheableHelper::random<int32_t>(INT_MAX));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableInt32* obj =
         dynamic_cast<const CacheableInt32*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -465,7 +471,7 @@ class CacheableInt64Wrapper : public CacheableWrapper {
     m_cacheableObject = CacheableInt64::create(rnd);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableInt64* obj =
         dynamic_cast<const CacheableInt64*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -506,7 +512,7 @@ class CacheableStringWrapper : public CacheableWrapper {
         randStr.data(), static_cast<int32_t>(randStr.length()));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableString* obj =
         dynamic_cast<const CacheableString*>(object.get());
     return (obj != nullptr
@@ -551,7 +557,7 @@ class CacheableHugeStringWrapper : public CacheableWrapper {
         randStr.data(), static_cast<int32_t>(randStr.length()));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableString* obj =
         dynamic_cast<const CacheableString*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -597,7 +603,7 @@ class CacheableHugeUnicodeStringWrapper : public CacheableWrapper {
         randStr.data(), static_cast<int32_t>(randStr.length()));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableString* obj =
         dynamic_cast<const CacheableString*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -641,7 +647,7 @@ class CacheableUnicodeStringWrapper : public CacheableWrapper {
         randStr.data(), static_cast<int32_t>(randStr.length()));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableString* obj =
         dynamic_cast<const CacheableString*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -671,7 +677,7 @@ class CacheableWideCharWrapper : public CacheableWrapper {
         CacheableCharacter::create(CacheableHelper::random<char16_t>(SHRT_MAX));
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     auto obj = std::dynamic_pointer_cast<const CacheableCharacter>(object);
     ASSERT(obj != nullptr, "getCheckSum: null object.");
     return CacheableHelper::crc32<char16_t>(obj->value());
@@ -697,10 +703,8 @@ class CacheableHashMapTypeWrapper : public CacheableWrapper {
     m_cacheableObject = HMAPTYPE::create(maxSize);
     HMAPTYPE* chmp = dynamic_cast<HMAPTYPE*>(m_cacheableObject.get());
     ASSERT(chmp != nullptr, "initRandomValue: null object.");
-    std::vector<int8_t> keyTypeIds =
-        CacheableWrapperFactory::getRegisteredKeyTypes();
-    std::vector<int8_t> valTypeIds =
-        CacheableWrapperFactory::getRegisteredValueTypes();
+    auto keyTypeIds = CacheableWrapperFactory::getRegisteredKeyTypes();
+    auto valTypeIds = CacheableWrapperFactory::getRegisteredValueTypes();
 
     for (std::vector<int8_t>::iterator keyIter = keyTypeIds.begin();
          keyIter != keyTypeIds.end(); keyIter++) {
@@ -746,7 +750,7 @@ class CacheableHashMapTypeWrapper : public CacheableWrapper {
     }
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const HMAPTYPE* obj = dynamic_cast<const HMAPTYPE*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
     uint32_t chksum = 0;
@@ -792,8 +796,7 @@ class CacheableHashSetTypeWrapper : public CacheableWrapper {
   virtual void initRandomValue(int32_t maxSize) {
     Serializable* ser = HSETTYPE::createDeserializable();
     HSETTYPE* set = (HSETTYPE*)ser;
-    std::vector<int8_t> keyTypeIds =
-        CacheableWrapperFactory::getRegisteredKeyTypes();
+    auto keyTypeIds = CacheableWrapperFactory::getRegisteredKeyTypes();
     size_t sizeOfTheVector = keyTypeIds.size();
     maxSize = maxSize / static_cast<int32_t>(sizeOfTheVector) + 1;
     for (size_t i = 0; i < sizeOfTheVector; i++) {
@@ -801,7 +804,7 @@ class CacheableHashSetTypeWrapper : public CacheableWrapper {
       CacheableWrapper* wrapper =
           CacheableWrapperFactory::createInstance(keyTypeId);
       wrapper->initRandomValue(maxSize);
-      CacheablePtr cptr = wrapper->getCacheable();
+      auto cptr = wrapper->getCacheable();
       set->insert(
           std::dynamic_pointer_cast<CacheableKey>(wrapper->getCacheable()));
       delete wrapper;
@@ -809,7 +812,7 @@ class CacheableHashSetTypeWrapper : public CacheableWrapper {
     m_cacheableObject = std::shared_ptr<Serializable>(set);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const HSETTYPE* obj = dynamic_cast<const HSETTYPE*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
     uint32_t checkSum = 0;
@@ -846,7 +849,7 @@ class CacheableBytesWrapper : public CacheableWrapper {
     delete[] randArr;
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableBytes* obj =
         dynamic_cast<const CacheableBytes*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -874,7 +877,7 @@ class CacheableDoubleArrayWrapper : public CacheableWrapper {
     delete[] randArr;
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableDoubleArray* obj =
         dynamic_cast<const CacheableDoubleArray*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -900,7 +903,7 @@ class CacheableFloatArrayWrapper : public CacheableWrapper {
     delete[] randArr;
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableFloatArray* obj =
         dynamic_cast<const CacheableFloatArray*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -925,7 +928,7 @@ class CacheableInt16ArrayWrapper : public CacheableWrapper {
     delete[] randArr;
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableInt16Array* obj =
         dynamic_cast<const CacheableInt16Array*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -950,7 +953,7 @@ class CacheableInt32ArrayWrapper : public CacheableWrapper {
     delete[] randArr;
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableInt32Array* obj =
         dynamic_cast<const CacheableInt32Array*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -975,7 +978,7 @@ class CacheableInt64ArrayWrapper : public CacheableWrapper {
     delete[] randArr;
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableInt64Array* obj =
         dynamic_cast<const CacheableInt64Array*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
@@ -997,7 +1000,7 @@ class CacheableNullStringWrapper : public CacheableWrapper {
     m_cacheableObject = CacheableString::create((char*)nullptr);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     ASSERT(object == nullptr, "getCheckSum: expected null object");
     return 0;
   }
@@ -1022,7 +1025,8 @@ class CacheableStringArrayWrapper : public CacheableWrapper {
       maxSize = 2;
     }
 
-    CacheableStringPtr* randArr = new CacheableStringPtr[arraySize];
+    std::shared_ptr<CacheableString>* randArr =
+        new std::shared_ptr<CacheableString>[arraySize];
     for (int32_t arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) {
       if (arrayIndex % 2 == 0) {
         std::string randStr;
@@ -1039,12 +1043,12 @@ class CacheableStringArrayWrapper : public CacheableWrapper {
     m_cacheableObject = CacheableStringArray::create(randArr, arraySize);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableStringArray* obj =
         dynamic_cast<const CacheableStringArray*>(object.get());
     ASSERT(obj != nullptr, "getCheckSum: null object.");
     uint32_t checkSum = 0;
-    CacheableStringPtr str;
+    std::shared_ptr<CacheableString> str;
     for (int32_t index = 0; index < obj->length(); index++) {
       str = obj->operator[](index);
       if (str->isWideString()) {
@@ -1074,7 +1078,9 @@ class CacheableUndefinedWrapper : public CacheableWrapper {
         CacheableUndefined::createDeserializable());
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const { return 0; }
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
+    return 0;
+  }
 };
 
 template <typename VECTTYPE>
@@ -1093,8 +1099,7 @@ class CacheableVectorTypeWrapper : public CacheableWrapper {
   virtual void initRandomValue(int32_t maxSize) {
     Serializable* ser = VECTTYPE::createDeserializable();
     VECTTYPE* vec = (VECTTYPE*)ser;
-    std::vector<int8_t> valueTypeIds =
-        CacheableWrapperFactory::getRegisteredValueTypes();
+    auto valueTypeIds = CacheableWrapperFactory::getRegisteredValueTypes();
     size_t sizeOfTheVector = valueTypeIds.size();
     maxSize = maxSize / static_cast<int32_t>(sizeOfTheVector) + 1;
     for (size_t i = 0; i < sizeOfTheVector; i++) {
@@ -1110,12 +1115,12 @@ class CacheableVectorTypeWrapper : public CacheableWrapper {
     m_cacheableObject = std::shared_ptr<Serializable>(vec);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const VECTTYPE* vec = dynamic_cast<const VECTTYPE*>(object.get());
     ASSERT(vec != nullptr, "getCheckSum: null object.");
     uint32_t checkSum = 0;
     for (uint32_t index = 0; index < (uint32_t)vec->size(); ++index) {
-      CacheablePtr obj = vec->at(index);
+      auto obj = vec->at(index);
       if (obj == nullptr) {
         continue;
       }
@@ -1154,8 +1159,7 @@ class CacheableObjectArrayWrapper : public CacheableWrapper {
   virtual void initRandomValue(int32_t maxSize) {
     Serializable* ser = CacheableObjectArray::createDeserializable();
     CacheableObjectArray* arr = (CacheableObjectArray*)ser;
-    std::vector<int8_t> valueTypeIds =
-        CacheableWrapperFactory::getRegisteredValueTypes();
+    auto valueTypeIds = CacheableWrapperFactory::getRegisteredValueTypes();
     size_t sizeOfTheVector = valueTypeIds.size();
     maxSize = maxSize / static_cast<int32_t>(sizeOfTheVector) + 1;
     for (size_t i = 0; i < sizeOfTheVector; i++) {
@@ -1171,14 +1175,14 @@ class CacheableObjectArrayWrapper : public CacheableWrapper {
     m_cacheableObject = std::shared_ptr<Serializable>(arr);
   }
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const {
+  virtual uint32_t getCheckSum(const std::shared_ptr<Cacheable> object) const {
     const CacheableObjectArray* arr =
         dynamic_cast<const CacheableObjectArray*>(object.get());
     ASSERT(arr != nullptr, "getCheckSum: null object.");
     uint32_t checkSum = 0;
     for (uint32_t index = 0; index < static_cast<uint32_t>(arr->size());
          ++index) {
-      const CacheablePtr obj = arr->at(index);
+      const auto obj = arr->at(index);
       if (obj == nullptr) {
         continue;
       }
diff --git a/cppcache/integration-test/CacheHelper.cpp b/cppcache/integration-test/CacheHelper.cpp
index a046815f..b18f1225 100644
--- a/cppcache/integration-test/CacheHelper.cpp
+++ b/cppcache/integration-test/CacheHelper.cpp
@@ -24,7 +24,6 @@
 #include <ace/INET_Addr.h>
 #include <ace/SOCK_Acceptor.h>
 
-#include <geode/GeodeCppCache.hpp>
 #include <geode/SystemProperties.hpp>
 #include <geode/PoolManager.hpp>
 #include <geode/util/chrono/duration.hpp>
@@ -70,8 +69,7 @@ extern ClientCleanup gClientCleanup;
 #define SEED 0
 #define RANDOM_NUMBER_OFFSET 14000
 #define RANDOM_NUMBER_DIVIDER 15000
-
-CachePtr CacheHelper::getCache() { return cachePtr; }
+std::shared_ptr<Cache> CacheHelper::getCache() { return cachePtr; }
 
 CacheHelper& CacheHelper::getHelper() {
   if (singleton == nullptr) {
@@ -80,9 +78,10 @@ CacheHelper& CacheHelper::getHelper() {
   return *singleton;
 }
 
-CacheHelper::CacheHelper(const char* member_id, const PropertiesPtr& configPtr,
+CacheHelper::CacheHelper(const char* member_id,
+                         const std::shared_ptr<Properties>& configPtr,
                          const bool noRootRegion) {
-  PropertiesPtr pp = configPtr;
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
@@ -105,8 +104,8 @@ CacheHelper::CacheHelper(const char* member_id, const PropertiesPtr& configPtr,
 
 /** rootRegionPtr will still be null... */
 CacheHelper::CacheHelper(const char* member_id, const char* cachexml,
-                         const PropertiesPtr& configPtr) {
-  PropertiesPtr pp = configPtr;
+                         const std::shared_ptr<Properties>& configPtr) {
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
@@ -121,9 +120,9 @@ CacheHelper::CacheHelper(const char* member_id, const char* cachexml,
   m_doDisconnect = false;
 }
 
-CacheHelper::CacheHelper(const PropertiesPtr& configPtr,
+CacheHelper::CacheHelper(const std::shared_ptr<Properties>& configPtr,
                          const bool noRootRegion) {
-  PropertiesPtr pp = configPtr;
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
@@ -149,9 +148,9 @@ CacheHelper::CacheHelper(const PropertiesPtr& configPtr,
 }
 
 CacheHelper::CacheHelper(const bool isThinclient,
-                         const AuthInitializePtr& authInitialize,
-                         const PropertiesPtr& configPtr) {
-  PropertiesPtr pp = configPtr;
+                         const std::shared_ptr<AuthInitialize>& authInitialize,
+                         const std::shared_ptr<Properties>& configPtr) {
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
@@ -170,9 +169,9 @@ CacheHelper::CacheHelper(const bool isThinclient,
 }
 
 CacheHelper::CacheHelper(const bool isThinclient,
-                         const PropertiesPtr& configPtr,
+                         const std::shared_ptr<Properties>& configPtr,
                          const bool noRootRegion) {
-  PropertiesPtr pp = configPtr;
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
@@ -189,14 +188,15 @@ CacheHelper::CacheHelper(const bool isThinclient,
 }
 
 CacheHelper::CacheHelper(const bool isThinclient, bool pdxIgnoreUnreadFields,
-                         bool pdxReadSerialized, const PropertiesPtr& configPtr,
+                         bool pdxReadSerialized,
+                         const std::shared_ptr<Properties>& configPtr,
                          const bool noRootRegion) {
-  PropertiesPtr pp = configPtr;
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
   try {
-    CacheFactoryPtr cfPtr = CacheFactory::createCacheFactory(pp);
+    auto cfPtr = CacheFactory::createCacheFactory(pp);
     LOGINFO("pdxReadSerialized = %d ", pdxReadSerialized);
     LOGINFO("pdxIgnoreUnreadFields = %d ", pdxIgnoreUnreadFields);
     cfPtr->setPdxReadSerialized(pdxReadSerialized);
@@ -213,18 +213,18 @@ CacheHelper::CacheHelper(const bool isThinclient, bool pdxIgnoreUnreadFields,
 
 CacheHelper::CacheHelper(const bool isthinClient, const char* poolName,
                          const char* locators, const char* serverGroup,
-                         const PropertiesPtr& configPtr, int redundancy,
-                         bool clientNotification, int subscriptionAckInterval,
-                         int connections, int loadConditioningInterval,
-                         bool isMultiuserMode, bool prSingleHop,
-                         bool threadLocal) {
-  PropertiesPtr pp = configPtr;
+                         const std::shared_ptr<Properties>& configPtr,
+                         int redundancy, bool clientNotification,
+                         int subscriptionAckInterval, int connections,
+                         int loadConditioningInterval, bool isMultiuserMode,
+                         bool prSingleHop, bool threadLocal) {
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
 
   try {
-    CacheFactoryPtr cacheFac = CacheFactory::createCacheFactory(pp);
+    auto cacheFac = CacheFactory::createCacheFactory(pp);
     cachePtr = cacheFac->create();
 
     auto poolFactory = cachePtr->getPoolManager().createFactory();
@@ -265,13 +265,13 @@ CacheHelper::CacheHelper(const bool isthinClient, const char* poolName,
 }
 
 CacheHelper::CacheHelper(const int redundancyLevel,
-                         const PropertiesPtr& configPtr) {
-  PropertiesPtr pp = configPtr;
+                         const std::shared_ptr<Properties>& configPtr) {
+  auto pp = configPtr;
   if (pp == nullptr) {
     pp = Properties::create();
   }
 
-  CacheFactoryPtr cacheFac = CacheFactory::createCacheFactory(pp);
+  auto cacheFac = CacheFactory::createCacheFactory(pp);
   cachePtr = cacheFac->create();
   m_doDisconnect = false;
 }
@@ -282,7 +282,7 @@ CacheHelper::~CacheHelper() {
 }
 
 void CacheHelper::closePool(const char* poolName, bool keepAlive) {
-  PoolPtr pool = getCache()->getPoolManager().find(poolName);
+  auto pool = getCache()->getPoolManager().find(poolName);
   pool->destroy(keepAlive);
 }
 
@@ -325,13 +325,14 @@ void CacheHelper::disconnect(bool keepalive) {
 }
 
 void CacheHelper::createPlainRegion(const char* regionName,
-                                    RegionPtr& regionPtr) {
+                                    std::shared_ptr<Region>& regionPtr) {
   createPlainRegion(regionName, regionPtr, 10);
 }
 
 void CacheHelper::createPlainRegion(const char* regionName,
-                                    RegionPtr& regionPtr, uint32_t size) {
-  RegionAttributesPtr regAttrs;
+                                    std::shared_ptr<Region>& regionPtr,
+                                    uint32_t size) {
+  std::shared_ptr<RegionAttributes> regAttrs;
   AttributesFactory attrFactory;
   // set lru attributes...
   attrFactory.setLruEntriesLimit(0);     // no limit.
@@ -345,12 +346,13 @@ void CacheHelper::createPlainRegion(const char* regionName,
 }
 
 void CacheHelper::createLRURegion(const char* regionName,
-                                  RegionPtr& regionPtr) {
+                                  std::shared_ptr<Region>& regionPtr) {
   createLRURegion(regionName, regionPtr, 10);
 }
-void CacheHelper::createLRURegion(const char* regionName, RegionPtr& regionPtr,
+void CacheHelper::createLRURegion(const char* regionName,
+                                  std::shared_ptr<Region>& regionPtr,
                                   uint32_t size) {
-  RegionAttributesPtr regAttrs;
+  std::shared_ptr<RegionAttributes> regAttrs;
   AttributesFactory attrFactory;
   // set lru attributes...
   attrFactory.setLruEntriesLimit(size);
@@ -364,13 +366,14 @@ void CacheHelper::createLRURegion(const char* regionName, RegionPtr& regionPtr,
 }
 
 void CacheHelper::createDistRegion(const char* regionName,
-                                   RegionPtr& regionPtr) {
+                                   std::shared_ptr<Region>& regionPtr) {
   createDistRegion(regionName, regionPtr, 10);
 }
 
-void CacheHelper::createDistRegion(const char* regionName, RegionPtr& regionPtr,
+void CacheHelper::createDistRegion(const char* regionName,
+                                   std::shared_ptr<Region>& regionPtr,
                                    uint32_t size) {
-  RegionAttributesPtr regAttrs;
+  std::shared_ptr<RegionAttributes> regAttrs;
   AttributesFactory attrFactory;
   // set lru attributes...
   attrFactory.setLruEntriesLimit(0);     // no limit.
@@ -382,17 +385,14 @@ void CacheHelper::createDistRegion(const char* regionName, RegionPtr& regionPtr,
   regionPtr = rootRegionPtr->createSubregion(regionName, regAttrs);
   ASSERT(regionPtr != nullptr, "failed to create region.");
 }
-
-RegionPtr CacheHelper::getRegion(const char* name) {
+std::shared_ptr<Region> CacheHelper::getRegion(const char* name) {
   return cachePtr->getRegion(name);
 }
-
-RegionPtr CacheHelper::createRegion(const char* name, bool ack, bool caching,
-                                    const CacheListenerPtr& listener,
-                                    bool clientNotificationEnabled,
-                                    bool scopeLocal,
-                                    bool concurrencyCheckEnabled,
-                                    int32_t tombstonetimeout) {
+std::shared_ptr<Region> CacheHelper::createRegion(
+    const char* name, bool ack, bool caching,
+    const std::shared_ptr<CacheListener>& listener,
+    bool clientNotificationEnabled, bool scopeLocal,
+    bool concurrencyCheckEnabled, int32_t tombstonetimeout) {
   AttributesFactory af;
   af.setCachingEnabled(caching);
   if (listener != nullptr) {
@@ -402,15 +402,14 @@ RegionPtr CacheHelper::createRegion(const char* name, bool ack, bool caching,
     af.setConcurrencyChecksEnabled(concurrencyCheckEnabled);
   }
 
-  RegionAttributesPtr rattrsPtr = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr = af.createRegionAttributes();
 
   CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cachePtr.get());
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheImpl->createRegion(name, rattrsPtr, regionPtr);
   return regionPtr;
 }
-
-RegionPtr CacheHelper::createRegion(
+std::shared_ptr<Region> CacheHelper::createRegion(
     const char* name, bool ack, bool caching, const std::chrono::seconds& ettl,
     const std::chrono::seconds& eit, const std::chrono::seconds& rttl,
     const std::chrono::seconds& rit, int lel, ExpirationAction::Action action,
@@ -423,21 +422,20 @@ RegionPtr CacheHelper::createRegion(
   af.setRegionIdleTimeout(action, rit);
   af.setRegionTimeToLive(action, rttl);
 
-  RegionAttributesPtr rattrsPtr = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr = af.createRegionAttributes();
 
   CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cachePtr.get());
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheImpl->createRegion(name, rattrsPtr, regionPtr);
   return regionPtr;
 }
-
-PoolPtr CacheHelper::createPool(
+std::shared_ptr<Pool> CacheHelper::createPool(
     const char* poolName, const char* locators, const char* serverGroup,
     int redundancy, bool clientNotification,
     std::chrono::milliseconds subscriptionAckInterval, int connections,
     int loadConditioningInterval, bool isMultiuserMode) {
   // printf(" in createPool isMultiuserMode = %d \n", isMultiuserMode);
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
+  auto poolFacPtr = getCache()->getPoolManager().createFactory();
 
   addServerLocatorEPs(locators, poolFacPtr);
   if (serverGroup) {
@@ -464,11 +462,11 @@ PoolPtr CacheHelper::createPool(
 }
 
 // this will create pool even endpoints and locatorhost has been not defined
-PoolPtr CacheHelper::createPool2(const char* poolName, const char* locators,
-                                 const char* serverGroup, const char* servers,
-                                 int redundancy, bool clientNotification,
-                                 int subscriptionAckInterval, int connections) {
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
+std::shared_ptr<Pool> CacheHelper::createPool2(
+    const char* poolName, const char* locators, const char* serverGroup,
+    const char* servers, int redundancy, bool clientNotification,
+    int subscriptionAckInterval, int connections) {
+  auto poolFacPtr = getCache()->getPoolManager().createFactory();
 
   if (servers != 0)  // with explicit server list
   {
@@ -495,7 +493,7 @@ PoolPtr CacheHelper::createPool2(const char* poolName, const char* locators,
   return poolFacPtr->create(poolName);
 }
 
-void CacheHelper::logPoolAttributes(PoolPtr& pool) {
+void CacheHelper::logPoolAttributes(std::shared_ptr<Pool>& pool) {
   LOG("logPoolAttributes() entered");
   LOGINFO("CPPTEST: Pool attribtes for pool %s are as follows:",
           pool->getName());
@@ -530,16 +528,14 @@ void CacheHelper::createPoolWithLocators(
     bool isMultiuserMode, const char* serverGroup) {
   LOG("createPool() entered.");
   printf(" in createPoolWithLocators isMultiuserMode = %d\n", isMultiuserMode);
-  PoolPtr poolPtr =
-      createPool(name, locators, serverGroup, subscriptionRedundancy,
-                 clientNotificationEnabled, subscriptionAckInterval,
-                 connections, -1, isMultiuserMode);
+  auto poolPtr = createPool(name, locators, serverGroup, subscriptionRedundancy,
+                            clientNotificationEnabled, subscriptionAckInterval,
+                            connections, -1, isMultiuserMode);
   ASSERT(poolPtr != nullptr, "Failed to create pool.");
   logPoolAttributes(poolPtr);
   LOG("Pool created.");
 }
-
-RegionPtr CacheHelper::createRegionAndAttachPool(
+std::shared_ptr<Region> CacheHelper::createRegionAndAttachPool(
     const char* name, bool ack, const char* poolName, bool caching,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
@@ -562,10 +558,9 @@ RegionPtr CacheHelper::createRegionAndAttachPool(
   }
   return regionFactory.create(name);
 }
-
-RegionPtr CacheHelper::createRegionAndAttachPool2(
+std::shared_ptr<Region> CacheHelper::createRegionAndAttachPool2(
     const char* name, bool ack, const char* poolName,
-    const PartitionResolverPtr& aResolver, bool caching,
+    const std::shared_ptr<PartitionResolver>& aResolver, bool caching,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
     ExpirationAction::Action action) {
@@ -587,7 +582,7 @@ RegionPtr CacheHelper::createRegionAndAttachPool2(
   return regionFactory.create(name);
 }
 
-void CacheHelper::addServerLocatorEPs(const char* epList, PoolFactoryPtr pfPtr,
+void CacheHelper::addServerLocatorEPs(const char* epList, std::shared_ptr<PoolFactory> pfPtr,
                                       bool poolLocators) {
   std::unordered_set<std::string> endpointNames;
   Utils::parseEndpointNamesString(epList, endpointNames);
@@ -609,7 +604,7 @@ void CacheHelper::addServerLocatorEPs(const char* epList, PoolFactoryPtr pfPtr,
 }
 
 // void CacheHelper::addServerLocatorEPs(const char* epList,
-//                                      CacheFactoryPtr cacheFac,
+//                                      std::shared_ptr<CacheFactory> cacheFac,
 //                                      bool poolLocators) {
 //  std::unordered_set<std::string> endpointNames;
 //  Utils::parseEndpointNamesString(epList, endpointNames);
@@ -629,14 +624,14 @@ void CacheHelper::addServerLocatorEPs(const char* epList, PoolFactoryPtr pfPtr,
 //    }
 //  }
 //}
-
-RegionPtr CacheHelper::createPooledRegion(
+std::shared_ptr<Region> CacheHelper::createPooledRegion(
     const char* name, bool ack, const char* locators, const char* poolName,
     bool caching, bool clientNotificationEnabled,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
-    const CacheListenerPtr& cacheListener, ExpirationAction::Action action) {
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
+    const std::shared_ptr<CacheListener>& cacheListener,
+    ExpirationAction::Action action) {
+  auto poolFacPtr = getCache()->getPoolManager().createFactory();
   poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
 
   if (locators) {
@@ -646,7 +641,7 @@ RegionPtr CacheHelper::createPooledRegion(
 
   if ((getCache()->getPoolManager().find(poolName)) ==
       nullptr) {  // Pool does not exist with the same name.
-    PoolPtr pptr = poolFacPtr->create(poolName);
+    auto pptr = poolFacPtr->create(poolName);
   }
 
   RegionShortcut preDefRA = PROXY;
@@ -668,14 +663,14 @@ RegionPtr CacheHelper::createPooledRegion(
   }
   return regionFactory.create(name);
 }
-
-RegionPtr CacheHelper::createPooledRegionConcurrencyCheckDisabled(
+std::shared_ptr<Region> CacheHelper::createPooledRegionConcurrencyCheckDisabled(
     const char* name, bool ack, const char* locators, const char* poolName,
     bool caching, bool clientNotificationEnabled, bool concurrencyCheckEnabled,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
-    const CacheListenerPtr& cacheListener, ExpirationAction::Action action) {
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
+    const std::shared_ptr<CacheListener>& cacheListener,
+    ExpirationAction::Action action) {
+  auto poolFacPtr = getCache()->getPoolManager().createFactory();
   poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
 
   LOG("adding pool locators");
@@ -683,7 +678,7 @@ RegionPtr CacheHelper::createPooledRegionConcurrencyCheckDisabled(
 
   if ((getCache()->getPoolManager().find(poolName)) ==
       nullptr) {  // Pool does not exist with the same name.
-    PoolPtr pptr = poolFacPtr->create(poolName);
+    auto pptr = poolFacPtr->create(poolName);
   }
 
   RegionShortcut preDefRA = PROXY;
@@ -706,8 +701,7 @@ RegionPtr CacheHelper::createPooledRegionConcurrencyCheckDisabled(
   }
   return regionFactory.create(name);
 }
-
-RegionPtr CacheHelper::createRegionDiscOverFlow(
+ std::shared_ptr<Region> CacheHelper::createRegionDiscOverFlow(
     const char* name, bool caching, bool clientNotificationEnabled,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
@@ -722,7 +716,7 @@ RegionPtr CacheHelper::createRegionDiscOverFlow(
   af.setCloningEnabled(true);
   if (lel > 0) {
     af.setDiskPolicy(DiskPolicyType::OVERFLOWS);
-    PropertiesPtr sqLiteProps = Properties::create();
+   auto sqLiteProps = Properties::create();
     sqLiteProps->insert("PageSize", "65536");
     sqLiteProps->insert("MaxPageCount", "1073741823");
     std::string sqlite_dir =
@@ -732,20 +726,20 @@ RegionPtr CacheHelper::createRegionDiscOverFlow(
     af.setPersistenceManager("SqLiteImpl", "createSqLiteInstance", sqLiteProps);
   }
 
-  RegionAttributesPtr rattrsPtr = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr = af.createRegionAttributes();
   CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cachePtr.get());
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheImpl->createRegion(name, rattrsPtr, regionPtr);
   return regionPtr;
 }
-
-RegionPtr CacheHelper::createPooledRegionDiscOverFlow(
+std::shared_ptr<Region> CacheHelper::createPooledRegionDiscOverFlow(
     const char* name, bool ack, const char* locators, const char* poolName,
     bool caching, bool clientNotificationEnabled,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
-    const CacheListenerPtr& cacheListener, ExpirationAction::Action action) {
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
+    const std::shared_ptr<CacheListener>& cacheListener,
+    ExpirationAction::Action action) {
+  auto poolFacPtr = getCache()->getPoolManager().createFactory();
   poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
 
   if (locators)  // with locator
@@ -755,7 +749,7 @@ RegionPtr CacheHelper::createPooledRegionDiscOverFlow(
   }
   if ((getCache()->getPoolManager().find(poolName)) ==
       nullptr) {  // Pool does not exist with the same name.
-    PoolPtr pptr = poolFacPtr->create(poolName);
+    auto pptr = poolFacPtr->create(poolName);
   }
 
   if (!caching) {
@@ -794,26 +788,25 @@ RegionPtr CacheHelper::createPooledRegionDiscOverFlow(
   }
   return regionFactory.create(name);
 }
-
-RegionPtr CacheHelper::createPooledRegionSticky(
+ std::shared_ptr<Region> CacheHelper::createPooledRegionSticky(
     const char* name, bool ack, const char* locators, const char* poolName,
     bool caching, bool clientNotificationEnabled,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
-    const CacheListenerPtr& cacheListener, ExpirationAction::Action action) {
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
-  poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
-  poolFacPtr->setThreadLocalConnections(true);
-  poolFacPtr->setPRSingleHopEnabled(false);
+    const std::shared_ptr<CacheListener>& cacheListener, ExpirationAction::Action action) {
+ auto poolFacPtr = getCache()->getPoolManager().createFactory();
+ poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
+ poolFacPtr->setThreadLocalConnections(true);
+ poolFacPtr->setPRSingleHopEnabled(false);
 
-  LOG("adding pool locators");
-  addServerLocatorEPs(locators, poolFacPtr);
+ LOG("adding pool locators");
+ addServerLocatorEPs(locators, poolFacPtr);
 
-  if ((getCache()->getPoolManager().find(poolName)) ==
-      nullptr) {  // Pool does not exist with the same name.
-    PoolPtr pptr = poolFacPtr->create(poolName);
-    LOG("createPooledRegionSticky logPoolAttributes");
-    logPoolAttributes(pptr);
+ if ((getCache()->getPoolManager().find(poolName)) ==
+     nullptr) {  // Pool does not exist with the same name.
+   auto pptr = poolFacPtr->create(poolName);
+   LOG("createPooledRegionSticky logPoolAttributes");
+   logPoolAttributes(pptr);
   }
 
   RegionShortcut preDefRA = PROXY;
@@ -835,26 +828,25 @@ RegionPtr CacheHelper::createPooledRegionSticky(
   }
   return regionFactory.create(name);
 }
-
-RegionPtr CacheHelper::createPooledRegionStickySingleHop(
+ std::shared_ptr<Region> CacheHelper::createPooledRegionStickySingleHop(
     const char* name, bool ack, const char* locators, const char* poolName,
     bool caching, bool clientNotificationEnabled,
     const std::chrono::seconds& ettl, const std::chrono::seconds& eit,
     const std::chrono::seconds& rttl, const std::chrono::seconds& rit, int lel,
-    const CacheListenerPtr& cacheListener, ExpirationAction::Action action) {
+    const std::shared_ptr<CacheListener>& cacheListener, ExpirationAction::Action action) {
   LOG("createPooledRegionStickySingleHop");
-  PoolFactoryPtr poolFacPtr = getCache()->getPoolManager().createFactory();
-  poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
-  poolFacPtr->setThreadLocalConnections(true);
-  poolFacPtr->setPRSingleHopEnabled(true);
-  LOG("adding pool locators");
-  addServerLocatorEPs(locators, poolFacPtr);
+ auto poolFacPtr = getCache()->getPoolManager().createFactory();
+ poolFacPtr->setSubscriptionEnabled(clientNotificationEnabled);
+ poolFacPtr->setThreadLocalConnections(true);
+ poolFacPtr->setPRSingleHopEnabled(true);
+ LOG("adding pool locators");
+ addServerLocatorEPs(locators, poolFacPtr);
 
-  if ((getCache()->getPoolManager().find(poolName)) ==
-      nullptr) {  // Pool does not exist with the same name.
-    PoolPtr pptr = poolFacPtr->create(poolName);
-    LOG("createPooledRegionStickySingleHop logPoolAttributes");
-    logPoolAttributes(pptr);
+ if ((getCache()->getPoolManager().find(poolName)) ==
+     nullptr) {  // Pool does not exist with the same name.
+   auto pptr = poolFacPtr->create(poolName);
+   LOG("createPooledRegionStickySingleHop logPoolAttributes");
+   logPoolAttributes(pptr);
   }
 
   RegionShortcut preDefRA = PROXY;
@@ -876,53 +868,52 @@ RegionPtr CacheHelper::createPooledRegionStickySingleHop(
   }
   return regionFactory.create(name);
 }
-
-RegionPtr CacheHelper::createSubregion(RegionPtr& parent, const char* name,
+ std::shared_ptr<Region> CacheHelper::createSubregion(std::shared_ptr<Region>& parent, const char* name,
                                        bool ack, bool caching,
-                                       const CacheListenerPtr& listener) {
+                                       const std::shared_ptr<CacheListener>& listener) {
   AttributesFactory af;
   af.setCachingEnabled(caching);
   if (listener != nullptr) {
     af.setCacheListener(listener);
   }
-  RegionAttributesPtr rattrsPtr = af.createRegionAttributes();
+ std::shared_ptr<RegionAttributes> rattrsPtr = af.createRegionAttributes();
 
-  return parent->createSubregion(name, rattrsPtr);
+ return parent->createSubregion(name, rattrsPtr);
 }
-
-CacheableStringPtr CacheHelper::createCacheable(const char* value) {
+std::shared_ptr<CacheableString> CacheHelper::createCacheable(
+    const char* value) {
   return CacheableString::create(value);
-}
-
-void CacheHelper::showKeys(VectorOfCacheableKey& vecKeys) {
-  fprintf(stdout, "vecKeys.size() = %zd\n", vecKeys.size());
-  for (uint32_t i = 0; i < static_cast<uint32_t>(vecKeys.size()); i++) {
-    char msg[1024];
-    size_t wrote = vecKeys.at(i)->logString(msg, 1023);
-    msg[wrote] = '\0';  // just in case...
-    fprintf(stdout, "key[%d] - %s\n", i, msg);
-  }
-  fflush(stdout);
-}
-
-void CacheHelper::showRegionAttributes(RegionAttributes& attributes) {
-  printf("caching=%s\n", attributes.getCachingEnabled() ? "true" : "false");
-  printf("Entry Time To Live = %s\n",
-         to_string(attributes.getEntryTimeToLive()).c_str());
-  printf("Entry Idle Timeout = %s\n",
-         to_string(attributes.getEntryIdleTimeout()).c_str());
-  printf("Region Time To Live = %s\n",
-         to_string(attributes.getRegionTimeToLive()).c_str());
-  printf("Region Idle Timeout = %s\n",
-         to_string(attributes.getRegionIdleTimeout()).c_str());
-  printf("Initial Capacity = %d\n", attributes.getInitialCapacity());
-  printf("Load Factor = %f\n", attributes.getLoadFactor());
-  printf("End Points = %s\n",
-         (attributes.getEndpoints() != nullptr ? attributes.getEndpoints()
-                                               : "(null)"));
-}
-
-QueryServicePtr CacheHelper::getQueryService() {
+ }
+
+ void CacheHelper::showKeys(
+     std::vector<std::shared_ptr<CacheableKey>>& vecKeys) {
+   fprintf(stdout, "vecKeys.size() = %zd\n", vecKeys.size());
+   for (uint32_t i = 0; i < static_cast<uint32_t>(vecKeys.size()); i++) {
+     char msg[1024];
+     size_t wrote = vecKeys.at(i)->logString(msg, 1023);
+     msg[wrote] = '\0';  // just in case...
+     fprintf(stdout, "key[%d] - %s\n", i, msg);
+   }
+   fflush(stdout);
+ }
+
+ void CacheHelper::showRegionAttributes(RegionAttributes& attributes) {
+   printf("caching=%s\n", attributes.getCachingEnabled() ? "true" : "false");
+   printf("Entry Time To Live = %s\n",
+          to_string(attributes.getEntryTimeToLive()).c_str());
+   printf("Entry Idle Timeout = %s\n",
+          to_string(attributes.getEntryIdleTimeout()).c_str());
+   printf("Region Time To Live = %s\n",
+          to_string(attributes.getRegionTimeToLive()).c_str());
+   printf("Region Idle Timeout = %s\n",
+          to_string(attributes.getRegionIdleTimeout()).c_str());
+   printf("Initial Capacity = %d\n", attributes.getInitialCapacity());
+   printf("Load Factor = %f\n", attributes.getLoadFactor());
+   printf("End Points = %s\n",
+          (attributes.getEndpoints() != nullptr ? attributes.getEndpoints()
+                                                : "(null)"));
+}
+ std::shared_ptr<QueryService> CacheHelper::getQueryService() {
   return cachePtr->getQueryService();
 }
 
@@ -1769,7 +1760,7 @@ void CacheHelper::initLocator(int instance, bool ssl, bool multiDS, int dsId,
 }
 
 void CacheHelper::clearSecProp() {
-  PropertiesPtr tmpSecProp = CacheHelper::getHelper()
+ auto tmpSecProp = CacheHelper::getHelper()
                                  .getCache()
                                  ->getDistributedSystem()
                                  .getSystemProperties()
diff --git a/cppcache/integration-test/CacheHelper.hpp b/cppcache/integration-test/CacheHelper.hpp
index 556a44e6..b6570927 100644
--- a/cppcache/integration-test/CacheHelper.hpp
+++ b/cppcache/integration-test/CacheHelper.hpp
@@ -28,7 +28,6 @@
 #include <ace/INET_Addr.h>
 #include <ace/SOCK_Acceptor.h>
 
-#include <geode/GeodeCppCache.hpp>
 #include <geode/SystemProperties.hpp>
 #include <geode/PoolManager.hpp>
 
@@ -50,47 +49,51 @@ class CacheHelper {
  public:
   static CacheHelper* singleton;
   static std::list<std::string> staticConfigFileList;
-  CachePtr cachePtr;
-  RegionPtr rootRegionPtr;
+  std::shared_ptr<Cache> cachePtr;
+  std::shared_ptr<Region> rootRegionPtr;
   bool m_doDisconnect;
 
-  CachePtr getCache();
+  std::shared_ptr<Cache> getCache();
 
   static CacheHelper& getHelper();
 
   static std::string unitTestOutputFile();
   static int getNumLocatorListUpdates(const char* s);
 
-  CacheHelper(const char* member_id, const PropertiesPtr& configPtr = nullptr,
+  CacheHelper(const char* member_id,
+              const std::shared_ptr<Properties>& configPtr = nullptr,
               const bool noRootRegion = false);
 
   /** rootRegionPtr will still be null... */
   CacheHelper(const char* member_id, const char* cachexml,
-              const PropertiesPtr& configPtr = nullptr);
+              const std::shared_ptr<Properties>& configPtr = nullptr);
 
-  CacheHelper(const PropertiesPtr& configPtr = nullptr,
+  CacheHelper(const std::shared_ptr<Properties>& configPtr = nullptr,
               const bool noRootRegion = false);
 
-  CacheHelper(const bool isThinclient, const PropertiesPtr& configPtr = nullptr,
+  CacheHelper(const bool isThinclient,
+              const std::shared_ptr<Properties>& configPtr = nullptr,
               const bool noRootRegion = false);
 
-  CacheHelper(const bool isThinclient, const AuthInitializePtr& authInitialize,
-              const PropertiesPtr& configPtr = nullptr);
+  CacheHelper(const bool isThinclient,
+              const std::shared_ptr<AuthInitialize>& authInitialize,
+              const std::shared_ptr<Properties>& configPtr = nullptr);
 
   CacheHelper(const bool isThinclient, bool pdxIgnoreUnreadFields,
-              bool pdxReadSerialized, const PropertiesPtr& configPtr = nullptr,
+              bool pdxReadSerialized,
+              const std::shared_ptr<Properties>& configPtr = nullptr,
               const bool noRootRegion = false);
 
   CacheHelper(const bool isthinClient, const char* poolName,
               const char* locators, const char* serverGroup,
-              const PropertiesPtr& configPtr = nullptr, int redundancy = 0,
-              bool clientNotification = false, int subscriptionAckInterval = -1,
-              int connections = -1, int loadConditioningInterval = -1,
-              bool isMultiuserMode = false, bool prSingleHop = false,
-              bool threadLocal = false);
+              const std::shared_ptr<Properties>& configPtr = nullptr,
+              int redundancy = 0, bool clientNotification = false,
+              int subscriptionAckInterval = -1, int connections = -1,
+              int loadConditioningInterval = -1, bool isMultiuserMode = false,
+              bool prSingleHop = false, bool threadLocal = false);
 
   CacheHelper(const int redundancyLevel,
-              const PropertiesPtr& configPtr = nullptr);
+              const std::shared_ptr<Properties>& configPtr = nullptr);
 
   virtual ~CacheHelper();
 
@@ -98,31 +101,33 @@ class CacheHelper {
 
   void disconnect(bool keepalive = false);
 
-  void createPlainRegion(const char* regionName, RegionPtr& regionPtr);
+  void createPlainRegion(const char* regionName,
+                         std::shared_ptr<Region>& regionPtr);
 
-  void createPlainRegion(const char* regionName, RegionPtr& regionPtr,
-                         uint32_t size);
+  void createPlainRegion(const char* regionName,
+                         std::shared_ptr<Region>& regionPtr, uint32_t size);
 
-  void createLRURegion(const char* regionName, RegionPtr& regionPtr);
+  void createLRURegion(const char* regionName,
+                       std::shared_ptr<Region>& regionPtr);
 
-  void createLRURegion(const char* regionName, RegionPtr& regionPtr,
-                       uint32_t size);
+  void createLRURegion(const char* regionName,
+                       std::shared_ptr<Region>& regionPtr, uint32_t size);
 
-  void createDistRegion(const char* regionName, RegionPtr& regionPtr);
+  void createDistRegion(const char* regionName,
+                        std::shared_ptr<Region>& regionPtr);
 
-  void createDistRegion(const char* regionName, RegionPtr& regionPtr,
-                        uint32_t size);
+  void createDistRegion(const char* regionName,
+                        std::shared_ptr<Region>& regionPtr, uint32_t size);
 
-  RegionPtr getRegion(const char* name);
+  std::shared_ptr<Region> getRegion(const char* name);
 
-  RegionPtr createRegion(const char* name, bool ack, bool caching,
-                         const CacheListenerPtr& listener,
-                         bool clientNotificationEnabled = false,
-                         bool scopeLocal = false,
-                         bool concurrencyCheckEnabled = false,
-                         int32_t tombstonetimeout = -1);
+  std::shared_ptr<Region> createRegion(
+      const char* name, bool ack, bool caching,
+      const std::shared_ptr<CacheListener>& listener,
+      bool clientNotificationEnabled = false, bool scopeLocal = false,
+      bool concurrencyCheckEnabled = false, int32_t tombstonetimeout = -1);
 
-  RegionPtr createRegion(
+  std::shared_ptr<Region> createRegion(
       const char* name, bool ack, bool caching = true,
       const std::chrono::seconds& ettl = std::chrono::seconds::zero(),
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
@@ -131,21 +136,24 @@ class CacheHelper {
       int lel = 0, ExpirationAction::Action action = ExpirationAction::DESTROY,
       const char* endpoints = 0, bool clientNotificationEnabled = false);
 
-  PoolPtr createPool(const char* poolName, const char* locators,
-                     const char* serverGroup, int redundancy = 0,
-                     bool clientNotification = false,
-                     std::chrono::milliseconds subscriptionAckInterval =
-                         std::chrono::milliseconds::zero(),
-                     int connections = -1, int loadConditioningInterval = -1,
-                     bool isMultiuserMode = false);
+  std::shared_ptr<Pool> createPool(
+      const char* poolName, const char* locators, const char* serverGroup,
+      int redundancy = 0, bool clientNotification = false,
+      std::chrono::milliseconds subscriptionAckInterval =
+          std::chrono::milliseconds::zero(),
+      int connections = -1, int loadConditioningInterval = -1,
+      bool isMultiuserMode = false);
 
   // this will create pool even endpoints and locatorhost has been not defined
-  PoolPtr createPool2(const char* poolName, const char* locators,
-                      const char* serverGroup, const char* servers = nullptr,
-                      int redundancy = 0, bool clientNotification = false,
-                      int subscriptionAckInterval = -1, int connections = -1);
+  std::shared_ptr<Pool> createPool2(const char* poolName, const char* locators,
+                                    const char* serverGroup,
+                                    const char* servers = nullptr,
+                                    int redundancy = 0,
+                                    bool clientNotification = false,
+                                    int subscriptionAckInterval = -1,
+                                    int connections = -1);
 
-  void logPoolAttributes(PoolPtr& pool);
+  void logPoolAttributes(std::shared_ptr<Pool>& pool);
 
   void createPoolWithLocators(
       const char* name, const char* locators = nullptr,
@@ -155,7 +163,7 @@ class CacheHelper {
       int connections = -1, bool isMultiuserMode = false,
       const char* serverGroup = nullptr);
 
-  RegionPtr createRegionAndAttachPool(
+  std::shared_ptr<Region> createRegionAndAttachPool(
       const char* name, bool ack, const char* poolName = nullptr,
       bool caching = true,
       const std::chrono::seconds& ettl = std::chrono::seconds::zero(),
@@ -164,22 +172,25 @@ class CacheHelper {
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
       int lel = 0, ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createRegionAndAttachPool2(
+  std::shared_ptr<Region> createRegionAndAttachPool2(
       const char* name, bool ack, const char* poolName,
-      const PartitionResolverPtr& aResolver = nullptr, bool caching = true,
+      const std::shared_ptr<PartitionResolver>& aResolver = nullptr,
+      bool caching = true,
       const std::chrono::seconds& ettl = std::chrono::seconds::zero(),
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
       const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
       int lel = 0, ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  void addServerLocatorEPs(const char* epList, PoolFactoryPtr pfPtr,
+  void addServerLocatorEPs(const char* epList,
+                           std::shared_ptr<PoolFactory> pfPtr,
                            bool poolLocators = true);
 
-  void addServerLocatorEPs(const char* epList, CacheFactoryPtr cacheFac,
+  void addServerLocatorEPs(const char* epList,
+                           std::shared_ptr<CacheFactory> cacheFac,
                            bool poolLocators = true);
 
-  RegionPtr createPooledRegion(
+  std::shared_ptr<Region> createPooledRegion(
       const char* name, bool ack, const char* locators = 0,
       const char* poolName = "__TEST_POOL1__", bool caching = true,
       bool clientNotificationEnabled = false,
@@ -187,10 +198,11 @@ class CacheHelper {
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
       const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
-      int lel = 0, const CacheListenerPtr& cacheListener = nullptr,
+      int lel = 0,
+      const std::shared_ptr<CacheListener>& cacheListener = nullptr,
       ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createPooledRegionConcurrencyCheckDisabled(
+  std::shared_ptr<Region> createPooledRegionConcurrencyCheckDisabled(
       const char* name, bool ack, const char* locators = 0,
       const char* poolName = "__TEST_POOL1__", bool caching = true,
       bool clientNotificationEnabled = false,
@@ -199,10 +211,11 @@ class CacheHelper {
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
       const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
-      int lel = 0, const CacheListenerPtr& cacheListener = nullptr,
+      int lel = 0,
+      const std::shared_ptr<CacheListener>& cacheListener = nullptr,
       ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createRegionDiscOverFlow(
+  std::shared_ptr<Region> createRegionDiscOverFlow(
       const char* name, bool caching = true,
       bool clientNotificationEnabled = false,
       const std::chrono::seconds& ettl = std::chrono::seconds::zero(),
@@ -211,7 +224,7 @@ class CacheHelper {
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
       int lel = 0, ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createPooledRegionDiscOverFlow(
+  std::shared_ptr<Region> createPooledRegionDiscOverFlow(
       const char* name, bool ack, const char* locators = 0,
       const char* poolName = "__TEST_POOL1__", bool caching = true,
       bool clientNotificationEnabled = false,
@@ -219,10 +232,11 @@ class CacheHelper {
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
       const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
-      int lel = 0, const CacheListenerPtr& cacheListener = nullptr,
+      int lel = 0,
+      const std::shared_ptr<CacheListener>& cacheListener = nullptr,
       ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createPooledRegionSticky(
+  std::shared_ptr<Region> createPooledRegionSticky(
       const char* name, bool ack, const char* locators = 0,
       const char* poolName = "__TEST_POOL1__", bool caching = true,
       bool clientNotificationEnabled = false,
@@ -230,10 +244,11 @@ class CacheHelper {
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
       const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
-      int lel = 0, const CacheListenerPtr& cacheListener = nullptr,
+      int lel = 0,
+      const std::shared_ptr<CacheListener>& cacheListener = nullptr,
       ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createPooledRegionStickySingleHop(
+  std::shared_ptr<Region> createPooledRegionStickySingleHop(
       const char* name, bool ack, const char* locators = 0,
       const char* poolName = "__TEST_POOL1__", bool caching = true,
       bool clientNotificationEnabled = false,
@@ -241,19 +256,21 @@ class CacheHelper {
       const std::chrono::seconds& eit = std::chrono::seconds::zero(),
       const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
       const std::chrono::seconds& rit = std::chrono::seconds::zero(),
-      int lel = 0, const CacheListenerPtr& cacheListener = nullptr,
+      int lel = 0,
+      const std::shared_ptr<CacheListener>& cacheListener = nullptr,
       ExpirationAction::Action action = ExpirationAction::DESTROY);
 
-  RegionPtr createSubregion(RegionPtr& parent, const char* name, bool ack,
-                            bool caching, const CacheListenerPtr& listener);
+  std::shared_ptr<Region> createSubregion(
+      std::shared_ptr<Region>& parent, const char* name, bool ack, bool caching,
+      const std::shared_ptr<CacheListener>& listener);
 
-  CacheableStringPtr createCacheable(const char* value);
+  std::shared_ptr<CacheableString> createCacheable(const char* value);
 
-  void showKeys(VectorOfCacheableKey& vecKeys);
+  void showKeys(std::vector<std::shared_ptr<CacheableKey>>& vecKeys);
 
   void showRegionAttributes(RegionAttributes& attributes);
 
-  QueryServicePtr getQueryService();
+  std::shared_ptr<QueryService> getQueryService();
 
   /*
    * GFJAVA is the environment variable. user has to set GFJAVA variable as a
diff --git a/cppcache/integration-test/CacheImplHelper.hpp b/cppcache/integration-test/CacheImplHelper.hpp
index 474205be..51e7a2d8 100644
--- a/cppcache/integration-test/CacheImplHelper.hpp
+++ b/cppcache/integration-test/CacheImplHelper.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 
-#include <geode/GeodeCppCache.hpp>
 #include <cstdlib>
 #include <geode/SystemProperties.hpp>
 #include <ace/OS.h>
@@ -40,17 +39,17 @@ using namespace unitTests;
 class CacheImplHelper : public CacheHelper {
  public:
   CacheImplHelper(const char* member_id,
-                  const PropertiesPtr& configPtr = nullptr)
+                  const std::shared_ptr<Properties>& configPtr = nullptr)
       : CacheHelper(member_id, configPtr) {}
 
-  CacheImplHelper(const PropertiesPtr& configPtr = nullptr)
+  CacheImplHelper(const std::shared_ptr<Properties>& configPtr = nullptr)
       : CacheHelper(configPtr) {}
 
-  virtual void createRegion(const char* regionName, RegionPtr& regionPtr,
-                            uint32_t size, bool ack = false,
-                            bool cacheServerClient = false,
+  virtual void createRegion(const char* regionName,
+                            std::shared_ptr<Region>& regionPtr, uint32_t size,
+                            bool ack = false, bool cacheServerClient = false,
                             bool cacheEnabled = true) {
-    RegionAttributesPtr regAttrs;
+    std::shared_ptr<RegionAttributes> regAttrs;
     AttributesFactory attrFactory;
     // set lru attributes...
     attrFactory.setLruEntriesLimit(0);     // no limit.
diff --git a/cppcache/integration-test/CacheableWrapper.hpp b/cppcache/integration-test/CacheableWrapper.hpp
index cc0f951d..79df121e 100644
--- a/cppcache/integration-test/CacheableWrapper.hpp
+++ b/cppcache/integration-test/CacheableWrapper.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 
-#include <geode/GeodeCppCache.hpp>
 #include <string>
 #include <map>
 #include <vector>
@@ -29,13 +28,15 @@ using namespace apache::geode::client;
 
 class CacheableWrapper {
  protected:
-  CacheablePtr m_cacheableObject;
+  std::shared_ptr<Cacheable> m_cacheableObject;
 
  public:
-  CacheableWrapper(const CacheablePtr cacheableObject)
+  CacheableWrapper(const std::shared_ptr<Cacheable> cacheableObject)
       : m_cacheableObject(cacheableObject) {}
 
-  virtual CacheablePtr getCacheable() const { return m_cacheableObject; }
+  virtual std::shared_ptr<Cacheable> getCacheable() const {
+    return m_cacheableObject;
+  }
 
   virtual int maxKeys() const {
     throw IllegalArgumentException("Cannot call maxKeys.");
@@ -47,7 +48,8 @@ class CacheableWrapper {
 
   virtual void initRandomValue(int maxSize) = 0;
 
-  virtual uint32_t getCheckSum(const CacheablePtr object) const = 0;
+  virtual uint32_t getCheckSum(
+      const std::shared_ptr<Cacheable> object) const = 0;
 
   uint32_t getCheckSum() const { return getCheckSum(m_cacheableObject); }
 
diff --git a/cppcache/integration-test/DeltaEx.hpp b/cppcache/integration-test/DeltaEx.hpp
index e0dc9e4d..c34f2eee 100644
--- a/cppcache/integration-test/DeltaEx.hpp
+++ b/cppcache/integration-test/DeltaEx.hpp
@@ -21,9 +21,15 @@
 #define GEODE_INTEGRATION_TEST_DELTAEX_H_
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
+#include <memory>
+#include <geode/PdxSerializable.hpp>
+#include <geode/PdxWriter.hpp>
+#include <geode/PdxReader.hpp>
+#include <geode/Delta.hpp>
+
 #include "CacheHelper.hpp"
+
 class DeltaEx : public Cacheable, public Delta {
  private:
   std::shared_ptr<DeltaEx> shared_from_this() {
@@ -69,7 +75,7 @@ class DeltaEx : public Cacheable, public Delta {
   }
   virtual int32_t classId() const { return 1; }
   virtual uint32_t objectSize() const { return 0; }
-  DeltaPtr clone() {
+  std::shared_ptr<Delta> clone() {
     cloneCount++;
     return shared_from_this();
   }
@@ -117,19 +123,19 @@ class PdxDeltaEx : public PdxSerializable, public Delta {
 
   const char* getClassName() const { return "PdxTests.PdxDeltaEx"; }
 
-  void toData(PdxWriterPtr pw) {
+  void toData(std::shared_ptr<PdxWriter> pw) {
     pw->writeInt("counter", m_counter);
     m_toDataCount++;
   }
 
-  void fromData(PdxReaderPtr pr) {
+  void fromData(std::shared_ptr<PdxReader> pr) {
     m_counter = pr->readInt("counter");
     m_fromDataCount++;
   }
 
   static PdxSerializable* createDeserializable() { return new PdxDeltaEx(); }
 
-  DeltaPtr clone() {
+  std::shared_ptr<Delta> clone() {
     m_cloneCount++;
     return shared_from_this();
   }
@@ -138,13 +144,12 @@ class PdxDeltaEx : public PdxSerializable, public Delta {
 
   void setDelta(bool delta) { this->m_isDelta = delta; }
 
-  CacheableStringPtr toString() const {
+  std::shared_ptr<CacheableString> toString() const {
     char idbuf[1024];
     sprintf(idbuf, "PdxDeltaEx :: [counter=%d]  [isDelta=%d]", m_counter,
             m_isDelta);
     return CacheableString::create(idbuf);
   }
 };
-typedef std::shared_ptr<PdxDeltaEx> PdxDeltaExPtr;
 
 #endif  // GEODE_INTEGRATION_TEST_DELTAEX_H_
diff --git a/cppcache/integration-test/QueryHelper.hpp b/cppcache/integration-test/QueryHelper.hpp
index df220c60..8eb0b796 100644
--- a/cppcache/integration-test/QueryHelper.hpp
+++ b/cppcache/integration-test/QueryHelper.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 
-#include <geode/GeodeCppCache.hpp>
 #include <cstdlib>
 #include <geode/SystemProperties.hpp>
 #include <ace/OS.h>
@@ -70,21 +69,23 @@ class QueryHelper {
 
   virtual ~QueryHelper() { ; }
 
-  virtual void populatePortfolioData(RegionPtr& pregion, int setSize,
-                                     int numSets, int32_t objSize = 1,
-                                     CacheableStringArrayPtr nm = nullptr);
-  virtual void populatePositionData(RegionPtr& pregion, int setSize,
-                                    int numSets);
-  virtual void populatePortfolioPdxData(RegionPtr& pregion, int setSize,
-                                        int numSets, int32_t objSize = 1,
+  virtual void populatePortfolioData(
+      std::shared_ptr<Region>& pregion, int setSize, int numSets,
+      int32_t objSize = 1, std::shared_ptr<CacheableStringArray> nm = nullptr);
+  virtual void populatePositionData(std::shared_ptr<Region>& pregion,
+                                    int setSize, int numSets);
+  virtual void populatePortfolioPdxData(std::shared_ptr<Region>& pregion,
+                                        int setSize, int numSets,
+                                        int32_t objSize = 1,
                                         char** nm = nullptr);
-  virtual void populatePositionPdxData(RegionPtr& pregion, int setSize,
-                                       int numSets);
-  virtual void populatePDXObject(RegionPtr& pregion);
-  virtual void getPDXObject(RegionPtr& pregion);
-
-  virtual bool verifyRS(SelectResultsPtr& resultset, int rowCount);
-  virtual bool verifySS(SelectResultsPtr& structset, int rowCount,
+  virtual void populatePositionPdxData(std::shared_ptr<Region>& pregion,
+                                       int setSize, int numSets);
+  virtual void populatePDXObject(std::shared_ptr<Region>& pregion);
+  virtual void getPDXObject(std::shared_ptr<Region>& pregion);
+
+  virtual bool verifyRS(std::shared_ptr<SelectResults>& resultset,
+                        int rowCount);
+  virtual bool verifySS(std::shared_ptr<SelectResults>& structset, int rowCount,
                         int fieldCount);
 
   // utility methods
@@ -155,9 +156,9 @@ QueryHelper* QueryHelper::singleton = nullptr;
 
 //===========================================================================================
 
-void QueryHelper::populatePortfolioData(RegionPtr& rptr, int setSize,
-                                        int numSets, int32_t objSize,
-                                        CacheableStringArrayPtr nm) {
+void QueryHelper::populatePortfolioData(
+    std::shared_ptr<Region>& rptr, int setSize, int numSets, int32_t objSize,
+    std::shared_ptr<CacheableStringArray> nm) {
   // lets reset the counter for uniform population of position objects
   Position::resetCounter();
 
@@ -168,7 +169,7 @@ void QueryHelper::populatePortfolioData(RegionPtr& rptr, int setSize,
       char portname[100] = {0};
       ACE_OS::sprintf(portname, "port%d-%d", set, current);
 
-      CacheableKeyPtr keyport = CacheableKey::create(portname);
+      auto keyport = CacheableKey::create(portname);
       // printf(" QueryHelper::populatePortfolioData creating key = %s and
       // puting data \n",portname);
       rptr->put(keyport, port);
@@ -183,8 +184,8 @@ void QueryHelper::populatePortfolioData(RegionPtr& rptr, int setSize,
 const char* secIds[] = {"SUN", "IBM",  "YHOO", "GOOG", "MSFT",
                         "AOL", "APPL", "ORCL", "SAP",  "DELL"};
 
-void QueryHelper::populatePositionData(RegionPtr& rptr, int setSize,
-                                       int numSets) {
+void QueryHelper::populatePositionData(std::shared_ptr<Region>& rptr,
+                                       int setSize, int numSets) {
   int numSecIds = sizeof(secIds) / sizeof(char*);
 
   for (int set = 1; set <= numSets; set++) {
@@ -195,16 +196,16 @@ void QueryHelper::populatePositionData(RegionPtr& rptr, int setSize,
       char posname[100] = {0};
       ACE_OS::sprintf(posname, "pos%d-%d", set, current);
 
-      CacheableKeyPtr keypos = CacheableKey::create(posname);
+      auto keypos = CacheableKey::create(posname);
       rptr->put(keypos, pos);
     }
   }
   // positionSetSize = setSize; positionNumSets = numSets;
 }
 
-void QueryHelper::populatePortfolioPdxData(RegionPtr& rptr, int setSize,
-                                           int numSets, int32_t objSize,
-                                           char** nm) {
+void QueryHelper::populatePortfolioPdxData(std::shared_ptr<Region>& rptr,
+                                           int setSize, int numSets,
+                                           int32_t objSize, char** nm) {
   // lets reset the counter for uniform population of position objects
   PositionPdx::resetCounter();
 
@@ -215,7 +216,7 @@ void QueryHelper::populatePortfolioPdxData(RegionPtr& rptr, int setSize,
       char portname[100] = {0};
       ACE_OS::sprintf(portname, "port%d-%d", set, current);
 
-      CacheableKeyPtr keyport = CacheableKey::create(portname);
+      auto keyport = CacheableKey::create(portname);
 
       rptr->put(keyport, port);
       LOGINFO("populatePortfolioPdxData:: Put for iteration current = %d done",
@@ -228,8 +229,8 @@ void QueryHelper::populatePortfolioPdxData(RegionPtr& rptr, int setSize,
   printf("all puts done \n");
 }
 
-void QueryHelper::populatePositionPdxData(RegionPtr& rptr, int setSize,
-                                          int numSets) {
+void QueryHelper::populatePositionPdxData(std::shared_ptr<Region>& rptr,
+                                          int setSize, int numSets) {
   int numSecIds = sizeof(secIds) / sizeof(char*);
 
   for (int set = 1; set <= numSets; set++) {
@@ -240,14 +241,14 @@ void QueryHelper::populatePositionPdxData(RegionPtr& rptr, int setSize,
       char posname[100] = {0};
       ACE_OS::sprintf(posname, "pos%d-%d", set, current);
 
-      CacheableKeyPtr keypos = CacheableKey::create(posname);
+      auto keypos = CacheableKey::create(posname);
       rptr->put(keypos, pos);
     }
   }
   // positionSetSize = setSize; positionNumSets = numSets;
 }
 
-void QueryHelper::populatePDXObject(RegionPtr& rptr) {
+void QueryHelper::populatePDXObject(std::shared_ptr<Region>& rptr) {
   // Register PdxType Object
 
   CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(rptr->getCache().get());
@@ -256,7 +257,7 @@ void QueryHelper::populatePDXObject(RegionPtr& rptr) {
 
   // Creating object of type PdxObject
   auto pdxobj = std::make_shared<PdxTests::PdxType>();
-  CacheableKeyPtr keyport = CacheableKey::create("ABC");
+  auto keyport = CacheableKey::create("ABC");
 
   // PUT Operation
   rptr->put(keyport, pdxobj);
@@ -284,11 +285,11 @@ void QueryHelper::populatePDXObject(RegionPtr& rptr) {
   LOG("NIL:200:PUT Operation successfully Done....End");
 }
 
-void QueryHelper::getPDXObject(RegionPtr& rptr) {
+void QueryHelper::getPDXObject(std::shared_ptr<Region>& rptr) {
   // Remote GET for PdxObject
   // PdxObject *obj2 = dynamic_cast<PdxObject *> ((rptr->get(keyport)).get());
 
-  CacheableKeyPtr keyport = CacheableKey::create("ABC");
+  auto keyport = CacheableKey::create("ABC");
   LOG("Client-2 PdxObject GET OP Start....");
   auto obj2 = std::dynamic_pointer_cast<PdxTests::PdxType>(rptr->get(keyport));
   LOG("Client-2 PdxObject GET OP Done....");
@@ -307,20 +308,20 @@ void QueryHelper::getPDXObject(RegionPtr& rptr) {
   */
 }
 
-bool QueryHelper::verifyRS(SelectResultsPtr& resultSet, int expectedRows) {
+bool QueryHelper::verifyRS(std::shared_ptr<SelectResults>& resultSet,
+                           int expectedRows) {
   if (!std::dynamic_pointer_cast<ResultSet>(resultSet)) {
     return false;
   }
 
-  ResultSetPtr rsptr =
-      std::static_pointer_cast<ResultSet>(resultSet);
+  auto rsptr = std::static_pointer_cast<ResultSet>(resultSet);
 
   int foundRows = 0;
 
   SelectResultsIterator iter = rsptr->getIterator();
 
   for (int32_t rows = 0; rows < rsptr->size(); rows++) {
-    SerializablePtr ser = (*rsptr)[rows];
+    auto ser = (*rsptr)[rows];
     foundRows++;
   }
 
@@ -330,8 +331,8 @@ bool QueryHelper::verifyRS(SelectResultsPtr& resultSet, int expectedRows) {
   return false;
 }
 
-bool QueryHelper::verifySS(SelectResultsPtr& structSet, int expectedRows,
-                           int expectedFields) {
+bool QueryHelper::verifySS(std::shared_ptr<SelectResults>& structSet,
+                           int expectedRows, int expectedFields) {
   if (!std::dynamic_pointer_cast<StructSet>(structSet)) {
     if (expectedRows == 0 && expectedFields == 0) {
       return true;  // quite possible we got a null set back.
@@ -340,14 +341,13 @@ bool QueryHelper::verifySS(SelectResultsPtr& structSet, int expectedRows,
     return false;
   }
 
-  StructSetPtr ssptr =
-      std::static_pointer_cast<StructSet>(structSet);
+  auto ssptr = std::static_pointer_cast<StructSet>(structSet);
 
   int foundRows = 0;
 
   for (SelectResults::Iterator iter = ssptr->begin(); iter != ssptr->end();
        iter++) {
-    SerializablePtr ser = (*iter);
+    auto ser = (*iter);
     foundRows++;
 
     Struct* siptr = dynamic_cast<Struct*>(ser.get());
@@ -360,7 +360,7 @@ bool QueryHelper::verifySS(SelectResultsPtr& structSet, int expectedRows,
     int foundFields = 0;
 
     for (int32_t cols = 0; cols < siptr->length(); cols++) {
-      SerializablePtr field = (*siptr)[cols];
+      auto field = (*siptr)[cols];
       foundFields++;
     }
 
diff --git a/cppcache/integration-test/TallyListener.hpp b/cppcache/integration-test/TallyListener.hpp
index 1d94a0f8..65e9dcce 100644
--- a/cppcache/integration-test/TallyListener.hpp
+++ b/cppcache/integration-test/TallyListener.hpp
@@ -20,13 +20,10 @@
  * limitations under the License.
  */
 
-#include <geode/GeodeCppCache.hpp>
+#include <geode/EntryEvent.hpp>
 #include <string>
 
 using namespace apache::geode::client;
-class TallyListener;
-
-typedef std::shared_ptr<TallyListener> TallyListenerPtr;
 
 class TallyListener : public CacheListener {
  private:
@@ -37,9 +34,9 @@ class TallyListener : public CacheListener {
   int m_clears;
   bool isListnerInvoked;
   bool isCallbackCalled;
-  CacheableKeyPtr m_lastKey;
-  CacheablePtr m_lastValue;
-  CacheableKeyPtr m_callbackArg;
+  std::shared_ptr<CacheableKey> m_lastKey;
+  std::shared_ptr<Cacheable> m_lastValue;
+  std::shared_ptr<CacheableKey> m_callbackArg;
   bool m_ignoreTimeout;
   bool m_quiet;
 
@@ -113,12 +110,12 @@ class TallyListener : public CacheListener {
   int getInvalidates() { return m_invalidates; }
   int getDestroys() { return m_destroys; }
   bool isListenerInvoked() { return isListnerInvoked; }
-  void setCallBackArg(const CacheableKeyPtr& callbackArg) {
+  void setCallBackArg(const std::shared_ptr<CacheableKey>& callbackArg) {
     m_callbackArg = callbackArg;
   }
-  CacheableKeyPtr getLastKey() { return m_lastKey; }
+  std::shared_ptr<CacheableKey> getLastKey() { return m_lastKey; }
 
-  CacheablePtr getLastValue() { return m_lastValue; }
+  std::shared_ptr<Cacheable> getLastValue() { return m_lastValue; }
   bool isCallBackArgCalled() { return isCallbackCalled; }
   void checkcallbackArg(const EntryEvent& event) {
     if (!isListnerInvoked) isListnerInvoked = true;
diff --git a/cppcache/integration-test/TallyLoader.hpp b/cppcache/integration-test/TallyLoader.hpp
index e7184aa7..d7b0c0c4 100644
--- a/cppcache/integration-test/TallyLoader.hpp
+++ b/cppcache/integration-test/TallyLoader.hpp
@@ -20,15 +20,11 @@
  * limitations under the License.
  */
 
-#include <geode/GeodeCppCache.hpp>
-
 using namespace apache::geode::client;
 using namespace test;
 
 class TallyLoader;
 
-typedef std::shared_ptr<TallyLoader> TallyLoaderPtr;
-
 class TallyLoader : virtual public CacheLoader {
  private:
   int32_t m_loads;
@@ -41,8 +37,10 @@ class TallyLoader : virtual public CacheLoader {
   {}
   virtual ~TallyLoader() {}
 
-  CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                    const SerializablePtr& aCallbackArgument) {
+  std::shared_ptr<Cacheable> load(
+      const std::shared_ptr<Region>& rp,
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument) {
     LOGDEBUG("TallyLoader::load invoked for %d.", m_loads);
     char buf[1024];
     sprintf(buf, "TallyLoader state: (loads = %d)", m_loads);
@@ -50,7 +48,7 @@ class TallyLoader : virtual public CacheLoader {
     return CacheableInt32::create(m_loads++);
   }
 
-  virtual void close(const RegionPtr& region) { LOG("TallyLoader::close"); }
+  virtual void close(const std::shared_ptr<Region>& region) { LOG("TallyLoader::close"); }
 
   int expectLoads(int expected) {
     int tries = 0;
diff --git a/cppcache/integration-test/TallyWriter.hpp b/cppcache/integration-test/TallyWriter.hpp
index 9a99b7aa..e8425b76 100644
--- a/cppcache/integration-test/TallyWriter.hpp
+++ b/cppcache/integration-test/TallyWriter.hpp
@@ -20,15 +20,11 @@
  * limitations under the License.
  */
 
-#include <geode/GeodeCppCache.hpp>
-
 using namespace apache::geode::client;
 using namespace test;
 
 class TallyWriter;
 
-typedef std::shared_ptr<TallyWriter> TallyWriterPtr;
-
 class TallyWriter : virtual public CacheWriter {
  private:
   int m_creates;
@@ -38,9 +34,9 @@ class TallyWriter : virtual public CacheWriter {
   bool isWriterInvoke;
   bool isCallbackCalled;
   bool isWriterfailed;
-  CacheableKeyPtr m_lastKey;
-  CacheablePtr m_lastValue;
-  CacheableKeyPtr m_callbackArg;
+  std::shared_ptr<CacheableKey> m_lastKey;
+  std::shared_ptr<Cacheable> m_lastValue;
+  std::shared_ptr<CacheableKey> m_callbackArg;
 
  public:
   TallyWriter()
@@ -93,7 +89,7 @@ class TallyWriter : virtual public CacheWriter {
     return !isWriterfailed;
   }
 
-  virtual void close(const RegionPtr& region) { LOG("TallyWriter::close"); }
+  virtual void close(const std::shared_ptr<Region>& region) { LOG("TallyWriter::close"); }
 
   int expectCreates(int expected) {
     int tries = 0;
@@ -119,7 +115,7 @@ class TallyWriter : virtual public CacheWriter {
   int getInvalidates() { return m_invalidates; }
   int getDestroys() { return m_destroys; }
   void setWriterFailed() { isWriterfailed = true; }
-  void setCallBackArg(const CacheableKeyPtr& callbackArg) {
+  void setCallBackArg(const std::shared_ptr<CacheableKey>& callbackArg) {
     m_callbackArg = callbackArg;
   }
   void resetWriterInvokation() {
@@ -128,9 +124,9 @@ class TallyWriter : virtual public CacheWriter {
   }
   bool isWriterInvoked() { return isWriterInvoke; }
   bool isCallBackArgCalled() { return isCallbackCalled; }
-  CacheableKeyPtr getLastKey() { return m_lastKey; }
+  std::shared_ptr<CacheableKey> getLastKey() { return m_lastKey; }
 
-  CacheablePtr getLastValue() { return m_lastValue; }
+  std::shared_ptr<Cacheable> getLastValue() { return m_lastValue; }
 
   void showTallies() {
     char buf[1024];
diff --git a/cppcache/integration-test/ThinClientCQ.hpp b/cppcache/integration-test/ThinClientCQ.hpp
index 027eb1a5..11bf9c95 100644
--- a/cppcache/integration-test/ThinClientCQ.hpp
+++ b/cppcache/integration-test/ThinClientCQ.hpp
@@ -40,7 +40,7 @@ const char* locatorsG =
 void createRegionForCQ(const char* name, bool ackMode,
                        bool clientNotificationEnabled = false,
                        int redundancyLevel = 0,
-                       const CacheListenerPtr& listener = nullptr,
+                       const std::shared_ptr<CacheListener>& listener = nullptr,
                        bool caching = true) {
   // Use region name as pool name to avoid recreating pools with the same name.
   getHelper()->createPoolWithLocators(name, locatorsG,
@@ -49,12 +49,11 @@ void createRegionForCQ(const char* name, bool ackMode,
   createRegionAndAttachPool(name, ackMode, name, caching);
 }
 
-void createRegionForCQMU(const char* name, bool ackMode,
-                         bool clientNotificationEnabled = false,
-                         int redundancyLevel = 0,
-                         const CacheListenerPtr& listener = nullptr,
-                         bool caching = true,
-                         bool poolIsInMultiuserMode = false) {
+void createRegionForCQMU(
+    const char* name, bool ackMode, bool clientNotificationEnabled = false,
+    int redundancyLevel = 0,
+    const std::shared_ptr<CacheListener>& listener = nullptr,
+    bool caching = true, bool poolIsInMultiuserMode = false) {
   // Use region name as pool name to avoid recreating pools with the same name.
   // TODO:
   // getHelper()->createPoolWithLocators( name, locatorsG,
diff --git a/cppcache/integration-test/ThinClientCallbackArg.hpp b/cppcache/integration-test/ThinClientCallbackArg.hpp
index f1f3823a..1c130f8c 100644
--- a/cppcache/integration-test/ThinClientCallbackArg.hpp
+++ b/cppcache/integration-test/ThinClientCallbackArg.hpp
@@ -43,26 +43,28 @@ static int numberOfLocators = 0;
 const char* locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, numberOfLocators);
 const char* poolName = "__TESTPOOL1_";
-TallyListenerPtr regListener;
-TallyWriterPtr regWriter;
+std::shared_ptr<TallyListener> regListener;
+std::shared_ptr<TallyWriter> regWriter;
 
 #include "LocatorHelper.hpp"
 
-void setCacheListener(const char* regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName,
+                      std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
-void setCacheWriter(const char* regName, TallyWriterPtr regWriter) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheWriter(const char* regName,
+                    std::shared_ptr<TallyWriter> regWriter) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheWriter(regWriter);
 }
 
 void createClientPooledLocatorRegion() {
   initClient(true);
-  CacheableKeyPtr key0 = CacheableKey::create(keys[0]);
+  auto key0 = CacheableKey::create(keys[0]);
   LOG("Creating region in CLIENT , no-ack, cacheing enable, with-listener and "
       "writer");
   createPooledRegion(regionNames[0], false, locatorsG, poolName, true,
@@ -73,7 +75,7 @@ void createClientPooledLocatorRegion() {
   setCacheListener(regionNames[0], regListener);
   regWriter->setCallBackArg(key0);
   regListener->setCallBackArg(key0);
-  RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+  auto regPtr0 = getHelper()->getRegion(regionNames[0]);
   regPtr0->registerAllKeys();
 }
 void validateLocalListenerWriterData() {
@@ -111,7 +113,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, doOperations)
   {
-    CacheableKeyPtr key0 = CacheableKey::create(keys[0]);
+    auto key0 = CacheableKey::create(keys[0]);
     LOG("do entry operation from client 1");
     RegionOperations region(regionNames[0]);
     region.putOp(5, key0);
diff --git a/cppcache/integration-test/ThinClientDistOps.hpp b/cppcache/integration-test/ThinClientDistOps.hpp
index 2cdc986f..90895b12 100644
--- a/cppcache/integration-test/ThinClientDistOps.hpp
+++ b/cppcache/integration-test/ThinClientDistOps.hpp
@@ -27,7 +27,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "testobject/PdxType.hpp"
@@ -68,7 +67,7 @@ END_TASK_DEFINITION
 
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (g_isGridClient) {
       config->insert("grid-client", "true");
     }
@@ -109,10 +108,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (noKey == false) {  // need to find the key!
@@ -204,9 +203,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
-      getHelper()->createRegion(name, ackMode, cachingEnable, nullptr,
-                                endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, cachingEnable, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -217,7 +215,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -231,7 +229,7 @@ void createPooledRegionSticky(const char* name, bool ackMode,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionSticky(
+  auto regPtr = getHelper()->createPooledRegionSticky(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -244,10 +242,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -264,7 +262,7 @@ void createEntry(const char* name, const char* key, const char* value) {
 }
 
 void createAndVerifyEntry(const char* name) {
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   /*1. create new entry with long key and long value */
@@ -296,7 +294,7 @@ void createAndVerifyEntry(const char* name) {
 
   /*3.create new with entry nullptr key and nullptr value.
    * IllegalArgumentException thrown*/
-  CacheableInt32Ptr x;
+  std::shared_ptr<CacheableInt32> x;
   try {
     regPtr->create(x, 1);
     LOG("Entry with null key and value created successfully");
@@ -319,7 +317,7 @@ void createAndVerifyEntry(const char* name) {
   // serializationRegistry->addPdxType(PdxTests::PdxType::createDeserializable);
   auto keyObject1 = std::make_shared<PdxTests::PdxType>();
   regPtr->create(keyObject1, x);
-  CacheablePtr retVal = regPtr->get(keyObject1);
+  auto retVal = regPtr->get(keyObject1);
   ASSERT(retVal == x, "retVal and x should match.");
 
   /*6.create new with entry userobject cantain all cacheable type ( like
@@ -348,7 +346,7 @@ void createAndVerifyEntry(const char* name) {
    * string value*/
   auto keyObject3 = std::make_shared<PdxTests::PdxType>();
   regPtr->create(keyObject3, "testString");
-  CacheablePtr strVal = regPtr->get(keyObject3);
+  auto strVal = regPtr->get(keyObject3);
   ASSERT(strcmp(strVal->toString()->asChar(), "testString") == 0,
          "strVal should be testString.");
 
@@ -360,7 +358,7 @@ void createAndVerifyEntry(const char* name) {
   auto keyObject4 = std::make_shared<PdxTests::PdxType>();
   auto valObject = std::make_shared<PdxTests::PdxType>();
   regPtr->create(keyObject4, valObject);
-  PdxTests::PdxTypePtr objVal =
+  auto objVal =
       std::dynamic_pointer_cast<PdxTests::PdxType>(regPtr->get(keyObject4));
   ASSERT(valObject == objVal, "valObject and objVal should match.");
 
@@ -399,9 +397,9 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
   sprintf(message, "Creating entry -- key: %s  value: %s in region %s\n", key,
           value, name);
   LOG(message);
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->create(keyPtr, valPtr);
   try {
     regPtr->create(keyPtr, valPtr);
@@ -422,10 +420,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -446,9 +444,9 @@ void doGetAgain(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "get  region name%s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -478,9 +476,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   fflush(stdout);
   static int count = 0;
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -558,11 +556,10 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, CreatePoolForUpdateLocatorList)
   {
     /*
-    PoolPtr  createPool(const char* poolName, const char* locators, const char*
-    serverGroup,
-                  const char* servers = nullptr, int redundancy = 0, bool
-    clientNotification = false, int subscriptionAckInterval = -1,
-                  int connections = -1, int loadConditioningInterval = - 1, bool
+    std::shared_ptr<Pool>  createPool(const char* poolName, const char*
+    locators, const char* serverGroup, const char* servers = nullptr, int
+    redundancy = 0, bool clientNotification = false, int subscriptionAckInterval
+    = -1, int connections = -1, int loadConditioningInterval = - 1, bool
     isMultiuserMode = false, int updateLocatorListInterval = 5000 )
     */
     initClient(true);
@@ -575,11 +572,10 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, CreatePoolForDontUpdateLocatorList)
   {
     /*
-    PoolPtr  createPool(const char* poolName, const char* locators, const char*
-    serverGroup,
-                  const char* servers = nullptr, int redundancy = 0, bool
-    clientNotification = false, int subscriptionAckInterval = -1,
-                  int connections = -1, int loadConditioningInterval = - 1, bool
+    std::shared_ptr<Pool>  createPool(const char* poolName, const char*
+    locators, const char* serverGroup, const char* servers = nullptr, int
+    redundancy = 0, bool clientNotification = false, int subscriptionAckInterval
+    = -1, int connections = -1, int loadConditioningInterval = - 1, bool
     isMultiuserMode = false, int updateLocatorListInterval = 5000 )
     */
     initClient(true);
@@ -594,8 +590,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, VerifyUpdateLocatorListThread)
     int sleepSeconds = 60;
     dunit::sleep(sleepSeconds * 1000);
 
-    PoolPtr pptr =
-        getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
+    auto pptr = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
     int updateIntervalSeconds = pptr->getUpdateLocatorListInterval().count() / 1000;
 
     int numLocatorListUpdates =
@@ -698,8 +693,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepFive)
   {
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     auto vec0 = reg0->serverKeys();
     auto vec1 = reg1->serverKeys();
     ASSERT(vec0.size() == 2, "Should have 2 keys in first region.");
@@ -747,10 +742,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool)
   {
     createPooledRegion(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_", false,
                        false);
-    RegionPtr reg = getHelper()->getRegion(regionNames[2]);
+    auto reg = getHelper()->getRegion(regionNames[2]);
     LOG("REGION Created with Caching Enabled false");
-    CacheableKeyPtr keyPtr = createKey(CREATE_TWICE_KEY);
-    CacheableStringPtr valPtr = CacheableString::create(CREATE_TWICE_VALUE);
+    auto keyPtr = createKey(CREATE_TWICE_KEY);
+    auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
     try {
       reg->create(keyPtr, valPtr);
       char message[200];
@@ -775,17 +770,16 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool_Sticky)
   {
     createPooledRegionSticky(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_",
                              false, false);
-    RegionPtr reg = getHelper()->getRegion(regionNames[2]);
+    auto reg = getHelper()->getRegion(regionNames[2]);
     LOG("REGION Created with Caching Enabled false");
-    CacheableKeyPtr keyPtr = createKey(CREATE_TWICE_KEY);
-    CacheableStringPtr valPtr = CacheableString::create(CREATE_TWICE_VALUE);
+    auto keyPtr = createKey(CREATE_TWICE_KEY);
+    auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
 
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     reg0->localInvalidate(createKey(keys[1]));
     reg1->localInvalidate(createKey(keys[3]));
-    PoolPtr pool =
-        getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
+    auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
     ASSERT(pool != nullptr, "Pool Should have been found");
     doNetsearch(regionNames[0], keys[1], nvals[1]);
     doNetsearch(regionNames[1], keys[3], nvals[3]);
diff --git a/cppcache/integration-test/ThinClientDistOps2.hpp b/cppcache/integration-test/ThinClientDistOps2.hpp
index fafa4610..193b3beb 100644
--- a/cppcache/integration-test/ThinClientDistOps2.hpp
+++ b/cppcache/integration-test/ThinClientDistOps2.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 
 #include <string>
@@ -152,11 +151,11 @@ END_TASK_DEFINITION
 // Test for getAll
 DUNIT_TASK_DEFINITION(CLIENT1, Client1GetAll)
   {
-    RegionPtr reg0 = getHelper()->getRegion(_regionNames[0]);
+    auto reg0 = getHelper()->getRegion(_regionNames[0]);
 
-    VectorOfCacheableKey keys0;
-    CacheableKeyPtr key0 = CacheableString::create(_keys[0]);
-    CacheableKeyPtr key1 = CacheableString::create(_keys[1]);
+    std::vector<std::shared_ptr<CacheableKey>> keys0;
+    auto key0 = CacheableString::create(_keys[0]);
+    auto key1 = CacheableString::create(_keys[1]);
 
     // re-create region with caching enabled
     reg0->localDestroyRegion();
@@ -186,11 +185,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1GetAll)
 
     // for second region invalidate only one key to have a partial get
     // from java server
-    RegionPtr reg1 = getHelper()->getRegion(_regionNames[1]);
-    CacheableKeyPtr key2 = CacheableString::create(_keys[2]);
-    CacheableKeyPtr key3 = CacheableString::create(_keys[3]);
+    auto reg1 = getHelper()->getRegion(_regionNames[1]);
+    auto key2 = CacheableString::create(_keys[2]);
+    auto key3 = CacheableString::create(_keys[3]);
     reg1->localInvalidate(key2);
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(key2);
     keys1.push_back(key3);
 
@@ -228,11 +227,11 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, Client1GetAll_Pool)
   {
     {
-      RegionPtr reg0 = getHelper()->getRegion(_regionNames[0]);
+      auto reg0 = getHelper()->getRegion(_regionNames[0]);
 
-      VectorOfCacheableKey keys0;
-      CacheableKeyPtr key0 = CacheableString::create(_keys[0]);
-      CacheableKeyPtr key1 = CacheableString::create(_keys[1]);
+      std::vector<std::shared_ptr<CacheableKey>> keys0;
+      auto key0 = CacheableString::create(_keys[0]);
+      auto key1 = CacheableString::create(_keys[1]);
 
       getHelper()->createRegionAndAttachPool(_regionNames[0], USE_ACK,
                                              poolName);
@@ -261,11 +260,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1GetAll_Pool)
     {
       // for second region invalidate only one key to have a partial get
       // from java server
-      RegionPtr reg1 = getHelper()->getRegion(_regionNames[1]);
-      CacheableKeyPtr key2 = CacheableString::create(_keys[2]);
-      CacheableKeyPtr key3 = CacheableString::create(_keys[3]);
+      auto reg1 = getHelper()->getRegion(_regionNames[1]);
+      auto key2 = CacheableString::create(_keys[2]);
+      auto key3 = CacheableString::create(_keys[3]);
       reg1->localInvalidate(key2);
-      VectorOfCacheableKey keys1;
+      std::vector<std::shared_ptr<CacheableKey>> keys1;
       keys1.push_back(key2);
       keys1.push_back(key3);
 
diff --git a/cppcache/integration-test/ThinClientDurable.hpp b/cppcache/integration-test/ThinClientDurable.hpp
index cbb9f166..59e86bbb 100644
--- a/cppcache/integration-test/ThinClientDurable.hpp
+++ b/cppcache/integration-test/ThinClientDurable.hpp
@@ -60,8 +60,8 @@ class OperMonitor : public CacheListener {
   void check(const EntryEvent& event) {
     m_ops++;
 
-    CacheableKeyPtr key = event.getKey();
-    CacheableInt32Ptr value = nullptr;
+    auto key = event.getKey();
+    std::shared_ptr<CacheableInt32> value = nullptr;
     try {
       value = std::dynamic_pointer_cast<CacheableInt32>(event.getNewValue());
     } catch (Exception&) {
@@ -137,19 +137,12 @@ class OperMonitor : public CacheListener {
   virtual void afterRegionInvalidate(const RegionEvent& event){};
   virtual void afterRegionDestroy(const RegionEvent& event){};
 };
-typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
-void setCacheListener(const char* regName, OperMonitorPtr monitor) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName, std::shared_ptr<OperMonitor> monitor) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(monitor);
-}
-
-OperMonitorPtr mon1C1 = nullptr;
-OperMonitorPtr mon2C1 = nullptr;
-
-OperMonitorPtr mon1C2 = nullptr;
-OperMonitorPtr mon2C2 = nullptr;
+}std::shared_ptr<OperMonitor> mon1C1 = nullptr;std::shared_ptr<OperMonitor> mon2C1=nullptr;std::shared_ptr<OperMonitor> mon1C2 = nullptr;std::shared_ptr<OperMonitor> mon2C2=nullptr;
 
 /* Total 10 Keys , alternate durable and non-durable */
 const char* mixKeys[] = {"Key-1", "D-Key-1", "L-Key", "LD-Key"};
@@ -159,8 +152,8 @@ const char* testRegex[] = {"D-Key-.*", "Key-.*"};
 #include "ThinClientTasks_C2S2.hpp"
 
 void initClientCache(int durableIdx, int redundancy,
-                     std::chrono::seconds durableTimeout, OperMonitorPtr& mon1,
-                     OperMonitorPtr& mon2, int sleepDuration = 0) {
+                     std::chrono::seconds durableTimeout, std::shared_ptr<OperMonitor>& mon1,
+                     std::shared_ptr<OperMonitor>& mon2, int sleepDuration = 0) {
   // Sleep before starting , Used for Timeout testing.
   if (sleepDuration) SLEEP(sleepDuration);
 
@@ -171,8 +164,8 @@ void initClientCache(int durableIdx, int redundancy,
 
   getHelper()->cachePtr->readyForEvents();
 
-  RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-  RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+ auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+ auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
   // Register Regex in both region.
   regPtr0->registerRegex(testRegex[0], true);
@@ -181,18 +174,18 @@ void initClientCache(int durableIdx, int redundancy,
   regPtr1->registerRegex(testRegex[1], false);
 
   // Register List in both regions
-  VectorOfCacheableKey v;
-  CacheableKeyPtr ldkey = CacheableKey::create(mixKeys[3]);
+  std::vector<std::shared_ptr<CacheableKey>>  v;
+ auto ldkey = CacheableKey::create(mixKeys[3]);
   v.push_back(ldkey);
   regPtr0->registerKeys(v, true);
   regPtr1->registerKeys(v, true);
   v.clear();
-  CacheableKeyPtr lkey = CacheableKey::create(mixKeys[2]);
-  v.push_back(lkey);
-  regPtr0->registerKeys(v);
-  regPtr1->registerKeys(v);
+ auto lkey = CacheableKey::create(mixKeys[2]);
+ v.push_back(lkey);
+ regPtr0->registerKeys(v);
+ regPtr1->registerKeys(v);
 
-  LOG("Clnt1Init complete.");
+ LOG("Clnt1Init complete.");
 }
 
 void feederUpdate(int value, int ignoreR2 = false) {
diff --git a/cppcache/integration-test/ThinClientDurableConnect.hpp b/cppcache/integration-test/ThinClientDurableConnect.hpp
index 878bca35..44dc7d1d 100644
--- a/cppcache/integration-test/ThinClientDurableConnect.hpp
+++ b/cppcache/integration-test/ThinClientDurableConnect.hpp
@@ -165,7 +165,7 @@ DUNIT_TASK_DEFINITION(CLIENT, ClntUp)
     initClientAndRegion(1, 0);
     getHelper()->cachePtr->readyForEvents();
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(true);
 
     LOG("Clnt1Init complete.");
@@ -177,7 +177,7 @@ DUNIT_TASK_DEFINITION(CLIENT, ClntUpNonHA)
     initClientAndRegion(0, 0);
     getHelper()->cachePtr->readyForEvents();
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(true);
 
     LOG("Clnt1Init complete.");
diff --git a/cppcache/integration-test/ThinClientDurableFailover.hpp b/cppcache/integration-test/ThinClientDurableFailover.hpp
index e91748ad..9188d4f3 100644
--- a/cppcache/integration-test/ThinClientDurableFailover.hpp
+++ b/cppcache/integration-test/ThinClientDurableFailover.hpp
@@ -58,8 +58,8 @@ class OperMonitor : public CacheListener {
   void check(const EntryEvent& event) {
     m_ops++;
 
-    CacheableKeyPtr key = event.getKey();
-    CacheableInt32Ptr value = nullptr;
+    auto key = event.getKey();
+    std::shared_ptr<CacheableInt32> value = nullptr;
     try {
       value = std::dynamic_pointer_cast<CacheableInt32>(event.getNewValue());
     } catch (Exception&) {
@@ -132,16 +132,12 @@ class OperMonitor : public CacheListener {
   virtual void afterRegionInvalidate(const RegionEvent& event){};
   virtual void afterRegionDestroy(const RegionEvent& event){};
 };
-typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
-void setCacheListener(const char* regName, OperMonitorPtr monitor) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName, std::shared_ptr<OperMonitor> monitor) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(monitor);
-}
-
-OperMonitorPtr mon1 = nullptr;
-OperMonitorPtr mon2 = nullptr;
+}std::shared_ptr<OperMonitor> mon1 = nullptr;std::shared_ptr<OperMonitor> mon2=nullptr;
 
 #include "ThinClientDurableInit.hpp"
 #include "ThinClientTasks_C2S2.hpp"
@@ -150,7 +146,7 @@ OperMonitorPtr mon2 = nullptr;
 const char* mixKeys[] = {"Key-1", "D-Key-1", "L-Key", "LD-Key"};
 const char* testRegex[] = {"D-Key-.*", "Key-.*"};
 
-void initClientCache(int redundancy, int durableTimeout, OperMonitorPtr& mon,
+void initClientCache(int redundancy, int durableTimeout, std::shared_ptr<OperMonitor>& mon,
                      int sleepDuration = 0, int durableIdx = 0) {
   if (sleepDuration) SLEEP(sleepDuration);
 
@@ -169,7 +165,7 @@ void initClientCache(int redundancy, int durableTimeout, OperMonitorPtr& mon,
 
   getHelper()->cachePtr->readyForEvents();
 
-  RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+ auto regPtr0 = getHelper()->getRegion(regionNames[0]);
 
   // for R =1 it will get a redundancy error
   try {
diff --git a/cppcache/integration-test/ThinClientDurableInit.hpp b/cppcache/integration-test/ThinClientDurableInit.hpp
index 9f3c22af..f57c856c 100644
--- a/cppcache/integration-test/ThinClientDurableInit.hpp
+++ b/cppcache/integration-test/ThinClientDurableInit.hpp
@@ -41,7 +41,7 @@ void initClientAndRegion(
     std::chrono::seconds redundancyMonitorInterval =
         std::chrono::seconds::zero(),
     std::chrono::seconds durableClientTimeout = std::chrono::seconds(60)) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   if (ClientIdx < 2) {
     pp->insert("durable-client-id", durableIds[ClientIdx]);
     pp->insert("durable-timeout", durableClientTimeout);
@@ -59,7 +59,7 @@ void initClientAndTwoRegions(int ClientIdx, int redundancy,
                              std::chrono::seconds durableClientTimeout,
                              const char* conflation = nullptr,
                              const char* rNames[] = regionNames) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   pp->insert("durable-client-id", durableIds[ClientIdx]);
   pp->insert("durable-timeout", durableClientTimeout);
   if (conflation) {
@@ -75,7 +75,7 @@ void initClientAndTwoRegions(int ClientIdx, int redundancy,
 void initClientAndTwoRegionsAndTwoPools(
     int ClientIdx, int redundancy, std::chrono::seconds durableClientTimeout,
     const char* conflation = nullptr, const char* rNames[] = regionNames) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   pp->insert("durable-client-id", durableIds[ClientIdx]);
   pp->insert("durable-timeout", durableClientTimeout);
   if (conflation) {
@@ -95,12 +95,12 @@ void initClientAndTwoRegionsAndTwoPools(
     LOG("Exception occured while sending readyForEvents");
   }*/
 
-  RegionPtr regPtr1 = getHelper()->getRegion(rNames[1]);
+  auto regPtr1 = getHelper()->getRegion(rNames[1]);
   regPtr1->registerAllKeys(true);
   getHelper()->createPoolWithLocators("__TESTPOOL1_", locatorsG, true,
                                       redundancy, std::chrono::seconds(1));
   createRegionAndAttachPool(rNames[0], USE_ACK, "__TESTPOOL1_", true);
-  RegionPtr regPtr0 = getHelper()->getRegion(rNames[0]);
+  auto regPtr0 = getHelper()->getRegion(rNames[0]);
   regPtr0->registerAllKeys(true);
 
   LOG("Calling readyForEvents:");
diff --git a/cppcache/integration-test/ThinClientDurableInterest.hpp b/cppcache/integration-test/ThinClientDurableInterest.hpp
index 5b684cfd..e5fab230 100644
--- a/cppcache/integration-test/ThinClientDurableInterest.hpp
+++ b/cppcache/integration-test/ThinClientDurableInterest.hpp
@@ -52,7 +52,7 @@ class OperMonitor : public CacheListener {
   void check(const EntryEvent& event) {
     m_ops++;
 
-    CacheableKeyPtr key = event.getKey();
+    auto key = event.getKey();
     auto value = std::dynamic_pointer_cast<CacheableInt32>(event.getNewValue());
 
     char buf[256];
@@ -114,23 +114,21 @@ class OperMonitor : public CacheListener {
     LOG("afterRegionLive called.");
   }
 };
-typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
 const char* mixKeys[] = {"Key-1", "D-Key-1", "Key-2", "D-Key-2"};
-const char* testRegex[] = {"D-Key-.*", "Key-.*"};
-OperMonitorPtr mon1, mon2;
+const char* testRegex[] = {"D-Key-.*", "Key-.*"}; std::shared_ptr<OperMonitor> mon1, mon2;
 
 #include "ThinClientDurableInit.hpp"
 #include "ThinClientTasks_C2S2.hpp"
 
-void setCacheListener(const char* regName, OperMonitorPtr monitor) {
+void setCacheListener(const char* regName, std::shared_ptr<OperMonitor> monitor) {
   LOGINFO("setCacheListener to %s ", regName);
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(monitor);
 }
 
-void initClientWithIntrest(int ClientIdx, OperMonitorPtr& mon) {
+void initClientWithIntrest(int ClientIdx, std::shared_ptr<OperMonitor>& mon) {
   if (mon == nullptr) {
     mon = std::make_shared<OperMonitor>();
   }
@@ -145,13 +143,13 @@ void initClientWithIntrest(int ClientIdx, OperMonitorPtr& mon) {
     LOG("Exception occured while sending readyForEvents");
   }
 
-  RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+ auto regPtr0 = getHelper()->getRegion(regionNames[0]);
   regPtr0->registerRegex(testRegex[0], true);
   regPtr0->registerRegex(testRegex[1], false);
 }
 
-void initClientWithIntrest2(int ClientIdx, OperMonitorPtr& monitor1,
-                            OperMonitorPtr& monitor2) {
+void initClientWithIntrest2(int ClientIdx, std::shared_ptr<OperMonitor>& monitor1,
+                            std::shared_ptr<OperMonitor>& monitor2) {
   initClientAndTwoRegionsAndTwoPools(0, ClientIdx, std::chrono::seconds(60));
   if (monitor1 == nullptr) {
     monitor1 = std::make_shared<OperMonitor>(1);
@@ -163,7 +161,7 @@ void initClientWithIntrest2(int ClientIdx, OperMonitorPtr& monitor1,
   setCacheListener(regionNames[1], monitor2);
 }
 
-void initClientNoIntrest(int ClientIdx, OperMonitorPtr mon) {
+void initClientNoIntrest(int ClientIdx, std::shared_ptr<OperMonitor> mon) {
   initClientAndRegion(0, ClientIdx);
 
   setCacheListener(regionNames[0], mon);
@@ -171,13 +169,13 @@ void initClientNoIntrest(int ClientIdx, OperMonitorPtr mon) {
   getHelper()->cachePtr->readyForEvents();
 }
 
-void initClientRemoveIntrest(int ClientIdx, OperMonitorPtr mon) {
+void initClientRemoveIntrest(int ClientIdx, std::shared_ptr<OperMonitor> mon) {
   initClientAndRegion(0, ClientIdx);
   setCacheListener(regionNames[0], mon);
   getHelper()->cachePtr->readyForEvents();
 
   // Only unregister durable Intrest.
-  RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+ auto regPtr0 = getHelper()->getRegion(regionNames[0]);
   regPtr0->registerRegex(testRegex[0], true);
   regPtr0->unregisterRegex(testRegex[0]);
 }
diff --git a/cppcache/integration-test/ThinClientDurableReconnect.hpp b/cppcache/integration-test/ThinClientDurableReconnect.hpp
index d1cbb95c..8ee384ce 100644
--- a/cppcache/integration-test/ThinClientDurableReconnect.hpp
+++ b/cppcache/integration-test/ThinClientDurableReconnect.hpp
@@ -59,27 +59,24 @@ class OperMonitor : public CacheListener {
       LOG("Duplicate Recieved");
     }
   }
-  virtual void close(const RegionPtr& region) {
+  virtual void close(const std::shared_ptr<Region>& region) {
     m_close = true;
     LOG("Listener Close Called");
   }
 };
-typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
-void setCacheListener(const char* regName, OperMonitorPtr monitor) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName, std::shared_ptr<OperMonitor> monitor) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(monitor);
-}
-
-OperMonitorPtr mon1 = nullptr;
+}std::shared_ptr<OperMonitor> mon1 = nullptr;
 
 const char* mixKeys[] = {"D-Key-1"};
 
 #include "ThinClientDurableInit.hpp"
 #include "ThinClientTasks_C2S2.hpp"
 
-void initClientCache(int redundancy, OperMonitorPtr& mon) {
+void initClientCache(int redundancy, std::shared_ptr<OperMonitor>& mon) {
   initClientAndRegion(redundancy, 0, std::chrono::seconds(60000),
                       std::chrono::seconds(1), std::chrono::seconds(300));
 
@@ -90,7 +87,7 @@ void initClientCache(int redundancy, OperMonitorPtr& mon) {
   setCacheListener(regionNames[0], mon);
 
   getHelper()->cachePtr->readyForEvents();
-  RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+ auto regPtr0 = getHelper()->getRegion(regionNames[0]);
   regPtr0->registerAllKeys(true);
 }
 
diff --git a/cppcache/integration-test/ThinClientFailover.hpp b/cppcache/integration-test/ThinClientFailover.hpp
index 8b91ebc7..49f1e7dc 100644
--- a/cppcache/integration-test/ThinClientFailover.hpp
+++ b/cppcache/integration-test/ThinClientFailover.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/High_Res_Timer.h>
 
 #include <ace/OS.h>
@@ -84,11 +83,11 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   LOG("_verifyEntry =================");
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   if (noKey == false) {  // need to find the key!
     ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -156,8 +155,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -168,7 +167,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -182,7 +181,7 @@ void createPooledRegionSticky(const char* name, bool ackMode,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionSticky(
+  auto regPtr = getHelper()->createPooledRegionSticky(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -195,10 +194,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -220,10 +219,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -245,9 +244,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
diff --git a/cppcache/integration-test/ThinClientFailover2.hpp b/cppcache/integration-test/ThinClientFailover2.hpp
index ba5c95d9..a57b4c9f 100644
--- a/cppcache/integration-test/ThinClientFailover2.hpp
+++ b/cppcache/integration-test/ThinClientFailover2.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/High_Res_Timer.h>
 
 #include <ace/OS.h>
@@ -87,10 +86,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   if (noKey == false) {  // need to find the key!
     ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -178,8 +177,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -190,7 +189,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -202,10 +201,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -227,10 +226,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -252,9 +251,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -288,9 +287,9 @@ void invalidateEntry(const char* name, const char* key) {
   fprintf(stdout, "Invalidating entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Invalidate entry, verify entry is invalidated
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -309,9 +308,9 @@ void destroyEntry(const char* name, const char* key) {
   fprintf(stdout, "Destroying entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Destroy entry, verify entry is destroyed
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -325,7 +324,7 @@ void destroyEntry(const char* name, const char* key) {
 
 void destroyRegion(const char* name) {
   LOG("destroyRegion() entered.");
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->destroyRegion();
   LOG("Region destroyed.");
 }
@@ -357,7 +356,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepOne_Pool_Locator)
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TEST_POOL1__",
                        true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
@@ -375,7 +374,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pool_Locator)
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TEST_POOL1__",
                        true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
@@ -420,8 +419,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepFive)
   {
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     auto vec0 = reg0->serverKeys();
     auto vec1 = reg1->serverKeys();
     ASSERT(vec0.size() == 3, "Should have 3 keys in first region.");
diff --git a/cppcache/integration-test/ThinClientFailover3.hpp b/cppcache/integration-test/ThinClientFailover3.hpp
index 7506812c..11ba8a24 100644
--- a/cppcache/integration-test/ThinClientFailover3.hpp
+++ b/cppcache/integration-test/ThinClientFailover3.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -85,10 +84,10 @@ void _verifyEntry(const char *name, const char *key, const char *val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   if (noKey == false) {  // need to find the key!
     ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -157,7 +156,7 @@ void createPooledRegion(const char *name, bool ackMode, const char *locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -169,10 +168,10 @@ void createEntry(const char *name, const char *key, const char *value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -194,10 +193,10 @@ void updateEntry(const char *name, const char *key, const char *value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -217,9 +216,9 @@ void doNetsearch(const char *name, const char *key, const char *value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
diff --git a/cppcache/integration-test/ThinClientFailoverInterest.hpp b/cppcache/integration-test/ThinClientFailoverInterest.hpp
index ab7ecfa9..323a1750 100644
--- a/cppcache/integration-test/ThinClientFailoverInterest.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterest.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -86,10 +85,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -184,8 +183,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, not a mirror, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -196,7 +195,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -208,10 +207,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -233,10 +232,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -258,9 +257,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -324,13 +323,13 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pool_Locator)
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TEST_POOL1__",
                        true);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr0);
     keys1.push_back(keyPtr2);
     regPtr0->registerKeys(keys0);
diff --git a/cppcache/integration-test/ThinClientFailoverInterest2.hpp b/cppcache/integration-test/ThinClientFailoverInterest2.hpp
index e915c300..1c28de1a 100644
--- a/cppcache/integration-test/ThinClientFailoverInterest2.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterest2.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -85,10 +84,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -183,8 +182,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -195,7 +194,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -207,10 +206,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -232,10 +231,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -257,9 +256,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -324,8 +323,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pool_Locator)
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TEST_POOL1__",
                        true);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->registerAllKeys();
     regPtr1->registerAllKeys();
 
@@ -390,8 +389,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, StepSeven)
   {
     // Client two unregister all keys
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->unregisterAllKeys();
     regPtr1->unregisterAllKeys();
 
diff --git a/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp b/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
index c09edcf9..f22b9d49 100644
--- a/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -90,10 +89,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -187,8 +186,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   LOGINFO("Creating region --  %s  ackMode is %d", name, ackMode);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -198,10 +197,10 @@ void createEntry(const char* name, const char* key, const char* value) {
   LOGINFO("Creating entry -- key: %s  value: %s in region %s", key, value,
           name);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -222,10 +221,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
   LOGINFO("Updating entry -- key: %s  value: %s in region %s", key, value,
           name);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -244,9 +243,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   LOGINFO("Netsearching for entry -- key: %s  expecting value: %s in region %s",
           key, value, name);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   LOGINFO("netsearch  region %s", regPtr->getName());
   ASSERT(regPtr != nullptr, "Region not found.");
 
@@ -315,8 +314,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, InitializeClient2)
     getHelper()->createPooledRegion(regionNames[1], NO_ACK, locatorsG,
                                     "__TEST_POOL1__", true, true);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     // create a local entry to check for no change after register interest
     createEntry(regionNames[0], keys[1], nvals[1]);
     regPtr0->registerAllKeys(false, true);
@@ -337,8 +336,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, InitializeClient2Regex)
     createRegion(regionNames[0], USE_ACK, locatorsG, true);
     createRegion(regionNames[1], NO_ACK, locatorsG, true);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     // create a local entry to check for no change after register interest
     createEntry(regionNames[0], keys[1], nvals[1]);
     regPtr0->registerRegex(".*", false, true);
@@ -359,7 +358,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyClient1)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(false, false);
 
     ASSERT(regPtr0->size() == 1, "Expected one entry in region");
@@ -368,7 +367,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, VerifyClient1)
            "Expected region to not contain the value");
 
     // check the same for registerRegex(".*")
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->registerRegex(".*", false, false);
 
     ASSERT(regPtr1->size() == 1, "Expected one entry in region");
@@ -387,8 +386,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, VerifyClient2)
   {
     // Client two should recieve all entries
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     ASSERT(regPtr0->size() == 2, "Expected two entries in region");
     ASSERT(regPtr1->size() == 2, "Expected two entries in region");
@@ -446,8 +445,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, Client2UnregisterAllKeys)
   {
     // Client two unregister all keys
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->unregisterAllKeys();
     regPtr1->unregisterAllKeys();
 
diff --git a/cppcache/integration-test/ThinClientFailoverRegex.hpp b/cppcache/integration-test/ThinClientFailoverRegex.hpp
index 7b713cce..7c670705 100644
--- a/cppcache/integration-test/ThinClientFailoverRegex.hpp
+++ b/cppcache/integration-test/ThinClientFailoverRegex.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -86,10 +85,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -184,8 +183,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -196,7 +195,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -208,10 +207,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -233,10 +232,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -258,9 +257,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -330,14 +329,14 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pool_Locator)
 
     createEntry(regionNames[1], keys[1], nvals[1]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     /*
-      CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-      CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+     auto keyPtr0 = CacheableKey::create(keys[0]);
+     auto keyPtr2 = CacheableKey::create(keys[2]);
 
-      VectorOfCacheableKey keys0,keys1;
+      std::vector<std::shared_ptr<CacheableKey>>  keys0,keys1;
       keys0.push_back(keyPtr0);
       keys1.push_back(keyPtr2);
       regPtr0->registerKeys(keys0, nullptr);
@@ -356,7 +355,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     createEntry(regionNames[0], keys[0], vals[0]);
     createEntry(regionNames[1], keys[2], vals[2]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->registerRegex(regkeys[1], false);
 
     doNetsearch(
@@ -378,13 +377,13 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
 
     updateEntry(regionNames[1], keys[1], vals[1]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->unregisterRegex(regkeys[2]);
 
     /*
-      RegionPtr regPtr1 = getHelper()->getRegion( regionNames[1] );
-      CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
-      VectorOfCacheableKey keys2;
+     auto regPtr1 = getHelper()->getRegion( regionNames[1] );
+     auto keyPtr2 = CacheableKey::create(keys[2]);
+      std::vector<std::shared_ptr<CacheableKey>>  keys2;
       keys2.push_back(keyPtr2);
       regPtr1->unregisterKeys(keys2, nullptr);
       */
diff --git a/cppcache/integration-test/ThinClientGatewayTest.hpp b/cppcache/integration-test/ThinClientGatewayTest.hpp
index 5d607652..9d1d4864 100644
--- a/cppcache/integration-test/ThinClientGatewayTest.hpp
+++ b/cppcache/integration-test/ThinClientGatewayTest.hpp
@@ -34,7 +34,6 @@
 using namespace apache::geode::client;
 using namespace test;
 
-#include <geode/GeodeCppCache.hpp>
 #include <string>
 
 class MyListener : public CacheListener {
@@ -62,11 +61,9 @@ class MyListener : public CacheListener {
   int getNumEvents() { return m_events; }
 };
 
-typedef std::shared_ptr<MyListener> MyListenerPtr;
-
-void setCacheListener(const char* regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName, std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
@@ -101,31 +98,30 @@ DUNIT_TASK_DEFINITION(SERVER2, StartServer2)
     LOG("SERVER started");
   }
 END_TASK_DEFINITION
-
-MyListenerPtr reg1Listener1 = nullptr;
+std::shared_ptr<MyListener> reg1Listener1 = nullptr;
 
 DUNIT_TASK_DEFINITION(SERVER2, SetupClient2)
   {
     // CacheHelper ch = getHelper();
     reg1Listener1 = std::make_shared<MyListener>();
-    RegionPtr regPtr = createPooledRegion("exampleRegion", false, locHostPort2,
+   auto regPtr = createPooledRegion("exampleRegion", false, locHostPort2,
                                           "poolName", true, reg1Listener1);
-    regPtr->registerAllKeys();
+   regPtr->registerAllKeys();
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(SERVER1, SetupClient)
   {
     initClientWithPool(true, "poolName", locHostPort1, nullptr);
-    RegionPtr regPtr =
+   auto regPtr =
         createRegionAndAttachPool("exampleRegion", true, nullptr);
-    LOG(" region is created ");
-    for (int i = 0; i < 100; i++) {
-      LOG(" region is created put");
-      regPtr->put(i, i);
-    }
+   LOG(" region is created ");
+   for (int i = 0; i < 100; i++) {
+     LOG(" region is created put");
+     regPtr->put(i, i);
+   }
 
-    dunit::sleep(10000);
+   dunit::sleep(10000);
   }
 END_TASK_DEFINITION
 
diff --git a/cppcache/integration-test/ThinClientHeapLRU.hpp b/cppcache/integration-test/ThinClientHeapLRU.hpp
index 2020cdce..be72e616 100644
--- a/cppcache/integration-test/ThinClientHeapLRU.hpp
+++ b/cppcache/integration-test/ThinClientHeapLRU.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "BuiltinCacheableWrappers.hpp"
@@ -62,7 +61,7 @@ const bool NO_ACK = false;
 
 void initThinClientWithClientTypeAsCLIENT(const bool isthinClient) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr pp = Properties::create();
+    auto pp = Properties::create();
     pp->insert("heap-lru-limit", 1);
     pp->insert("heap-lru-delta", 10);
 
@@ -95,8 +94,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -108,7 +107,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -117,7 +116,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
 
 void createOnekEntries() {
   CacheableHelper::registerBuiltins();
-  RegionPtr dataReg = getHelper()->getRegion(regionNames[0]);
+  auto dataReg = getHelper()->getRegion(regionNames[0]);
   for (int i = 0; i < 2048; i++) {
     CacheableWrapper* tmpkey =
         CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableInt32);
@@ -136,7 +135,7 @@ void createOnekEntries() {
     //  delete tmpval;
   }
   dunit::sleep(10000);
-  VectorOfRegionEntry me;
+  std::vector<std::shared_ptr<RegionEntry>> me;
   dataReg->entries(me, false);
   LOG("Verifying size outside loop");
   char buf[1024];
diff --git a/cppcache/integration-test/ThinClientHelper.hpp b/cppcache/integration-test/ThinClientHelper.hpp
index 04be7439..1f2f2a3b 100644
--- a/cppcache/integration-test/ThinClientHelper.hpp
+++ b/cppcache/integration-test/ThinClientHelper.hpp
@@ -22,7 +22,6 @@
 
 #include <chrono>
 
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "testUtils.hpp"
@@ -49,12 +48,12 @@ using namespace unitTests;
 CacheHelper* cacheHelper = nullptr;
 
 void initGridClient(const bool isthinClient,
-                    const PropertiesPtr& configPtr = nullptr) {
+                    const std::shared_ptr<Properties>& configPtr = nullptr) {
   static bool s_isGridClient = true;
 
   s_isGridClient = !s_isGridClient;
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = configPtr;
+    auto config = configPtr;
     if (config == nullptr) {
       config = Properties::create();
     }
@@ -65,7 +64,7 @@ void initGridClient(const bool isthinClient,
 }
 
 void initClient(const bool isthinClient,
-                const PropertiesPtr& configPtr = nullptr) {
+                const std::shared_ptr<Properties>& configPtr = nullptr) {
   if (cacheHelper == nullptr) {
     cacheHelper = new CacheHelper(isthinClient, configPtr);
   }
@@ -74,7 +73,7 @@ void initClient(const bool isthinClient,
 
 void initClientWithPool(const bool isthinClient, const char* poolName,
                         const char* locators, const char* serverGroup,
-                        const PropertiesPtr& configPtr = nullptr,
+                        const std::shared_ptr<Properties>& configPtr = nullptr,
                         int redundancy = 0, bool clientNotification = false,
                         int subscriptionAckInterval = -1, int connections = -1,
                         int loadConditioningInterval = -1,
@@ -89,9 +88,10 @@ void initClientWithPool(const bool isthinClient, const char* poolName,
 }
 
 /* For HA Clients */
-void initClient(int redundancyLevel, const PropertiesPtr& configPtr = nullptr) {
+void initClient(int redundancyLevel,
+                const std::shared_ptr<Properties>& configPtr = nullptr) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = configPtr;
+    auto config = configPtr;
     if (config == nullptr) {
       config = Properties::create();
     }
@@ -101,12 +101,12 @@ void initClient(int redundancyLevel, const PropertiesPtr& configPtr = nullptr) {
 }
 
 void initGridClient(int redundancyLevel,
-                    const PropertiesPtr& configPtr = nullptr) {
+                    const std::shared_ptr<Properties>& configPtr = nullptr) {
   static bool s_isGridClient = true;
 
   s_isGridClient = !s_isGridClient;
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = configPtr;
+    auto config = configPtr;
     if (config == nullptr) {
       config = Properties::create();
     }
@@ -178,10 +178,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   if (noKey == false) {  // need to find the key!
     ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -285,10 +285,10 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
     free(buf);
   }
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -369,20 +369,20 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
 
 void createRegion(const char* name, bool ackMode,
                   bool clientNotificationEnabled = false,
-                  const CacheListenerPtr& listener = nullptr,
+                  const std::shared_ptr<CacheListener>& listener = nullptr,
                   bool caching = true) {
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, caching, listener,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, caching, listener,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
-RegionPtr createOverflowRegion(const char* name, bool ackMode, int lel = 0,
-                               bool clientNotificationEnabled = true,
-                               bool caching = true) {
+std::shared_ptr<Region> createOverflowRegion(
+    const char* name, bool ackMode, int lel = 0,
+    bool clientNotificationEnabled = true, bool caching = true) {
   std::string bdb_dir = "BDB";
   std::string bdb_dirEnv = "BDBEnv";
   AttributesFactory af;
@@ -390,7 +390,7 @@ RegionPtr createOverflowRegion(const char* name, bool ackMode, int lel = 0,
   af.setLruEntriesLimit(lel);
   af.setDiskPolicy(DiskPolicyType::OVERFLOWS);
 
-  PropertiesPtr sqLiteProps = Properties::create();
+  auto sqLiteProps = Properties::create();
   sqLiteProps->insert("PageSize", "65536");
   sqLiteProps->insert("MaxPageCount", "1073741823");
   std::string sqlite_dir =
@@ -399,19 +399,18 @@ RegionPtr createOverflowRegion(const char* name, bool ackMode, int lel = 0,
   sqLiteProps->insert("PersistenceDirectory", sqlite_dir.c_str());
   af.setPersistenceManager("SqLiteImpl", "createSqLiteInstance", sqLiteProps);
 
-  RegionAttributesPtr rattrsPtr = af.createRegionAttributes();
-  CachePtr cache = getHelper()->cachePtr;
+  std::shared_ptr<RegionAttributes> rattrsPtr = af.createRegionAttributes();
+  auto cache = getHelper()->cachePtr;
   CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheImpl->createRegion(name, rattrsPtr, regionPtr);
   return regionPtr;
 }
-
-RegionPtr createPooledRegion(const char* name, bool ackMode,
-                             const char* locators, const char* poolname,
-                             bool clientNotificationEnabled = false,
-                             const CacheListenerPtr& listener = nullptr,
-                             bool caching = true) {
+std::shared_ptr<Region> createPooledRegion(
+    const char* name, bool ackMode, const char* locators, const char* poolname,
+    bool clientNotificationEnabled = false,
+    const std::shared_ptr<CacheListener>& listener = nullptr,
+    bool caching = true) {
   LOG("createPooledRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
@@ -421,7 +420,7 @@ RegionPtr createPooledRegion(const char* name, bool ackMode,
   }
 
   // ack, caching
-  RegionPtr regPtr = getHelper()->createPooledRegion(
+  auto regPtr = getHelper()->createPooledRegion(
       name, ackMode, locators, poolname, caching, clientNotificationEnabled,
       std::chrono::seconds(0), std::chrono::seconds(0), std::chrono::seconds(0),
       std::chrono::seconds(0), 0, listener);
@@ -430,59 +429,56 @@ RegionPtr createPooledRegion(const char* name, bool ackMode,
   LOG("Region created.");
   return regPtr;
 }
-
-PoolPtr findPool(const char* poolName) {
-  LOG("findPool() entered.");
-  PoolPtr poolPtr = getHelper()->getCache()->getPoolManager().find(poolName);
-  ASSERT(poolPtr != nullptr, "Failed to find pool.");
-  return poolPtr;
-}
-PoolPtr createPool(const char* poolName, const char* locators,
-                   const char* serverGroup, int redundancy = 0,
-                   bool clientNotification = false,
-                   std::chrono::milliseconds subscriptionAckInterval =
-                       std::chrono::milliseconds::zero(),
-                   int connections = -1, int loadConditioningInterval = -1) {
-  LOG("createPool() entered.");
-
-  PoolPtr poolPtr = getHelper()->createPool(
-      poolName, locators, serverGroup, redundancy, clientNotification,
-      subscriptionAckInterval, connections, loadConditioningInterval);
-  ASSERT(poolPtr != nullptr, "Failed to create pool.");
-  LOG("Pool created.");
-  return poolPtr;
-}
-
-PoolPtr createPoolAndDestroy(const char* poolName, const char* locators,
-                             const char* serverGroup, int redundancy = 0,
-                             bool clientNotification = false,
-                             std::chrono::milliseconds subscriptionAckInterval =
-                                 std::chrono::milliseconds::zero(),
-                             int connections = -1) {
-  LOG("createPoolAndDestroy() entered.");
-
-  PoolPtr poolPtr = getHelper()->createPool(
-      poolName, locators, serverGroup, redundancy, clientNotification,
-      subscriptionAckInterval, connections);
-  ASSERT(poolPtr != nullptr, "Failed to create pool.");
-  poolPtr->destroy();
-  LOG("Pool created and destroyed.");
-  return poolPtr;
+ std::shared_ptr<Pool> findPool(const char* poolName) {
+   LOG("findPool() entered.");
+   auto poolPtr = getHelper()->getCache()->getPoolManager().find(poolName);
+   ASSERT(poolPtr != nullptr, "Failed to find pool.");
+   return poolPtr;
+ }
+ std::shared_ptr<Pool> createPool(
+     const char* poolName, const char* locators, const char* serverGroup,
+     int redundancy = 0, bool clientNotification = false,
+     std::chrono::milliseconds subscriptionAckInterval =
+         std::chrono::milliseconds::zero(),
+     int connections = -1, int loadConditioningInterval = -1) {
+   LOG("createPool() entered.");
+
+   auto poolPtr = getHelper()->createPool(
+       poolName, locators, serverGroup, redundancy, clientNotification,
+       subscriptionAckInterval, connections, loadConditioningInterval);
+   ASSERT(poolPtr != nullptr, "Failed to create pool.");
+   LOG("Pool created.");
+   return poolPtr;
+ }
+ std::shared_ptr<Pool> createPoolAndDestroy(
+     const char* poolName, const char* locators, const char* serverGroup,
+     int redundancy = 0, bool clientNotification = false,
+     std::chrono::milliseconds subscriptionAckInterval =
+         std::chrono::milliseconds::zero(),
+     int connections = -1) {
+   LOG("createPoolAndDestroy() entered.");
+
+   auto poolPtr = getHelper()->createPool(poolName, locators, serverGroup,
+                                          redundancy, clientNotification,
+                                          subscriptionAckInterval, connections);
+   ASSERT(poolPtr != nullptr, "Failed to create pool.");
+   poolPtr->destroy();
+   LOG("Pool created and destroyed.");
+   return poolPtr;
 }
 // this will create pool even endpoints and locatorhost has been not defined
-PoolPtr createPool2(const char* poolName, const char* locators,
+std::shared_ptr<Pool> createPool2(const char* poolName, const char* locators,
                     const char* serverGroup, const char* servers = nullptr,
                     int redundancy = 0, bool clientNotification = false) {
   LOG("createPool2() entered.");
 
-  PoolPtr poolPtr = getHelper()->createPool2(
+  auto poolPtr = getHelper()->createPool2(
       poolName, locators, serverGroup, servers, redundancy, clientNotification);
   ASSERT(poolPtr != nullptr, "Failed to create pool.");
   LOG("Pool created.");
   return poolPtr;
 }
-
-RegionPtr createRegionAndAttachPool(
+std::shared_ptr<Region> createRegionAndAttachPool(
     const char* name, bool ack, const char* poolName, bool caching = true,
     const std::chrono::seconds& ettl = std::chrono::seconds::zero(),
     const std::chrono::seconds& eit = std::chrono::seconds::zero(),
@@ -490,7 +486,7 @@ RegionPtr createRegionAndAttachPool(
     const std::chrono::seconds& rit = std::chrono::seconds::zero(), int lel = 0,
     ExpirationAction::Action action = ExpirationAction::DESTROY) {
   LOG("createRegionAndAttachPool() entered.");
-  RegionPtr regPtr = getHelper()->createRegionAndAttachPool(
+ auto regPtr = getHelper()->createRegionAndAttachPool(
       name, ack, poolName, caching, ettl, eit, rttl, rit, lel, action);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
@@ -503,23 +499,23 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+ auto keyPtr = createKey(key);
+ auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
-  ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
 
-  ASSERT(!regPtr->containsKey(keyPtr),
-         "Key should not have been found in region.");
-  ASSERT(!regPtr->containsValueForKey(keyPtr),
-         "Value should not have been found in region.");
+ ASSERT(!regPtr->containsKey(keyPtr),
+        "Key should not have been found in region.");
+ ASSERT(!regPtr->containsValueForKey(keyPtr),
+        "Value should not have been found in region.");
 
-  // regPtr->create( keyPtr, valPtr );
-  regPtr->put(keyPtr, valPtr);
-  LOG("Created entry.");
+ // regPtr->create( keyPtr, valPtr );
+ regPtr->put(keyPtr, valPtr);
+ LOG("Created entry.");
 
-  verifyEntry(name, key, value);
-  LOG("Entry created.");
+ verifyEntry(name, key, value);
+ LOG("Entry created.");
 }
 
 void updateEntry(const char* name, const char* key, const char* value,
@@ -529,15 +525,14 @@ void updateEntry(const char* name, const char* key, const char* value,
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+ auto keyPtr = createKey(key);
+ auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
-  ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
 
-  if (checkKey) {
-    ASSERT(regPtr->containsKey(keyPtr),
-           "Key should have been found in region.");
+ if (checkKey) {
+   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
   }
   if (checkVal) {
     ASSERT(regPtr->containsValueForKey(keyPtr),
@@ -560,9 +555,9 @@ void doNetsearch(const char* name, const char* key, const char* value,
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+ auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+ auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -598,17 +593,17 @@ void createIntEntry(const char* name, const char* key, const int value,
   fflush(stdout);
 
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableInt32Ptr valPtr = CacheableInt32::create(value);
+ auto keyPtr = createKey(key);
+ auto valPtr = CacheableInt32::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
-  ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
 
-  if (onlyCreate) {
-    ASSERT(!regPtr->containsKey(keyPtr),
-           "Key should not have been found in region.");
-    ASSERT(!regPtr->containsValueForKey(keyPtr),
-           "Value should not have been found in region.");
+ if (onlyCreate) {
+   ASSERT(!regPtr->containsKey(keyPtr),
+          "Key should not have been found in region.");
+   ASSERT(!regPtr->containsValueForKey(keyPtr),
+          "Value should not have been found in region.");
   }
 
   regPtr->put(keyPtr, valPtr);
@@ -623,9 +618,9 @@ void invalidateEntry(const char* name, const char* key) {
   fprintf(stdout, "Invalidating entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Invalidate entry, verify entry is invalidated
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+ auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+ auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -644,9 +639,9 @@ void destroyEntry(const char* name, const char* key) {
   fprintf(stdout, "Destroying entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Destroy entry, verify entry is destroyed
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+ auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+ auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -660,7 +655,7 @@ void destroyEntry(const char* name, const char* key) {
 
 void destroyRegion(const char* name) {
   LOG("destroyRegion() entered.");
-  RegionPtr regPtr = getHelper()->getRegion(name);
+ auto regPtr = getHelper()->getRegion(name);
   regPtr->localDestroyRegion();
   LOG("Region destroyed.");
 }
@@ -670,46 +665,51 @@ class RegionOperations {
   RegionOperations(const char* name)
       : m_regionPtr(getHelper()->getRegion(name)) {}
 
-  void putOp(int keys = 1, const SerializablePtr& aCallbackArgument = nullptr) {
+  void putOp(int keys = 1, const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
       sprintf(keybuf, "key%d", i);
       sprintf(valbuf, "value%d", i);
-      CacheableStringPtr valPtr = CacheableString::create(valbuf);
+      auto valPtr = CacheableString::create(valbuf);
       m_regionPtr->put(keybuf, valPtr, aCallbackArgument);
     }
   }
-  void invalidateOp(int keys = 1,
-                    const SerializablePtr& aCallbackArgument = nullptr) {
+  void invalidateOp(
+      int keys = 1,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
       sprintf(keybuf, "key%d", i);
-      CacheableStringPtr valPtr = CacheableString::create(valbuf);
+      auto valPtr = CacheableString::create(valbuf);
       m_regionPtr->localInvalidate(keybuf, aCallbackArgument);
     }
   }
-  void destroyOp(int keys = 1, const SerializablePtr& aCallbackArgument = nullptr) {
+  void destroyOp(
+      int keys = 1,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
       sprintf(keybuf, "key%d", i);
-      CacheableStringPtr valPtr = CacheableString::create(valbuf);
+      auto valPtr = CacheableString::create(valbuf);
       m_regionPtr->destroy(keybuf, aCallbackArgument);
     }
   }
-  void removeOp(int keys = 1, const SerializablePtr& aCallbackArgument = nullptr) {
+  void removeOp(
+      int keys = 1,
+      const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
       sprintf(keybuf, "key%d", i);
       sprintf(valbuf, "value%d", i);
-      CacheableStringPtr valPtr = CacheableString::create(valbuf);
+      auto valPtr = CacheableString::create(valbuf);
       m_regionPtr->remove(keybuf, valPtr, aCallbackArgument);
     }
   }
-  RegionPtr m_regionPtr;
+  std::shared_ptr<Region> m_regionPtr;
 };
 
 #endif  // GEODE_INTEGRATION_TEST_THINCLIENTHELPER_H_
diff --git a/cppcache/integration-test/ThinClientInterest1.hpp b/cppcache/integration-test/ThinClientInterest1.hpp
index 8cf0b6b6..c1fd4d5b 100644
--- a/cppcache/integration-test/ThinClientInterest1.hpp
+++ b/cppcache/integration-test/ThinClientInterest1.hpp
@@ -54,9 +54,9 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, populateServer)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     for (int i = 0; i < 5; i++) {
-      CacheableKeyPtr keyPtr = CacheableKey::create(keys[i]);
+      auto keyPtr = CacheableKey::create(keys[i]);
       regPtr->create(keyPtr, vals[i]);
     }
     SLEEP(200);
@@ -68,7 +68,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, setupClient2_Pool_Locator)
     initClient(true);
     createPooledRegion(regionNames[0], false /*ack mode*/, locatorsG,
                        "__TEST_POOL1__", true /*client notification*/);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, true);
     SLEEP(200);
   }
@@ -76,9 +76,9 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, verify)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     for (int i = 0; i < 5; i++) {
-      CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[i]);
+      auto keyPtr1 = CacheableKey::create(keys[i]);
       char buf[1024];
       sprintf(buf, "key[%s] should have been found", keys[i]);
       ASSERT(regPtr->containsKey(keyPtr1), buf);
diff --git a/cppcache/integration-test/ThinClientInterest2.hpp b/cppcache/integration-test/ThinClientInterest2.hpp
index 92ef6ab6..caacbdd3 100644
--- a/cppcache/integration-test/ThinClientInterest2.hpp
+++ b/cppcache/integration-test/ThinClientInterest2.hpp
@@ -49,15 +49,15 @@ DUNIT_TASK_DEFINITION(CLIENT2, setupClient2_Pool_Locator)
     initClient(true);
     createPooledRegion(regionNames[0], false /*ack mode*/, locatorsG,
                        "__TEST_POOL1__", true /*client notification*/);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, populateServer)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     for (int i = 0; i < 5; i++) {
-      CacheableKeyPtr keyPtr = CacheableKey::create(keys[i]);
+      auto keyPtr = CacheableKey::create(keys[i]);
       regPtr->create(keyPtr, vals[i]);
     }
   }
@@ -65,13 +65,13 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, verify)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     for (int i = 0; i < 5; i++) {
-      CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[i]);
+      auto keyPtr1 = CacheableKey::create(keys[i]);
       char buf[1024];
       sprintf(buf, "key[%s] should not have been found", keys[i]);
       ASSERT(!regPtr->containsKey(keyPtr1), buf);
-      CacheablePtr checkPtr = regPtr->get(keyPtr1);
+      auto checkPtr = regPtr->get(keyPtr1);
       verifyEntry(regionNames[0], keys[i], vals[i]);
     }
   }
diff --git a/cppcache/integration-test/ThinClientInterest3.hpp b/cppcache/integration-test/ThinClientInterest3.hpp
index 3eb0c0fc..132113a9 100644
--- a/cppcache/integration-test/ThinClientInterest3.hpp
+++ b/cppcache/integration-test/ThinClientInterest3.hpp
@@ -38,22 +38,24 @@ static bool isLocator = false;
 const char *locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
 #include "LocatorHelper.hpp"
-TallyListenerPtr reg1Listener1;
-TallyWriterPtr reg1Writer1;
+std::shared_ptr<TallyListener> reg1Listener1;
+std::shared_ptr<TallyWriter> reg1Writer1;
 int numCreates = 0;
 int numUpdates = 0;
 int numInvalidates = 0;
 int numDestroys = 0;
 
-void setCacheListener(const char *regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char *regName,
+                      std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
-void setCacheWriter(const char *regName, TallyWriterPtr regWriter) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheWriter(const char *regName,
+                    std::shared_ptr<TallyWriter> regWriter) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheWriter(regWriter);
 }
 
@@ -105,10 +107,10 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testCreatesAndUpdates)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
-    VectorOfCacheableKey keys;
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
+    std::vector<std::shared_ptr<CacheableKey>> keys;
     keys.push_back(keyPtr1);
     keys.push_back(keyPtr2);
     regPtr->registerKeys(keys);
@@ -145,9 +147,9 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testInvalidateAndDestroy)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
     regPtr->invalidate(keyPtr1);
     numInvalidates++;
     validateEventCount(__LINE__);
diff --git a/cppcache/integration-test/ThinClientInterest3Cacheless.hpp b/cppcache/integration-test/ThinClientInterest3Cacheless.hpp
index 3943e3a5..6bc88826 100644
--- a/cppcache/integration-test/ThinClientInterest3Cacheless.hpp
+++ b/cppcache/integration-test/ThinClientInterest3Cacheless.hpp
@@ -38,22 +38,24 @@ static bool isLocator = false;
 const char *locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
 #include "LocatorHelper.hpp"
-TallyListenerPtr reg1Listener1;
-TallyWriterPtr reg1Writer1;
+std::shared_ptr<TallyListener> reg1Listener1;
+std::shared_ptr<TallyWriter> reg1Writer1;
 int numCreates = 0;
 int numUpdates = 0;
 int numInvalidates = 0;
 int numDestroys = 0;
 
-void setCacheListener(const char *regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char *regName,
+                      std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
-void setCacheWriter(const char *regName, TallyWriterPtr regWriter) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheWriter(const char *regName,
+                    std::shared_ptr<TallyWriter> regWriter) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheWriter(regWriter);
 }
 
@@ -106,10 +108,10 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testCreatesAndUpdates)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
-    VectorOfCacheableKey keys;
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
+    std::vector<std::shared_ptr<CacheableKey>> keys;
     keys.push_back(keyPtr1);
     keys.push_back(keyPtr2);
     regPtr->registerKeys(keys);
diff --git a/cppcache/integration-test/ThinClientInterestList.hpp b/cppcache/integration-test/ThinClientInterestList.hpp
index 77aed90a..357d4b58 100644
--- a/cppcache/integration-test/ThinClientInterestList.hpp
+++ b/cppcache/integration-test/ThinClientInterestList.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -84,10 +83,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -202,7 +201,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locatorsG,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locatorsG, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -215,13 +214,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -243,10 +242,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -268,9 +267,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -331,13 +330,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     createEntry(regionNames[0], keys[0], vals[0]);
     createEntry(regionNames[1], keys[2], vals[2]);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr1);
     keys1.push_back(keyPtr3);
     regPtr0->registerKeys(keys0);
@@ -356,9 +355,9 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
     doNetsearch(regionNames[1], keys[2], vals[2]);
     createEntry(regionNames[0], keys[1], vals[1]);
     createEntry(regionNames[1], keys[3], vals[3]);
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    VectorOfCacheableKey keys0;
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    std::vector<std::shared_ptr<CacheableKey>> keys0;
     keys0.push_back(keyPtr0);
     regPtr0->registerKeys(keys0);
     LOG("StepFour complete.");
@@ -374,9 +373,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFive)
     updateEntry(regionNames[0], keys[0], nvals[0]);
     updateEntry(regionNames[1], keys[2], nvals[2]);
 
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
-    VectorOfCacheableKey keys1;
+    auto keyPtr3 = CacheableKey::create(keys[3]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyPtr3);
     regPtr1->unregisterKeys(keys1);
     LOG("StepFive complete.");
@@ -387,10 +386,10 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepSix)
     // verifyCreated( regionNames[0], keys[0]);
     verifyEntry(regionNames[0], keys[0], nvals[0]);
     verifyEntry(regionNames[1], keys[2], vals[2]);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
     regPtr0->destroy(keyPtr1);
     regPtr1->destroy(keyPtr3);
     LOG("StepSix complete.");
diff --git a/cppcache/integration-test/ThinClientInterestList2.hpp b/cppcache/integration-test/ThinClientInterestList2.hpp
index a84a9ee3..687401d4 100644
--- a/cppcache/integration-test/ThinClientInterestList2.hpp
+++ b/cppcache/integration-test/ThinClientInterestList2.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -84,10 +83,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -202,7 +201,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locatorsG, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -215,13 +214,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -243,10 +242,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -268,9 +267,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -332,8 +331,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1Entries)
     createEntry(regionNames[0], keys[0], vals[0]);
     createEntry(regionNames[1], keys[2], vals[2]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     regPtr0->registerAllKeys();
     regPtr1->registerAllKeys();
@@ -348,7 +347,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2Entries)
     doNetsearch(regionNames[1], keys[2], vals[2]);
     createEntry(regionNames[0], keys[1], vals[1]);
     createEntry(regionNames[1], keys[3], vals[3]);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys();
     LOG("CreateClient2Entries complete.");
   }
@@ -363,7 +362,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, UpdateClient1Entries)
     updateEntry(regionNames[0], keys[0], nvals[0]);
     updateEntry(regionNames[1], keys[2], nvals[2]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->unregisterAllKeys();
     LOG("UpdateClient1Entries complete.");
   }
@@ -373,10 +372,10 @@ DUNIT_TASK_DEFINITION(CLIENT2, VerifyAndDestroyClient2Entries)
     // verifyCreated( regionNames[0], keys[0]);
     verifyEntry(regionNames[0], keys[0], nvals[0]);
     verifyEntry(regionNames[1], keys[2], vals[2]);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
     regPtr0->destroy(keyPtr1);
     regPtr1->destroy(keyPtr3);
     LOG("VerifyAndDestroyClient2Entries complete.");
diff --git a/cppcache/integration-test/ThinClientListenerInit.hpp b/cppcache/integration-test/ThinClientListenerInit.hpp
index 8082ab9a..99f63b8b 100644
--- a/cppcache/integration-test/ThinClientListenerInit.hpp
+++ b/cppcache/integration-test/ThinClientListenerInit.hpp
@@ -39,9 +39,9 @@ static int numberOfLocators = 1;
 const char* locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, numberOfLocators);
 const char* poolName = "__TESTPOOL1_";
-TallyListenerPtr reg1Listener1, reg1Listener2;
-TallyWriterPtr reg1Writer1, reg1Writer2;
-TallyLoaderPtr reg1Loader1, reg1Loader2;
+std::shared_ptr<TallyListener> reg1Listener1, reg1Listener2;
+std::shared_ptr<TallyWriter> reg1Writer1, reg1Writer2;
+std::shared_ptr<TallyLoader> reg1Loader1, reg1Loader2;
 int numCreates = 0;
 int numUpdates = 0;
 int numLoads = 0;
@@ -54,14 +54,16 @@ class ThinClientTallyLoader : public TallyLoader {
 
   virtual ~ThinClientTallyLoader() {}
 
-  CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                    const SerializablePtr& aCallbackArgument) {
+  std::shared_ptr<Cacheable> load(
+      const std::shared_ptr<Region>& rp,
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument) {
     int32_t loadValue = std::dynamic_pointer_cast<CacheableInt32>(
                             TallyLoader::load(rp, key, aCallbackArgument))
                             ->value();
     char lstrvalue[32];
     sprintf(lstrvalue, "%i", loadValue);
-    CacheableStringPtr lreturnValue = CacheableString::create(lstrvalue);
+    auto lreturnValue = CacheableString::create(lstrvalue);
     if (key != nullptr && (nullptr != rp->getAttributes()->getEndpoints() ||
                            rp->getAttributes()->getPoolName() != nullptr)) {
       LOGDEBUG("Putting the value (%s) for local region clients only ",
@@ -72,21 +74,24 @@ class ThinClientTallyLoader : public TallyLoader {
   }
 };
 
-void setCacheListener(const char* regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName,
+                      std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
-void setCacheLoader(const char* regName, TallyLoaderPtr regLoader) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheLoader(const char* regName,
+                    std::shared_ptr<TallyLoader> regLoader) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheLoader(regLoader);
 }
 
-void setCacheWriter(const char* regName, TallyWriterPtr regWriter) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheWriter(const char* regName,
+                    std::shared_ptr<TallyWriter> regWriter) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheWriter(regWriter);
 }
 
@@ -134,9 +139,9 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testLoaderAndWriter)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr = CacheableKey::create(keys[0]);
-    VectorOfCacheableKey keys;
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr = CacheableKey::create(keys[0]);
+    std::vector<std::shared_ptr<CacheableKey>> keys;
     keys.push_back(keyPtr);
     regPtr->registerKeys(keys);
 
@@ -148,8 +153,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, testLoaderAndWriter)
     // now having all the Callbacks set, lets call the loader and writer
     ASSERT(regPtr->get(keyPtr) != nullptr, "Expected non null value");
 
-    RegionEntryPtr regEntryPtr = regPtr->getEntry(keyPtr);
-    CacheablePtr valuePtr = regEntryPtr->getValue();
+    auto regEntryPtr = regPtr->getEntry(keyPtr);
+    auto valuePtr = regEntryPtr->getValue();
     int val = atoi(valuePtr->toString()->asChar());
     LOGFINE("val for keyPtr is %d", val);
     ASSERT(val == 0, "Expected value CacheLoad value should be 0");
@@ -162,10 +167,10 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testCreatesAndUpdates)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
-    VectorOfCacheableKey keys;
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
+    std::vector<std::shared_ptr<CacheableKey>> keys;
     keys.push_back(keyPtr1);
     keys.push_back(keyPtr2);
     regPtr->registerKeys(keys);
@@ -212,17 +217,17 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testDestroy)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
     regPtr->localInvalidate(keyPtr1);
     // Verify no listener activity after the invalidate
     validateEventCount(__LINE__);
 
     // Verify after update listener activity after a get on an invalidated value
     regPtr->get(keyPtr1);
-    RegionEntryPtr regEntryPtr = regPtr->getEntry(keyPtr1);
-    CacheablePtr valuePtr = regEntryPtr->getValue();
+    auto regEntryPtr = regPtr->getEntry(keyPtr1);
+    auto valuePtr = regEntryPtr->getValue();
     int val = atoi(valuePtr->toString()->asChar());
     LOGFINE("val for keyPtr1 is %d", val);
     ASSERT(val == 0, "Expected value CacheLoad value should be 0");
@@ -231,8 +236,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, testDestroy)
 
     regPtr->destroy(keyPtr2);
     regPtr->get(keyPtr2);
-    RegionEntryPtr regEntryPtr1 = regPtr->getEntry(keyPtr2);
-    CacheablePtr valuePtr1 = regEntryPtr1->getValue();
+    auto regEntryPtr1 = regPtr->getEntry(keyPtr2);
+    auto valuePtr1 = regEntryPtr1->getValue();
     int val1 = atoi(valuePtr1->toString()->asChar());
     LOGFINE("val1 for keyPtr2 is %d", val1);
     ASSERT(val1 == 1, "Expected value CacheLoad value should be 1");
diff --git a/cppcache/integration-test/ThinClientListenerWriter.hpp b/cppcache/integration-test/ThinClientListenerWriter.hpp
index ce6ec8b6..f5d9d281 100644
--- a/cppcache/integration-test/ThinClientListenerWriter.hpp
+++ b/cppcache/integration-test/ThinClientListenerWriter.hpp
@@ -31,7 +31,6 @@
 #define CLIENT3 s2p2
 
 class SimpleCacheListener;
-typedef std::shared_ptr<SimpleCacheListener> SimpleCacheListenerPtr;
 
 // The SimpleCacheListener class.
 class SimpleCacheListener : public CacheListener {
@@ -47,7 +46,7 @@ class SimpleCacheListener : public CacheListener {
   virtual void afterDestroy(const EntryEvent& event);
   virtual void afterRegionInvalidate(const RegionEvent& event);
   virtual void afterRegionDestroy(const RegionEvent& event);
-  virtual void close(const RegionPtr& region);
+  virtual void close(const std::shared_ptr<Region>& region);
   virtual void afterRegionClear(const RegionEvent& event);
 
   SimpleCacheListener() : CacheListener(), m_creates(0), m_clears(0) {
@@ -93,7 +92,7 @@ void SimpleCacheListener::afterRegionDestroy(const RegionEvent& event) {
       event.getRegion()->getName());
 }
 
-void SimpleCacheListener::close(const RegionPtr& region) {
+void SimpleCacheListener::close(const std::shared_ptr<Region>& region) {
   LOGINFO("SimpleCacheListener: Got an close event for %s region .",
           region.get()->getName());
 }
@@ -118,26 +117,24 @@ static bool isLocator = false;
 static int numberOfLocators = 0;
 const char* locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, numberOfLocators);
-const char* poolName = "__TESTPOOL1_";
-TallyListenerPtr regListener;
-SimpleCacheListenerPtr parentRegCacheListener;
-SimpleCacheListenerPtr subRegCacheListener;
-
-SimpleCacheListenerPtr distRegCacheListener;
-TallyWriterPtr regWriter;
+const char* poolName = "__TESTPOOL1_"; std::shared_ptr<TallyListener> regListener; std::shared_ptr<SimpleCacheListener> parentRegCacheListener; std::shared_ptr<SimpleCacheListener> subRegCacheListener;
+std::shared_ptr<SimpleCacheListener> distRegCacheListener;
+std::shared_ptr<TallyWriter> regWriter;
 
 #include "LocatorHelper.hpp"
 const char* myRegNames[] = {"DistRegionAck", "DistRegionNoAck", "ExampleRegion",
                             "SubRegion1", "SubRegion2"};
-void setCacheListener(const char* regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName,
+                      std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
-void setCacheWriter(const char* regName, TallyWriterPtr regWriter) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheWriter(const char* regName,
+                    std::shared_ptr<TallyWriter> regWriter) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheWriter(regWriter);
 }
 
@@ -208,22 +205,20 @@ DUNIT_TASK_DEFINITION(CLIENT1, SetupClient1withCachingEnabled_Pooled_Locator)
                        true);
 
     // create subregion
-    RegionPtr exmpRegptr = getHelper()->getRegion(myRegNames[2]);
-    RegionAttributesPtr lattribPtr = exmpRegptr->getAttributes();
-    RegionPtr subregPtr1 =
-        exmpRegptr->createSubregion(myRegNames[3], lattribPtr);
-    RegionPtr subregPtr2 =
-        exmpRegptr->createSubregion(myRegNames[4], lattribPtr);
-
-    LOGINFO(
-        " CLIENT1 SetupClient1withCachingEnabled_Pooled_Locator subRegions "
-        "created successfully");
+   auto exmpRegptr = getHelper()->getRegion(myRegNames[2]);
+   auto lattribPtr = exmpRegptr->getAttributes();
+   auto subregPtr1 = exmpRegptr->createSubregion(myRegNames[3], lattribPtr);
+   auto subregPtr2 = exmpRegptr->createSubregion(myRegNames[4], lattribPtr);
+
+   LOGINFO(
+       " CLIENT1 SetupClient1withCachingEnabled_Pooled_Locator subRegions "
+       "created successfully");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, Register2WithTrue)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys();
   }
 END_TASK_DEFINITION
@@ -231,30 +226,30 @@ END_TASK_DEFINITION
 // RegisterKeys
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterKeys)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(myRegNames[0]);
+   auto regPtr0 = getHelper()->getRegion(myRegNames[0]);
 
-    RegionPtr exmpRegPtr = getHelper()->getRegion(myRegNames[2]);
-    RegionPtr subregPtr0 = exmpRegPtr->getSubregion(myRegNames[3]);
-    RegionPtr subregPtr1 = exmpRegPtr->getSubregion(myRegNames[4]);
+   auto exmpRegPtr = getHelper()->getRegion(myRegNames[2]);
+   auto subregPtr0 = exmpRegPtr->getSubregion(myRegNames[3]);
+   auto subregPtr1 = exmpRegPtr->getSubregion(myRegNames[4]);
 
-    // 1. registerAllKeys on parent and both subregions
-    regPtr0->registerAllKeys();
-    exmpRegPtr->registerAllKeys();
-    subregPtr0->registerAllKeys();
-    subregPtr1->registerAllKeys();
+   // 1. registerAllKeys on parent and both subregions
+   regPtr0->registerAllKeys();
+   exmpRegPtr->registerAllKeys();
+   subregPtr0->registerAllKeys();
+   subregPtr1->registerAllKeys();
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, Register2WithFalse)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(false, false, false);
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT3, Register3WithFalse)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(false, false, false);
   }
 END_TASK_DEFINITION
@@ -269,7 +264,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, SetupClient2_Pooled_Locator)
                        regListener, false);
     regWriter = std::make_shared<TallyWriter>();
     setCacheWriter(regionNames[0], regWriter);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     // regPtr0->registerAllKeys();
   }
 END_TASK_DEFINITION
@@ -294,26 +289,23 @@ DUNIT_TASK_DEFINITION(CLIENT2, SetupClient2withCachingEnabled_Pooled_Locator)
     setCacheWriter(myRegNames[2], regWriter);
 
     // create subregion
-    RegionPtr exmpRegptr = getHelper()->getRegion(myRegNames[2]);
-    RegionAttributesPtr lattribPtr = exmpRegptr->getAttributes();
-    RegionPtr subregPtr1 =
-        exmpRegptr->createSubregion(myRegNames[3], lattribPtr);
-    RegionPtr subregPtr2 =
-        exmpRegptr->createSubregion(myRegNames[4], lattribPtr);
-
-    LOGINFO(
-        "CLIENT2 SetupClient2withCachingEnabled_Pooled_Locator:: subRegions "
-        "created successfully");
-
-    // Attach Listener to subRegion
-    // Attache Listener
-
-    AttributesMutatorPtr subregAttrMutatorPtr =
-        subregPtr1->getAttributesMutator();
-    subRegCacheListener = std::make_shared<SimpleCacheListener>();
-    subregAttrMutatorPtr->setCacheListener(subRegCacheListener);
-
-    LOG("StepTwo_Pool complete.");
+   auto exmpRegptr = getHelper()->getRegion(myRegNames[2]);
+   auto lattribPtr = exmpRegptr->getAttributes();
+   auto subregPtr1 = exmpRegptr->createSubregion(myRegNames[3], lattribPtr);
+   auto subregPtr2 = exmpRegptr->createSubregion(myRegNames[4], lattribPtr);
+
+   LOGINFO(
+       "CLIENT2 SetupClient2withCachingEnabled_Pooled_Locator:: subRegions "
+       "created successfully");
+
+   // Attach Listener to subRegion
+   // Attache Listener
+
+   auto subregAttrMutatorPtr = subregPtr1->getAttributesMutator();
+   subRegCacheListener = std::make_shared<SimpleCacheListener>();
+   subregAttrMutatorPtr->setCacheListener(subRegCacheListener);
+
+   LOG("StepTwo_Pool complete.");
   }
 END_TASK_DEFINITION
 
@@ -368,54 +360,54 @@ DUNIT_TASK_DEFINITION(CLIENT1, doEventOperations)
   {
     LOG("do entry operation from client 1");
 
-    RegionPtr regPtr0 = getHelper()->getRegion(myRegNames[0]);
-    RegionPtr exmpRegPtr = getHelper()->getRegion(myRegNames[2]);
-
-    RegionPtr subregPtr1 = exmpRegPtr->getSubregion(myRegNames[3]);
-    RegionPtr subregPtr2 = exmpRegPtr->getSubregion(myRegNames[4]);
-
-    for (int index = 0; index < 5; index++) {
-      char key[100] = {0};
-      char value[100] = {0};
-      ACE_OS::sprintf(key, "Key-%d", index);
-      ACE_OS::sprintf(value, "Value-%d", index);
-      CacheableKeyPtr keyptr = CacheableKey::create(key);
-      CacheablePtr valuePtr = CacheableString::create(value);
-      regPtr0->put(keyptr, valuePtr);
-      exmpRegPtr->put(keyptr, valuePtr);
-      subregPtr1->put(keyptr, valuePtr);
-      subregPtr2->put(keyptr, valuePtr);
-    }
-
-    LOGINFO(
-        "CLIENT-1 localCaching Enabled After Put ....ExampleRegion.size() = %d",
-        exmpRegPtr->size());
-    ASSERT(exmpRegPtr->size() == 5,
-           "Total number of entries in the region should be 5");
-    // SLEEP( 1000 ); // let the events reach at other end.
-
-    LOGINFO(
-        "CLIENT-1 localCaching Enabled After Put ....DistRegionAck.size() = %d",
-        regPtr0->size());
-
-    // TEST COVERAGE FOR cacheListener.afterRegionClear() API
-    exmpRegPtr->clear();
-    LOGINFO("CLIENT-1 AFTER Clear() call ....reg.size() = %d",
-            exmpRegPtr->size());
-    ASSERT(exmpRegPtr->size() == 0,
-           "Total number of entries in the region should be 0");
-
-    LOGINFO("CLIENT-1 AFTER Clear() call ....SubRegion-1.size() = %d",
-            subregPtr1->size());
-    ASSERT(subregPtr1->size() == 5,
-           "Total number of entries in the region should be 0");
-
-    LOGINFO("CLIENT-1 AFTER Clear() call ....SubRegion-2.size() = %d",
-            subregPtr2->size());
-    ASSERT(subregPtr2->size() == 5,
-           "Total number of entries in the region should be 0");
-
-    SLEEP(1000);
+   auto regPtr0 = getHelper()->getRegion(myRegNames[0]);
+   auto exmpRegPtr = getHelper()->getRegion(myRegNames[2]);
+
+   auto subregPtr1 = exmpRegPtr->getSubregion(myRegNames[3]);
+   auto subregPtr2 = exmpRegPtr->getSubregion(myRegNames[4]);
+
+   for (int index = 0; index < 5; index++) {
+     char key[100] = {0};
+     char value[100] = {0};
+     ACE_OS::sprintf(key, "Key-%d", index);
+     ACE_OS::sprintf(value, "Value-%d", index);
+     auto keyptr = CacheableKey::create(key);
+     auto valuePtr = CacheableString::create(value);
+     regPtr0->put(keyptr, valuePtr);
+     exmpRegPtr->put(keyptr, valuePtr);
+     subregPtr1->put(keyptr, valuePtr);
+     subregPtr2->put(keyptr, valuePtr);
+   }
+
+   LOGINFO(
+       "CLIENT-1 localCaching Enabled After Put ....ExampleRegion.size() = %d",
+       exmpRegPtr->size());
+   ASSERT(exmpRegPtr->size() == 5,
+          "Total number of entries in the region should be 5");
+   // SLEEP( 1000 ); // let the events reach at other end.
+
+   LOGINFO(
+       "CLIENT-1 localCaching Enabled After Put ....DistRegionAck.size() = %d",
+       regPtr0->size());
+
+   // TEST COVERAGE FOR cacheListener.afterRegionClear() API
+   exmpRegPtr->clear();
+   LOGINFO("CLIENT-1 AFTER Clear() call ....reg.size() = %d",
+           exmpRegPtr->size());
+   ASSERT(exmpRegPtr->size() == 0,
+          "Total number of entries in the region should be 0");
+
+   LOGINFO("CLIENT-1 AFTER Clear() call ....SubRegion-1.size() = %d",
+           subregPtr1->size());
+   ASSERT(subregPtr1->size() == 5,
+          "Total number of entries in the region should be 0");
+
+   LOGINFO("CLIENT-1 AFTER Clear() call ....SubRegion-2.size() = %d",
+           subregPtr2->size());
+   ASSERT(subregPtr2->size() == 5,
+          "Total number of entries in the region should be 0");
+
+   SLEEP(1000);
   }
 END_TASK_DEFINITION
 
@@ -441,35 +433,35 @@ DUNIT_TASK_DEFINITION(CLIENT2, validateListenerWriterEventsWithNBSTrue)
     ASSERT(parentRegCacheListener->getClears() == 1,
            "region.clear() should be called once");
 
-    RegionPtr exmpRegPtr = getHelper()->getRegion(myRegNames[2]);
+   auto exmpRegPtr = getHelper()->getRegion(myRegNames[2]);
     // LOGINFO(" Total Entries in ExampleRegion = %d ", exmpRegPtr->size());
-    ASSERT(exmpRegPtr->size() == 0,
-           "Client-2 ExampleRegion.clear() should have called and so "
-           "Exampleregion size is expected to 0 ");
-
-    // Verify entries in Sub-Region.
-    RegionPtr subregPtr1 = exmpRegPtr->getSubregion(myRegNames[3]);
-    RegionPtr subregPtr2 = exmpRegPtr->getSubregion(myRegNames[4]);
-
-    // LOGINFO(" Total Entries in SubRegion-1 = %d ", subregPtr1->size());
-    // LOGINFO(" Total Entries in SubRegion-2 = %d ", subregPtr2->size());
-    ASSERT(subRegCacheListener->getCreates() == 5,
-           "should be 5 creates for SubRegion-1 ");
-    ASSERT(subRegCacheListener->getClears() == 0,
-           "should be 0 clears for SubRegion-1 ");
-    ASSERT(subregPtr1->size() == 5,
-           "Client-2 SubRegion-1 should contains 5 entries ");
-    ASSERT(subregPtr2->size() == 5,
-           "Client-2 SubRegion-2 should contains 5 entries ");
-
-    // LOGINFO(" SubRegion-1 CREATES:: subRegCacheListener::m_creates = %d ",
-    // subRegCacheListener->getCreates());
-    // LOGINFO(" SubRegion-1 CLEARS:: subRegCacheListener::m_clears = %d ",
-    // subRegCacheListener->getClears());
-
-    LOGINFO(
-        "validateListenerWriterEventsWithNBSTrue :: Event Validation "
-        "Passed....!!");
+   ASSERT(exmpRegPtr->size() == 0,
+          "Client-2 ExampleRegion.clear() should have called and so "
+          "Exampleregion size is expected to 0 ");
+
+   // Verify entries in Sub-Region.
+   auto subregPtr1 = exmpRegPtr->getSubregion(myRegNames[3]);
+   auto subregPtr2 = exmpRegPtr->getSubregion(myRegNames[4]);
+
+   // LOGINFO(" Total Entries in SubRegion-1 = %d ", subregPtr1->size());
+   // LOGINFO(" Total Entries in SubRegion-2 = %d ", subregPtr2->size());
+   ASSERT(subRegCacheListener->getCreates() == 5,
+          "should be 5 creates for SubRegion-1 ");
+   ASSERT(subRegCacheListener->getClears() == 0,
+          "should be 0 clears for SubRegion-1 ");
+   ASSERT(subregPtr1->size() == 5,
+          "Client-2 SubRegion-1 should contains 5 entries ");
+   ASSERT(subregPtr2->size() == 5,
+          "Client-2 SubRegion-2 should contains 5 entries ");
+
+   // LOGINFO(" SubRegion-1 CREATES:: subRegCacheListener::m_creates = %d ",
+   // subRegCacheListener->getCreates());
+   // LOGINFO(" SubRegion-1 CLEARS:: subRegCacheListener::m_clears = %d ",
+   // subRegCacheListener->getClears());
+
+   LOGINFO(
+       "validateListenerWriterEventsWithNBSTrue :: Event Validation "
+       "Passed....!!");
   }
 END_TASK_DEFINITION
 
diff --git a/cppcache/integration-test/ThinClientLocalCacheLoader.hpp b/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
index faea6eee..0d4484b2 100644
--- a/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
+++ b/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
@@ -30,11 +30,10 @@
 
 using namespace apache::geode::client;
 using namespace test;
-
-TallyLoaderPtr reg1Loader1;
+std::shared_ptr<TallyLoader> reg1Loader1;
 int numLoads = 0;
-CachePtr cachePtr;
-RegionPtr regionPtr;
+std::shared_ptr<Cache> cachePtr;
+std::shared_ptr<Region> regionPtr;
 
 class ThinClientTallyLoader : public TallyLoader {
  public:
@@ -42,24 +41,26 @@ class ThinClientTallyLoader : public TallyLoader {
 
   virtual ~ThinClientTallyLoader() {}
 
-  CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                    const SerializablePtr& aCallbackArgument) {
+  std::shared_ptr<Cacheable> load(
+      const std::shared_ptr<Region>& rp,
+      const std::shared_ptr<CacheableKey>& key,
+      const std::shared_ptr<Serializable>& aCallbackArgument) {
     int32_t loadValue = std::dynamic_pointer_cast<CacheableInt32>(
                             TallyLoader::load(rp, key, aCallbackArgument))
                             ->value();
     char lstrvalue[32];
     sprintf(lstrvalue, "%i", loadValue);
-    CacheableStringPtr lreturnValue = CacheableString::create(lstrvalue);
-    if (key != nullptr && (nullptr != rp->getAttributes()->getEndpoints() ||
-                           rp->getAttributes()->getPoolName() != nullptr)) {
-      LOGDEBUG("Putting the value (%s) for local region clients only ",
-               lstrvalue);
-      rp->put(key, lreturnValue);
+   auto lreturnValue = CacheableString::create(lstrvalue);
+   if (key != nullptr && (nullptr != rp->getAttributes()->getEndpoints() ||
+                          rp->getAttributes()->getPoolName() != nullptr)) {
+     LOGDEBUG("Putting the value (%s) for local region clients only ",
+              lstrvalue);
+     rp->put(key, lreturnValue);
     }
     return lreturnValue;
   }
 
-  void close(const RegionPtr& region) {
+  void close(const std::shared_ptr<Region>& region) {
     LOG(" ThinClientTallyLoader::close() called");
     if (region != nullptr) {
       LOGINFO(" Region %s is Destroyed = %d ", region->getName(),
@@ -101,7 +102,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, SetupClient)
     std::string clientXml = path;
     clientXml += "/resources/";
     clientXml += clientXmlFile;
-    CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory()->set(
+    auto cacheFactoryPtr = CacheFactory::createCacheFactory()->set(
         "cache-xml-file", clientXml.c_str());
     cachePtr = cacheFactoryPtr->create();
     LOGINFO("Created the Geode Cache");
@@ -112,9 +113,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, SetupClient)
     LOGINFO("Obtained the Region from the Cache");
 
     // Plugin the ThinClientTallyLoader to the Region.
-    AttributesMutatorPtr attrMutatorPtr = regionPtr->getAttributesMutator();
-    reg1Loader1 = std::make_shared<ThinClientTallyLoader>();
-    attrMutatorPtr->setCacheLoader(reg1Loader1);
+   auto attrMutatorPtr = regionPtr->getAttributesMutator();
+   reg1Loader1 = std::make_shared<ThinClientTallyLoader>();
+   attrMutatorPtr->setCacheLoader(reg1Loader1);
   }
 END_TASK_DEFINITION
 
@@ -128,115 +129,115 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testLoader)
   {
-    CacheableKeyPtr keyPtr = CacheableKey::create("Key0");
+   auto keyPtr = CacheableKey::create("Key0");
 
-    ASSERT(!regionPtr->containsKey(keyPtr),
-           "Key should not have been found in region.");
-    // now having the Callbacks set, lets call the loader
-    ASSERT(regionPtr->get(keyPtr) != nullptr, "Expected non null value");
+   ASSERT(!regionPtr->containsKey(keyPtr),
+          "Key should not have been found in region.");
+   // now having the Callbacks set, lets call the loader
+   ASSERT(regionPtr->get(keyPtr) != nullptr, "Expected non null value");
 
-    RegionEntryPtr regEntryPtr = regionPtr->getEntry(keyPtr);
-    CacheablePtr valuePtr = regEntryPtr->getValue();
-    int val = atoi(valuePtr->toString()->asChar());
-    LOGFINE("val for keyPtr is %d", val);
-    numLoads++;
-    validateEventCount(__LINE__);
+   auto regEntryPtr = regionPtr->getEntry(keyPtr);
+   auto valuePtr = regEntryPtr->getValue();
+   int val = atoi(valuePtr->toString()->asChar());
+   LOGFINE("val for keyPtr is %d", val);
+   numLoads++;
+   validateEventCount(__LINE__);
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testDestroy)
   {
-    CacheableKeyPtr keyPtr2 = CacheableKey::create("Key1");
-    regionPtr->destroy(keyPtr2);
-    // Verify the sequence destroy()->get() :- CacheLoader to be invoked.
-    regionPtr->get(keyPtr2);
-    RegionEntryPtr regEntryPtr2 = regionPtr->getEntry(keyPtr2);
-    CacheablePtr valuePtr2 = regEntryPtr2->getValue();
-    int val2 = atoi(valuePtr2->toString()->asChar());
-    LOGFINE("val2 for keyPtr2 is %d", val2);
-    numLoads++;
-    validateEventCount(__LINE__);
+   auto keyPtr2 = CacheableKey::create("Key1");
+   regionPtr->destroy(keyPtr2);
+   // Verify the sequence destroy()->get() :- CacheLoader to be invoked.
+   regionPtr->get(keyPtr2);
+   auto regEntryPtr2 = regionPtr->getEntry(keyPtr2);
+   auto valuePtr2 = regEntryPtr2->getValue();
+   int val2 = atoi(valuePtr2->toString()->asChar());
+   LOGFINE("val2 for keyPtr2 is %d", val2);
+   numLoads++;
+   validateEventCount(__LINE__);
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testInvalidateKey)
   {
-    CacheableKeyPtr keyPtr2 = CacheableKey::create("Key2");
-    regionPtr->put(keyPtr2, "Value2");
-    regionPtr->invalidate(keyPtr2);
-    // Verify the sequence invalidate()->get() :- CacheLoader to be invoked.
-    regionPtr->get(keyPtr2);
-    RegionEntryPtr regEntryPtr = regionPtr->getEntry(keyPtr2);
-    CacheablePtr valuePtr = regEntryPtr->getValue();
-    int val = atoi(valuePtr->toString()->asChar());
-    LOGFINE("val for keyPtr1 is %d", val);
-    numLoads++;
-    validateEventCount(__LINE__);
+   auto keyPtr2 = CacheableKey::create("Key2");
+   regionPtr->put(keyPtr2, "Value2");
+   regionPtr->invalidate(keyPtr2);
+   // Verify the sequence invalidate()->get() :- CacheLoader to be invoked.
+   regionPtr->get(keyPtr2);
+   auto regEntryPtr = regionPtr->getEntry(keyPtr2);
+   auto valuePtr = regEntryPtr->getValue();
+   int val = atoi(valuePtr->toString()->asChar());
+   LOGFINE("val for keyPtr1 is %d", val);
+   numLoads++;
+   validateEventCount(__LINE__);
 
-    // Verify the sequence put()->invalidate()->get()->invalidate()->get() :-
-    // CacheLoader to be invoked twice
-    // once after each get.
-    CacheableKeyPtr keyPtr4 = CacheableKey::create("Key4");
-    regionPtr->put(keyPtr4, "Value4");
-    regionPtr->invalidate(keyPtr4);
-    regionPtr->get(keyPtr4);
-    RegionEntryPtr regEntryPtr1 = regionPtr->getEntry(keyPtr4);
-    CacheablePtr valuePtr1 = regEntryPtr1->getValue();
-    int val1 = atoi(valuePtr1->toString()->asChar());
-    LOGFINE("val1 for keyPtr4 is %d", val1);
-    numLoads++;
-    validateEventCount(__LINE__);
+   // Verify the sequence put()->invalidate()->get()->invalidate()->get() :-
+   // CacheLoader to be invoked twice
+   // once after each get.
+   auto keyPtr4 = CacheableKey::create("Key4");
+   regionPtr->put(keyPtr4, "Value4");
+   regionPtr->invalidate(keyPtr4);
+   regionPtr->get(keyPtr4);
+   auto regEntryPtr1 = regionPtr->getEntry(keyPtr4);
+   auto valuePtr1 = regEntryPtr1->getValue();
+   int val1 = atoi(valuePtr1->toString()->asChar());
+   LOGFINE("val1 for keyPtr4 is %d", val1);
+   numLoads++;
+   validateEventCount(__LINE__);
 
-    regionPtr->invalidate(keyPtr4);
-    regionPtr->get(keyPtr4);
-    RegionEntryPtr regEntryPtr2 = regionPtr->getEntry(keyPtr4);
-    CacheablePtr valuePtr2 = regEntryPtr2->getValue();
-    int val2 = atoi(valuePtr2->toString()->asChar());
-    LOGFINE("val2 for keyPtr4 is %d", val2);
-    numLoads++;
-    validateEventCount(__LINE__);
+   regionPtr->invalidate(keyPtr4);
+   regionPtr->get(keyPtr4);
+   auto regEntryPtr2 = regionPtr->getEntry(keyPtr4);
+   auto valuePtr2 = regEntryPtr2->getValue();
+   int val2 = atoi(valuePtr2->toString()->asChar());
+   LOGFINE("val2 for keyPtr4 is %d", val2);
+   numLoads++;
+   validateEventCount(__LINE__);
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testInvalidateRegion)
   {
-    CacheableKeyPtr keyPtr3 = CacheableKey::create("Key3");
-    regionPtr->put(keyPtr3, "Value3");
-    // Verify the sequence invalidateRegion()->get() :- CacheLoader to be
-    // invoked.
-    regionPtr->invalidateRegion();
-    regionPtr->get(keyPtr3);
-    RegionEntryPtr regEntryPtr = regionPtr->getEntry(keyPtr3);
-    CacheablePtr valuePtr = regEntryPtr->getValue();
-    int val = atoi(valuePtr->toString()->asChar());
-    LOGFINE("val for keyPtr3 is %d", val);
-    numLoads++;
-    validateEventCount(__LINE__);
+   auto keyPtr3 = CacheableKey::create("Key3");
+   regionPtr->put(keyPtr3, "Value3");
+   // Verify the sequence invalidateRegion()->get() :- CacheLoader to be
+   // invoked.
+   regionPtr->invalidateRegion();
+   regionPtr->get(keyPtr3);
+   auto regEntryPtr = regionPtr->getEntry(keyPtr3);
+   auto valuePtr = regEntryPtr->getValue();
+   int val = atoi(valuePtr->toString()->asChar());
+   LOGFINE("val for keyPtr3 is %d", val);
+   numLoads++;
+   validateEventCount(__LINE__);
 
-    // Verify the sequence
-    // put()->invalidateRegion()->get()->invalidateRegion()->get() :-
-    // CacheLoader
-    // to be invoked twice.
-    // once after each get.
-    CacheableKeyPtr keyPtr4 = CacheableKey::create("Key4");
-    regionPtr->put(keyPtr4, "Value4");
-    regionPtr->invalidateRegion();
-    regionPtr->get(keyPtr4);
-    RegionEntryPtr regEntryPtr1 = regionPtr->getEntry(keyPtr4);
-    CacheablePtr valuePtr1 = regEntryPtr1->getValue();
-    int val1 = atoi(valuePtr1->toString()->asChar());
-    LOGFINE("val1 for keyPtr4 is %d", val1);
-    numLoads++;
-    validateEventCount(__LINE__);
+   // Verify the sequence
+   // put()->invalidateRegion()->get()->invalidateRegion()->get() :-
+   // CacheLoader
+   // to be invoked twice.
+   // once after each get.
+   auto keyPtr4 = CacheableKey::create("Key4");
+   regionPtr->put(keyPtr4, "Value4");
+   regionPtr->invalidateRegion();
+   regionPtr->get(keyPtr4);
+   auto regEntryPtr1 = regionPtr->getEntry(keyPtr4);
+   auto valuePtr1 = regEntryPtr1->getValue();
+   int val1 = atoi(valuePtr1->toString()->asChar());
+   LOGFINE("val1 for keyPtr4 is %d", val1);
+   numLoads++;
+   validateEventCount(__LINE__);
 
-    regionPtr->invalidateRegion();
-    regionPtr->get(keyPtr4);
-    RegionEntryPtr regEntryPtr2 = regionPtr->getEntry(keyPtr4);
-    CacheablePtr valuePtr2 = regEntryPtr2->getValue();
-    int val2 = atoi(valuePtr2->toString()->asChar());
-    LOGFINE("val2 for keyPtr4 is %d", val2);
-    numLoads++;
-    validateEventCount(__LINE__);
+   regionPtr->invalidateRegion();
+   regionPtr->get(keyPtr4);
+   auto regEntryPtr2 = regionPtr->getEntry(keyPtr4);
+   auto valuePtr2 = regEntryPtr2->getValue();
+   int val2 = atoi(valuePtr2->toString()->asChar());
+   LOGFINE("val2 for keyPtr4 is %d", val2);
+   numLoads++;
+   validateEventCount(__LINE__);
   }
 END_TASK_DEFINITION
 
diff --git a/cppcache/integration-test/ThinClientMultipleCaches.hpp b/cppcache/integration-test/ThinClientMultipleCaches.hpp
index 637b3689..0cec1645 100644
--- a/cppcache/integration-test/ThinClientMultipleCaches.hpp
+++ b/cppcache/integration-test/ThinClientMultipleCaches.hpp
@@ -23,7 +23,6 @@
 #include <string>
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <geode/CacheFactory.hpp>
 
 #include "CacheHelper.hpp"
@@ -48,8 +47,7 @@ DUNIT_TASK_DEFINITION(SERVER1, CreateServer1)
     LOG("SERVER1 started");
   }
 END_TASK_DEFINITION
-
-RegionPtr createRegionFromCache(std::shared_ptr<Cache> cache) {
+std::shared_ptr<Region> createRegionFromCache(std::shared_ptr<Cache> cache) {
   auto poolFactory = cache->getPoolManager().createFactory();
   CacheHelper::getHelper().addServerLocatorEPs(locatorsG, poolFactory, true);
   poolFactory->create("DistRegionAck");
diff --git a/cppcache/integration-test/ThinClientNotification.hpp b/cppcache/integration-test/ThinClientNotification.hpp
index 089bcce2..a04040ed 100644
--- a/cppcache/integration-test/ThinClientNotification.hpp
+++ b/cppcache/integration-test/ThinClientNotification.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -80,10 +79,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   LOG("Before contains key");
   // if the region is no ack, then we may need to wait...
@@ -176,7 +175,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -189,10 +188,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -214,10 +213,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -239,9 +238,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -253,7 +252,7 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   ASSERT(!regPtr->containsValueForKey(keyPtr),
          "Value should not have been found in region.");
 
-  CacheablePtr theValue = regPtr->get(keyPtr);
+  auto theValue = regPtr->get(keyPtr);
   auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
       theValue);  // force a netsearch
 
@@ -275,9 +274,9 @@ void invalidateEntry(const char* name, const char* key) {
   fprintf(stdout, "Invalidating entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Invalidate entry, verify entry is invalidated
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -296,9 +295,9 @@ void destroyEntry(const char* name, const char* key) {
   fprintf(stdout, "Destroying entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Destroy entry, verify entry is destroyed
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -312,7 +311,7 @@ void destroyEntry(const char* name, const char* key) {
 
 void destroyRegion(const char* name) {
   LOG("destroyRegion() entered.");
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->localDestroyRegion();
   LOG("Region destroyed.");
 }
@@ -340,7 +339,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateRegions1_PoolLocators)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TESTPOOL1_", true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
@@ -353,7 +352,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateRegions2_PoolLocators)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TESTPOOL1_", true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
diff --git a/cppcache/integration-test/ThinClientPdxSerializer.hpp b/cppcache/integration-test/ThinClientPdxSerializer.hpp
index 7e80b6bb..c8965bc9 100644
--- a/cppcache/integration-test/ThinClientPdxSerializer.hpp
+++ b/cppcache/integration-test/ThinClientPdxSerializer.hpp
@@ -27,7 +27,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -154,7 +153,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwoPoolLoc_PDX)
   }
 END_TASK_DEFINITION
 
-void checkPdxInstanceToStringAtServer(RegionPtr regionPtr) {
+void checkPdxInstanceToStringAtServer(std::shared_ptr<Region> regionPtr) {
   auto keyport = CacheableKey::create("success");
   auto boolPtr =
       std::dynamic_pointer_cast<CacheableBoolean>(regionPtr->get(keyport));
@@ -164,7 +163,9 @@ void checkPdxInstanceToStringAtServer(RegionPtr regionPtr) {
 
 DUNIT_TASK_DEFINITION(CLIENT1, JavaPutGet)
   {
-    SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+    auto serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
     serializationRegistry->setPdxSerializer(std::make_shared<TestPdxSerializer>());
 
     auto regPtr0 = getHelper()->getRegion("DistRegionAck");
@@ -196,7 +197,9 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, JavaGet)
   {
-    SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+    auto serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
     serializationRegistry->setPdxSerializer(std::make_shared<TestPdxSerializer>());
 
     LOGDEBUG("JavaGet-1 Line_309");
@@ -222,7 +225,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, putFromVersion1_PS)
     auto regPtr0 = getHelper()->getRegion("DistRegionAck");
     auto key = CacheableKey::create(1);
 
-    SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+    auto serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
     serializationRegistry->setPdxSerializer(std::make_shared<TestPdxSerializerForV1>());
 
     // Create New object and wrap it in PdxWrapper (owner)
@@ -255,9 +260,11 @@ DUNIT_TASK_DEFINITION(CLIENT2, putFromVersion2_PS)
     auto regPtr0 = getHelper()->getRegion("DistRegionAck");
     auto key = CacheableKey::create(1);
 
-
-    SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
-    serializationRegistry->setPdxSerializer(PdxSerializerPtr(new TestPdxSerializerForV2));
+    auto serializationRegistry =
+        CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+            ->getSerializationRegistry();
+    serializationRegistry->setPdxSerializer(
+        std::shared_ptr<PdxSerializer>(new TestPdxSerializerForV2));
 
     // Create New object and wrap it in PdxWrapper (owner)
     auto npt1 = new PdxTests::TestDiffTypePdxSV2(true);
diff --git a/cppcache/integration-test/ThinClientPdxSerializers.hpp b/cppcache/integration-test/ThinClientPdxSerializers.hpp
index e166213d..8eabc70e 100644
--- a/cppcache/integration-test/ThinClientPdxSerializers.hpp
+++ b/cppcache/integration-test/ThinClientPdxSerializers.hpp
@@ -63,7 +63,7 @@ class TestPdxSerializer : public PdxSerializer {
     return objectSize;
   }
 
-  void *fromDataForAddress(PdxReaderPtr pr) {
+  void *fromDataForAddress(std::shared_ptr<PdxReader> pr) {
     try {
       PdxTests::NonPdxAddress *npa = new PdxTests::NonPdxAddress;
       npa->_aptNumber = pr->readInt("_aptNumber");
@@ -75,7 +75,7 @@ class TestPdxSerializer : public PdxSerializer {
     }
   }
 
-  void *fromData(const char *className, PdxReaderPtr pr) {
+  void *fromData(const char *className, std::shared_ptr<PdxReader> pr) {
     ASSERT(strcmp(className, CLASSNAME1) == 0 ||
                strcmp(className, CLASSNAME2) == 0,
            "Unexpected classname in fromData");
@@ -180,7 +180,7 @@ class TestPdxSerializer : public PdxSerializer {
     return (void *)npt;
   }
 
-  bool toDataForAddress(void *testObject, PdxWriterPtr pw) {
+  bool toDataForAddress(void *testObject, std::shared_ptr<PdxWriter> pw) {
     try {
       PdxTests::NonPdxAddress *npa =
           reinterpret_cast<PdxTests::NonPdxAddress *>(testObject);
@@ -193,7 +193,8 @@ class TestPdxSerializer : public PdxSerializer {
     }
   }
 
-  bool toData(void *testObject, const char *className, PdxWriterPtr pw) {
+  bool toData(void *testObject, const char *className,
+              std::shared_ptr<PdxWriter> pw) {
     ASSERT(strcmp(className, CLASSNAME1) == 0 ||
                strcmp(className, CLASSNAME2) == 0,
            "Unexpected classname in toData");
diff --git a/cppcache/integration-test/ThinClientPutAll.hpp b/cppcache/integration-test/ThinClientPutAll.hpp
index fd986c01..545b3267 100644
--- a/cppcache/integration-test/ThinClientPutAll.hpp
+++ b/cppcache/integration-test/ThinClientPutAll.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "testobject/PdxType.hpp"
@@ -92,10 +91,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -207,8 +206,8 @@ void createRegion(const char* name, bool ackMode, bool isCacheEnabled,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, isCacheEnabled, nullptr, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, isCacheEnabled,
+                                          nullptr, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -219,7 +218,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -233,7 +232,7 @@ void createPooledRegionConcurrencyCheckDisabled(
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionConcurrencyCheckDisabled(
+  auto regPtr = getHelper()->createPooledRegionConcurrencyCheckDisabled(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled, concurrencyCheckEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -247,13 +246,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -275,10 +274,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -300,9 +299,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -398,7 +397,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     try {
-      SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+      auto serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
       serializationRegistry->addPdxType(PdxTests::PdxType::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes1::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes2::createDeserializable);
@@ -410,21 +411,21 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     // the client1 will register k0 and k1
     // createEntry( regionNames[0], keys[0], vals[0] );
     // createEntry( regionNames[0], keys[1], vals[1] );
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyPtr0);
     keys1.push_back(keyPtr1);
     regPtr0->registerKeys(keys1);
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
 
-    VectorOfCacheableKey keys2;
+    std::vector<std::shared_ptr<CacheableKey>> keys2;
     keys2.push_back(keyPtr2);
     keys2.push_back(keyPtr3);
     regPtr1->registerKeys(keys2);
@@ -436,7 +437,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
   {
     try {
-      SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+      auto serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
       serializationRegistry->addPdxType(PdxTests::PdxType::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes1::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes2::createDeserializable);
@@ -457,8 +460,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
       map1.emplace(CacheableKey::create(keys[i]),
                    CacheableString::create(vals[i]));
     }
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->putAll(map0);
     regPtr1->putAll(map1);
     LOG("StepFour complete.");
@@ -478,11 +481,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutAllOps)
                        CacheableString::create(value));
     }
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->putAll(entryMap);
     LOG("putAll1 complete");
 
-    VectorOfCacheableKey getAllkeys;
+    std::vector<std::shared_ptr<CacheableKey>> getAllkeys;
     for (int32_t item = 0; item < 500; item++) {
       sprintf(key, "key-%d", item);
       getAllkeys.push_back(CacheableKey::create(key));
@@ -531,8 +534,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepSix)
       map1.emplace(CacheableKey::create(keys[i]),
                    CacheableString::create(nvals[i]));
     }
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->putAll(map0);
     regPtr1->putAll(map1);
 
@@ -589,13 +592,13 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepTen)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionServicePtr rsp = regPtr0->getRegionService();
-    RegionPtr regPtr = rsp->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto rsp = regPtr0->getRegionService();
+    auto regPtr = rsp->getRegion(regionNames[0]);
     ASSERT(regPtr != nullptr, "Failed to get region.");
 
-    RegionServicePtr rsp1 = regPtr0->getRegionService();
-    RegionPtr regPtr1 = rsp1->getRegion("NOT_CREATED_REGION");
+    auto rsp1 = regPtr0->getRegionService();
+    auto regPtr1 = rsp1->getRegion("NOT_CREATED_REGION");
     ASSERT(regPtr1 == nullptr, "Unknown Region Returned");
 
     LOG("StepTen complete.");
@@ -604,10 +607,10 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepEleven)
   {
-    CacheableKeyPtr keyPtr0 = CacheableInt64::create(100L);
-    CacheableKeyPtr valPtr0 = CacheableInt64::create(200L);
+    auto keyPtr0 = CacheableInt64::create(100L);
+    auto valPtr0 = CacheableInt64::create(200L);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
 
     regPtr0->put(keyPtr0, valPtr0);
     auto checkPtr =
@@ -619,7 +622,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEleven)
     ASSERT(checkPtr == nullptr, "checkPtr should be null.");
 
     try {
-      CacheableKeyPtr key;
+      std::shared_ptr<CacheableKey> key;
       regPtr0->invalidate(key);
       FAIL("Invalidate on nullptr should throw exception");
     } catch (IllegalArgumentException e) {
@@ -633,7 +636,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepThirteen)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable map0;
     for (int i = 0; i < 2; i++) {
       map0.emplace(CacheableInt64::create(i), CacheableInt64::create(i));
@@ -680,7 +683,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThirteen)
     auto keyObject6 = std::make_shared<PdxTests::PdxTypes3>();
     map0.emplace(keyObject6, CacheableString::create("testString"));
     regPtr0->putAll(map0);
-    CacheablePtr checkPtr1 = regPtr0->get(keyObject6);
+    auto checkPtr1 = regPtr0->get(keyObject6);
     ASSERT(strcmp(checkPtr1->toString()->asChar(), "testString") == 0,
            "strVal should be testString.");
     map0.clear();
@@ -735,7 +738,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThirteen)
 
     regPtr0->localInvalidateRegion();
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyObject7);
     keys1.push_back(keyObject8);
     const auto values = regPtr0->getAll(keys1);
diff --git a/cppcache/integration-test/ThinClientPutAllTimeout.hpp b/cppcache/integration-test/ThinClientPutAllTimeout.hpp
index 191a814e..a60642b9 100644
--- a/cppcache/integration-test/ThinClientPutAllTimeout.hpp
+++ b/cppcache/integration-test/ThinClientPutAllTimeout.hpp
@@ -37,22 +37,24 @@ static bool isLocator = false;
 const char* locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
 #include "LocatorHelper.hpp"
-TallyListenerPtr reg1Listener1;
-TallyWriterPtr reg1Writer1;
+std::shared_ptr<TallyListener> reg1Listener1;
+std::shared_ptr<TallyWriter> reg1Writer1;
 int numCreates = 0;
 int numUpdates = 0;
 int numInvalidates = 0;
 int numDestroys = 0;
 
-void setCacheListener(const char* regName, TallyListenerPtr regListener) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName,
+                      std::shared_ptr<TallyListener> regListener) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }
 
-void setCacheWriter(const char* regName, TallyWriterPtr regWriter) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheWriter(const char* regName,
+                    std::shared_ptr<TallyWriter> regWriter) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheWriter(regWriter);
 }
 
@@ -150,7 +152,7 @@ void putAllWithOneEntryTimeoutWithCallBackArg(
 DUNIT_TASK_DEFINITION(CLIENT1, testTimeoutException)
   {
     printf("start task testTimeoutException\n");
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
 
     regPtr->registerAllKeys();
 
@@ -189,7 +191,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, testWithoutTimeoutException)
   {
     printf("start task testWithoutTimeoutException\n");
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
 
     // regPtr->registerAllKeys();
 
diff --git a/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp b/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
index 5688b871..3ae93232 100644
--- a/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
+++ b/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "testobject/PdxType.hpp"
@@ -91,10 +90,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
     LOG(buf);
   }
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -206,8 +205,8 @@ void createRegion(const char* name, bool ackMode, bool isCacheEnabled,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, isCacheEnabled, nullptr, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, isCacheEnabled,
+                                          nullptr, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -218,7 +217,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -232,7 +231,7 @@ void createPooledRegionConcurrencyCheckDisabled(
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionConcurrencyCheckDisabled(
+  auto regPtr = getHelper()->createPooledRegionConcurrencyCheckDisabled(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled, concurrencyCheckEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -246,13 +245,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -274,10 +273,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -299,9 +298,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -400,7 +399,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, RegisterClient1Keys)
   {
 
     try {
-      SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+      auto serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
 
       serializationRegistry->addPdxType(PdxTests::PdxType::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes1::createDeserializable);
@@ -413,21 +414,21 @@ DUNIT_TASK_DEFINITION(CLIENT1, RegisterClient1Keys)
     // the client1 will register k0 and k1
     // createEntry( regionNames[0], keys[0], vals[0] );
     // createEntry( regionNames[0], keys[1], vals[1] );
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyPtr0);
     keys1.push_back(keyPtr1);
     regPtr0->registerKeys(keys1);
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
 
-    VectorOfCacheableKey keys2;
+    std::vector<std::shared_ptr<CacheableKey>> keys2;
     keys2.push_back(keyPtr2);
     keys2.push_back(keyPtr3);
     regPtr1->registerKeys(keys2);
@@ -439,7 +440,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterClient2Keys)
   {
     try {
-      SerializationRegistryPtr serializationRegistry = CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())->getSerializationRegistry();
+      auto serializationRegistry =
+          CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
+              ->getSerializationRegistry();
       serializationRegistry->addPdxType(PdxTests::PdxType::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes1::createDeserializable);
       serializationRegistry->addPdxType(PdxTests::PdxTypes2::createDeserializable);
@@ -460,8 +463,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, RegisterClient2Keys)
       map1.emplace(CacheableKey::create(keys[i]),
                    CacheableString::create(vals[i]));
     }
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->putAll(map0, std::chrono::seconds(15),
                     CacheableInt32::create(1000));
     regPtr1->putAll(map1, std::chrono::seconds(15),
@@ -483,13 +486,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutAllOps)
                        CacheableString::create(value));
     }
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->putAll(entryMap, std::chrono::seconds(15),
                     CacheableInt32::create(1000));
 
     LOG("putAll1 complete");
 
-    VectorOfCacheableKey getAllkeys;
+    std::vector<std::shared_ptr<CacheableKey>> getAllkeys;
     for (int32_t item = 0; item < 500; item++) {
       sprintf(key, "key-%d", item);
       getAllkeys.push_back(CacheableKey::create(key));
@@ -599,13 +602,13 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyRegionService)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionServicePtr rsp = regPtr0->getRegionService();
-    RegionPtr regPtr = rsp->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto rsp = regPtr0->getRegionService();
+    auto regPtr = rsp->getRegion(regionNames[0]);
     ASSERT(regPtr != nullptr, "Failed to get region.");
 
-    RegionServicePtr rsp1 = regPtr0->getRegionService();
-    RegionPtr regPtr1 = rsp1->getRegion("NOT_CREATED_REGION");
+    auto rsp1 = regPtr0->getRegionService();
+    auto regPtr1 = rsp1->getRegion("NOT_CREATED_REGION");
     ASSERT(regPtr1 == nullptr, "Unknown Region Returned");
 
     LOG("VerifyRegionService complete.");
@@ -614,10 +617,10 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, InvalidateKeys)
   {
-    CacheableKeyPtr keyPtr0 = CacheableInt64::create(100L);
-    CacheableKeyPtr valPtr0 = CacheableInt64::create(200L);
+    auto keyPtr0 = CacheableInt64::create(100L);
+    auto valPtr0 = CacheableInt64::create(200L);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
 
     regPtr0->put(keyPtr0, valPtr0);
     auto checkPtr =
@@ -629,7 +632,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, InvalidateKeys)
     ASSERT(checkPtr == nullptr, "checkPtr should be null.");
 
     try {
-      CacheableKeyPtr key;
+      std::shared_ptr<CacheableKey> key;
       regPtr0->invalidate(key);
       FAIL("Invalidate on nullptr should throw exception");
     } catch (IllegalArgumentException e) {
@@ -678,7 +681,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyPutAllWithLongKeyAndLongValue)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable map0;
     try {
       map0.emplace(CacheableInt64::create(345),
@@ -766,7 +769,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, VerifyPutAllWithObjectKey)
 
     regPtr0->localInvalidateRegion();
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyObject7);
     keys1.push_back(keyObject8);
     const auto values = regPtr0->getAll(keys1);
diff --git a/cppcache/integration-test/ThinClientPutGetAll.hpp b/cppcache/integration-test/ThinClientPutGetAll.hpp
index c1666b2e..264a25d4 100644
--- a/cppcache/integration-test/ThinClientPutGetAll.hpp
+++ b/cppcache/integration-test/ThinClientPutGetAll.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -59,13 +58,14 @@ const char* _regionNames[] = {"DistRegionAck"};
 
 #include "LocatorHelper.hpp"
 
-void verifyGetAll(RegionPtr region, bool addToLocalCache, const char** _vals,
-                  int startIndex, CacheablePtr callBack = nullptr) {
-  CacheableKeyPtr keyPtr0 = CacheableKey::create(_keys[0]);
-  CacheableKeyPtr keyPtr1 = CacheableKey::create(_keys[1]);
-  CacheableKeyPtr keyPtr2 = CacheableKey::create("keyNotThere");
+void verifyGetAll(std::shared_ptr<Region> region, bool addToLocalCache,
+                  const char** _vals, int startIndex,
+                  std::shared_ptr<Cacheable> callBack = nullptr) {
+  auto keyPtr0 = CacheableKey::create(_keys[0]);
+  auto keyPtr1 = CacheableKey::create(_keys[1]);
+  auto keyPtr2 = CacheableKey::create("keyNotThere");
 
-  VectorOfCacheableKey keys1;
+  std::vector<std::shared_ptr<CacheableKey>> keys1;
   keys1.push_back(keyPtr0);
   keys1.push_back(keyPtr1);
   keys1.push_back(keyPtr2);
@@ -96,9 +96,10 @@ void verifyGetAll(RegionPtr region, bool addToLocalCache, const char** _vals,
   }
 }
 
-void verifyGetAllWithCallBackArg(RegionPtr region, bool addToLocalCache,
-                                 const char** vals, int startIndex,
-                                 CacheablePtr callBack) {
+void verifyGetAllWithCallBackArg(std::shared_ptr<Region> region,
+                                 bool addToLocalCache, const char** vals,
+                                 int startIndex,
+                                 std::shared_ptr<Cacheable> callBack) {
   verifyGetAll(region, addToLocalCache, vals, startIndex, callBack);
 }
 
@@ -109,7 +110,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -148,7 +149,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutAllInitialValuesFromClientOne)
       map0.emplace(CacheableKey::create(_keys[i]),
                    CacheableString::create(_vals[i]));
     }
-    RegionPtr regPtr0 = getHelper()->getRegion(_regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(_regionNames[0]);
     regPtr0->putAll(map0);
     LOG("PutAllInitialValuesFromClientOne complete.");
   }
@@ -157,7 +158,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, GetAllInitialValuesFromClientTwo)
   {
     // getAll and validate key and value.
-    RegionPtr region = getHelper()->getRegion(_regionNames[0]);
+    auto region = getHelper()->getRegion(_regionNames[0]);
     verifyGetAll(region, true, _vals, 0);
     verifyGetAllWithCallBackArg(region, true, _vals, 0,
                                 CacheableInt32::create(1000));
@@ -173,7 +174,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutAllUpdatedValuesFromClientOne)
       map0.emplace(CacheableKey::create(_keys[i]),
                    CacheableString::create(_nvals[i]));
     }
-    RegionPtr regPtr0 = getHelper()->getRegion(_regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(_regionNames[0]);
     regPtr0->putAll(map0);
     LOG("PutAllUpdatedValuesFromClientOne complete.");
   }
@@ -181,7 +182,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, GetAllUpdatedValuesFromClientTwo)
   {
     // verify getAll get the data from local cache.
-    RegionPtr region = getHelper()->getRegion(_regionNames[0]);
+    auto region = getHelper()->getRegion(_regionNames[0]);
     verifyGetAll(region, true, _vals, 0);
     verifyGetAllWithCallBackArg(region, true, _vals, 0,
                                 CacheableInt32::create(1000));
@@ -193,7 +194,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, GetAllAfterLocalDestroyRegionOnClientTwo)
   {
     // getAll and validate key and value after localDestroyRegion and recreation
     // of region.
-    RegionPtr reg0 = getHelper()->getRegion(_regionNames[0]);
+    auto reg0 = getHelper()->getRegion(_regionNames[0]);
     reg0->localDestroyRegion();
     reg0 = nullptr;
     getHelper()->createPooledRegion(regionNames[0], USE_ACK, 0,
@@ -209,7 +210,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, GetAllAfterLocalDestroyRegionOnClientTwo_Pool)
   {
     // getAll and validate key and value after localDestroyRegion and recreation
     // of region.
-    RegionPtr reg0 = getHelper()->getRegion(_regionNames[0]);
+    auto reg0 = getHelper()->getRegion(_regionNames[0]);
     reg0->localDestroyRegion();
     reg0 = nullptr;
     createPooledRegion(_regionNames[0], USE_ACK, locatorsG, poolName, true,
@@ -224,7 +225,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, putallAndGetallPdxWithCallBackArg)
   {
     LOG("putallAndGetallPdxWithCallBackArg started.");
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     try {
@@ -310,7 +311,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, putallAndGetallPdxWithCallBackArg)
     map0.emplace(CacheableInt32::create(29), p9);
     map0.emplace(CacheableInt32::create(30), p10);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(_regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(_regionNames[0]);
     // TODO: Investigate whether callback is used
     regPtr0->putAll(map0, std::chrono::seconds(15),
                     CacheableInt32::create(1001));
@@ -328,7 +329,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, putallAndGetallPdxWithCallBackArg)
     regPtr0->localDestroy(CacheableInt32::create(30));
     LOG("localDestroy on all Pdx objects completed.");
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(CacheableInt32::create(21));
     keys1.push_back(CacheableInt32::create(22));
     keys1.push_back(CacheableInt32::create(23));
@@ -401,7 +402,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, putallAndGetallPdx)
   {
     LOG("putallAndGetallPdx started.");
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     try {
@@ -486,7 +487,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, putallAndGetallPdx)
     map0.emplace(CacheableInt32::create(28), p8);
     map0.emplace(CacheableInt32::create(29), p9);
     map0.emplace(CacheableInt32::create(30), p10);
-    RegionPtr regPtr0 = getHelper()->getRegion(_regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(_regionNames[0]);
     regPtr0->put(CacheableInt32::create(30), p10);
     regPtr0->putAll(map0);
     LOG("putAll on Pdx objects completed.");
@@ -503,7 +504,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, putallAndGetallPdx)
     regPtr0->localDestroy(CacheableInt32::create(30));
     LOG("localDestroy on all Pdx objects completed.");
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(CacheableInt32::create(21));
     keys1.push_back(CacheableInt32::create(22));
     keys1.push_back(CacheableInt32::create(23));
diff --git a/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp b/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
index db18d3e6..3ba99530 100644
--- a/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
+++ b/cppcache/integration-test/ThinClientRIwithlocalRegionDestroy.hpp
@@ -20,7 +20,7 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
+#include <geode/RegionEvent.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -87,14 +87,12 @@ class SimpleCacheListener : public CacheListener {
     }
   }
 
-  virtual void close(const RegionPtr& region) {
+  virtual void close(const std::shared_ptr<Region>& region) {
     LOGINFO("SimpleCacheListener: Got a close event.");
   }
 };
-typedef std::shared_ptr<SimpleCacheListener> SimpleCacheListenerPtr;
-
-SimpleCacheListenerPtr eventListener1 = nullptr;
-SimpleCacheListenerPtr eventListener2 = nullptr;
+std::shared_ptr<SimpleCacheListener> eventListener1 = nullptr;
+std::shared_ptr<SimpleCacheListener> eventListener2 = nullptr;
 
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
@@ -121,7 +119,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -148,26 +146,24 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepOne_Pool_Locator)
     createPooledRegion(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_", true);
 
     // create subregion
-    RegionPtr regptr = getHelper()->getRegion(regionNames[2]);
-    RegionAttributesPtr lattribPtr = regptr->getAttributes();
-    RegionPtr subregPtr1 = regptr->createSubregion(regionNames[3], lattribPtr);
-    RegionPtr subregPtr2 = regptr->createSubregion(regionNames[4], lattribPtr);
-
-    LOGINFO(
-        "NIL: CLIENT1 StepOne_Pool_Locator subregions created successfully");
-
-    // Attache Listener
-    RegionPtr regionPtr0 = getHelper()->getRegion(regionNames[0]);
-    AttributesMutatorPtr attrMutatorPtr = regionPtr0->getAttributesMutator();
-    eventListener1 = std::make_shared<SimpleCacheListener>();
-    attrMutatorPtr->setCacheListener(eventListener1);
-
-    AttributesMutatorPtr subregAttrMutatorPtr =
-        subregPtr1->getAttributesMutator();
-    eventListener2 = std::make_shared<SimpleCacheListener>();
-    subregAttrMutatorPtr->setCacheListener(eventListener2);
-
-    LOG("StepOne_Pool complete.");
+   auto regptr = getHelper()->getRegion(regionNames[2]);
+   std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+   auto subregPtr1 = regptr->createSubregion(regionNames[3], lattribPtr);
+   auto subregPtr2 = regptr->createSubregion(regionNames[4], lattribPtr);
+
+   LOGINFO("NIL: CLIENT1 StepOne_Pool_Locator subregions created successfully");
+
+   // Attache Listener
+   auto regionPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto attrMutatorPtr = regionPtr0->getAttributesMutator();
+   eventListener1 = std::make_shared<SimpleCacheListener>();
+   attrMutatorPtr->setCacheListener(eventListener1);
+
+   auto subregAttrMutatorPtr = subregPtr1->getAttributesMutator();
+   eventListener2 = std::make_shared<SimpleCacheListener>();
+   subregAttrMutatorPtr->setCacheListener(eventListener2);
+
+   LOG("StepOne_Pool complete.");
   }
 END_TASK_DEFINITION
 
@@ -180,48 +176,48 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_Pool_Locator)
     createPooledRegion(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_", true);
 
     // create subregion
-    RegionPtr regptr = getHelper()->getRegion(regionNames[2]);
-    RegionAttributesPtr lattribPtr = regptr->getAttributes();
-    RegionPtr subregPtr1 = regptr->createSubregion(regionNames[3], lattribPtr);
-    RegionPtr subregPtr2 = regptr->createSubregion(regionNames[4], lattribPtr);
-
-    LOGINFO(
-        "NIL: CLIENT2 StepTwo_Pool_Locator:: subregions created successfully");
-    LOG("StepTwo_Pool complete.");
+   auto regptr = getHelper()->getRegion(regionNames[2]);
+   std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+   auto subregPtr1 = regptr->createSubregion(regionNames[3], lattribPtr);
+   auto subregPtr2 = regptr->createSubregion(regionNames[4], lattribPtr);
+
+   LOGINFO(
+       "NIL: CLIENT2 StepTwo_Pool_Locator:: subregions created successfully");
+   LOG("StepTwo_Pool complete.");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, registerKeysOnRegion)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    // RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    //auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     /*regPtr0->registerRegex(testregex[0]);
     regPtr1->registerRegex(testregex[1]);*/
 
-    // NIL
-    VectorOfCacheableKey keys;
-    keys.push_back(CacheableString::create("Key-1"));
-    keys.push_back(CacheableString::create("Key-2"));
-    regPtr0->registerKeys(keys, false);
-    LOGINFO("NIL CLIENT-1 registerAllKeys() done ");
+   // NIL
+   std::vector<std::shared_ptr<CacheableKey>> keys;
+   keys.push_back(CacheableString::create("Key-1"));
+   keys.push_back(CacheableString::create("Key-2"));
+   regPtr0->registerKeys(keys, false);
+   LOGINFO("NIL CLIENT-1 registerAllKeys() done ");
 
-    regPtr0->localDestroyRegion();
-    LOGINFO("NIL CLIENT-1 localDestroyRegion() done");
-    LOG("StepThree complete.");
+   regPtr0->localDestroyRegion();
+   LOGINFO("NIL CLIENT-1 localDestroyRegion() done");
+   LOG("StepThree complete.");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, putOps)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
 
     for (int index = 0; index < 5; index++) {
       char key[100] = {0};
       char value[100] = {0};
       ACE_OS::sprintf(key, "Key-%d", index);
       ACE_OS::sprintf(value, "Value-%d", index);
-      CacheableKeyPtr keyptr = CacheableKey::create(key);
-      CacheablePtr valuePtr = CacheableString::create(value);
+     auto keyptr = CacheableKey::create(key);
+     auto valuePtr = CacheableString::create(value);
       regPtr0->put(keyptr, valuePtr);
     }
     LOG("StepFour complete.");
@@ -230,7 +226,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
 
     regPtr0->registerAllKeys();
     LOGINFO("NIL CLIENT-1 registerAllKeys() done ");
@@ -243,15 +239,15 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
 
     for (int index = 0; index < 5; index++) {
       char key[100] = {0};
       char value[100] = {0};
       ACE_OS::sprintf(key, "Key-%d", index);
       ACE_OS::sprintf(value, "Value-%d", index);
-      CacheableKeyPtr keyptr = CacheableKey::create(key);
-      CacheablePtr valuePtr = CacheableString::create(value);
+     auto keyptr = CacheableKey::create(key);
+     auto valuePtr = CacheableString::create(value);
       regPtr0->put(keyptr, valuePtr);
     }
     LOG("StepFour complete.");
@@ -278,8 +274,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepFive)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->registerRegex(testregex[0]);
     regPtr1->registerRegex(testregex[1]);
     LOGINFO("NIL CLIENT-1 registerRegex() done ");
@@ -292,16 +288,16 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepSix)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     for (int index = 0; index < 5; index++) {
       char key[100] = {0};
       char value[100] = {0};
       ACE_OS::sprintf(key, "Key-%d", index);
       ACE_OS::sprintf(value, "Value-%d", index);
-      CacheableKeyPtr keyptr = CacheableKey::create(key);
-      CacheablePtr valuePtr = CacheableString::create(value);
+     auto keyptr = CacheableKey::create(key);
+     auto valuePtr = CacheableString::create(value);
       regPtr0->put(keyptr, valuePtr);
       regPtr1->put(keyptr, valuePtr);
     }
@@ -312,88 +308,88 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyOps)
   {
     // regPtr0 is destroyed
-    // RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    //auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyptr = CacheableKey::create("Key-2");
+   auto keyptr = CacheableKey::create("Key-2");
 
-    // regPtr0 is destroyed
-    // ASSERT( !regPtr0->containsKey( keyptr ), "Key must not found in region0."
-    // );
+   // regPtr0 is destroyed
+   // ASSERT( !regPtr0->containsKey( keyptr ), "Key must not found in region0."
+   // );
 
-    ASSERT(regPtr1->containsKey(keyptr), "Key must found in region1.");
+   ASSERT(regPtr1->containsKey(keyptr), "Key must found in region1.");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepSeven)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
-    RegionPtr regPtr2 = getHelper()->getRegion(regionNames[2]);
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr1 = getHelper()->getRegion(regionNames[1]);
+   auto regPtr2 = getHelper()->getRegion(regionNames[2]);
 
-    RegionPtr subregPtr0 = regPtr2->getSubregion(regionNames[3]);
-    RegionPtr subregPtr1 = regPtr2->getSubregion(regionNames[4]);
+   auto subregPtr0 = regPtr2->getSubregion(regionNames[3]);
+   auto subregPtr1 = regPtr2->getSubregion(regionNames[4]);
 
-    // 1. registerAllKeys on parent and both subregions
-    regPtr2->registerAllKeys();
-    subregPtr0->registerAllKeys();
-    subregPtr1->registerAllKeys();
+   // 1. registerAllKeys on parent and both subregions
+   regPtr2->registerAllKeys();
+   subregPtr0->registerAllKeys();
+   subregPtr1->registerAllKeys();
 
-    LOGINFO("NIL CLIENT-1 StepSeven ::  registerAllKeys() done ");
+   LOGINFO("NIL CLIENT-1 StepSeven ::  registerAllKeys() done ");
 
-    // 2. Now locally destroy SubRegion1
-    subregPtr0->localDestroyRegion();
-    LOGINFO("NIL CLIENT-1 SubRegion1 locally destroyed successfully");
+   // 2. Now locally destroy SubRegion1
+   subregPtr0->localDestroyRegion();
+   LOGINFO("NIL CLIENT-1 SubRegion1 locally destroyed successfully");
 
-    LOG("NIL: Client-1 StepSeven complete.");
+   LOG("NIL: Client-1 StepSeven complete.");
 
-    /*
-    regPtr0->registerRegex(testregex[0]);
-    regPtr1->registerRegex(testregex[1]);
-    LOGINFO("NIL CLIENT-1 registerRegex() done ");
-    */
+   /*
+   regPtr0->registerRegex(testregex[0]);
+   regPtr1->registerRegex(testregex[1]);
+   LOGINFO("NIL CLIENT-1 registerRegex() done ");
+   */
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepEight)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
-    RegionPtr regPtr2 = getHelper()->getRegion(regionNames[2]);
-
-    RegionPtr subregPtr0 = regPtr2->getSubregion(regionNames[3]);
-    RegionPtr subregPtr1 = regPtr2->getSubregion(regionNames[4]);
-
-    for (int index = 0; index < 5; index++) {
-      char key[100] = {0};
-      char value[100] = {0};
-      ACE_OS::sprintf(key, "Key-%d", index);
-      ACE_OS::sprintf(value, "Value-%d", index);
-      CacheableKeyPtr keyptr = CacheableKey::create(key);
-      CacheablePtr valuePtr = CacheableString::create(value);
-      regPtr2->put(keyptr, valuePtr);
-      subregPtr0->put(keyptr, valuePtr);
-      subregPtr1->put(keyptr, valuePtr);
-    }
-
-    LOG("NIL : Client-2 StepSix complete.");
+   auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+   auto regPtr1 = getHelper()->getRegion(regionNames[1]);
+   auto regPtr2 = getHelper()->getRegion(regionNames[2]);
+
+   auto subregPtr0 = regPtr2->getSubregion(regionNames[3]);
+   auto subregPtr1 = regPtr2->getSubregion(regionNames[4]);
+
+   for (int index = 0; index < 5; index++) {
+     char key[100] = {0};
+     char value[100] = {0};
+     ACE_OS::sprintf(key, "Key-%d", index);
+     ACE_OS::sprintf(value, "Value-%d", index);
+     auto keyptr = CacheableKey::create(key);
+     auto valuePtr = CacheableString::create(value);
+     regPtr2->put(keyptr, valuePtr);
+     subregPtr0->put(keyptr, valuePtr);
+     subregPtr1->put(keyptr, valuePtr);
+   }
+
+   LOG("NIL : Client-2 StepSix complete.");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifySubRegionOps)
   {
-    RegionPtr regPtr2 = getHelper()->getRegion(regionNames[2]);
+   auto regPtr2 = getHelper()->getRegion(regionNames[2]);
     // locally destroyed
-    // RegionPtr subregPtr0 = regPtr2->getSubregion( regionNames[3] );
-    RegionPtr subregPtr1 = regPtr2->getSubregion(regionNames[4]);
+    //auto subregPtr0 = regPtr2->getSubregion( regionNames[3] );
+   auto subregPtr1 = regPtr2->getSubregion(regionNames[4]);
 
     for (int index = 0; index < 5; index++) {
       char key[100] = {0};
       char value[100] = {0};
       ACE_OS::sprintf(key, "Key-%d", index);
       ACE_OS::sprintf(value, "Value-%d", index);
-      CacheableKeyPtr keyptr = CacheableKey::create(key);
-      CacheablePtr valuePtr = CacheableString::create(value);
+     auto keyptr = CacheableKey::create(key);
+     auto valuePtr = CacheableString::create(value);
 
       ASSERT(regPtr2->containsKey(keyptr), "Key must found in region1.");
       ASSERT(subregPtr1->containsKey(keyptr), "Key must found in region1.");
diff --git a/cppcache/integration-test/ThinClientRegex.hpp b/cppcache/integration-test/ThinClientRegex.hpp
index 248dd04c..0114909a 100644
--- a/cppcache/integration-test/ThinClientRegex.hpp
+++ b/cppcache/integration-test/ThinClientRegex.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -83,10 +82,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -201,7 +200,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -214,13 +213,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -242,10 +241,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -267,9 +266,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -327,8 +326,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterClient1Regex)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->registerRegex(testregex[0]);
     regPtr1->registerRegex(testregex[1]);
     LOG("RegisterClient1Regex complete.");
@@ -337,8 +336,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterClient2Regex)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr0->registerRegex(testregex[2]);
     regPtr1->registerRegex(testregex[3]);
     LOG("RegisterClient2Regex complete.");
@@ -360,7 +359,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateAndVerifyClient2Entries)
     verifyEntry(regionNames[0], keys[2], vals[2]);
     verifyEntry(regionNames[1], keys[3], vals[3]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->unregisterRegex(testregex[3]);
 
     LOG("CreateAndVerifyClient2Entries complete.");
@@ -374,7 +373,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, VerifyAndUpdateClient1Entries)
     updateEntry(regionNames[0], keys[2], nvals[2]);
     updateEntry(regionNames[1], keys[3], nvals[3]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->unregisterRegex(testregex[1]);
 
     LOG("VerifyAndUpdateClient1Entries complete.");
diff --git a/cppcache/integration-test/ThinClientRegex2.hpp b/cppcache/integration-test/ThinClientRegex2.hpp
index 817c7292..b78616c1 100644
--- a/cppcache/integration-test/ThinClientRegex2.hpp
+++ b/cppcache/integration-test/ThinClientRegex2.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -84,10 +83,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -200,8 +199,8 @@ void createRegion(const char* name, bool ackMode,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -212,7 +211,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -225,13 +224,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -253,10 +252,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -278,9 +277,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -349,7 +348,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerRegex(regex23);
     LOG("StepThree complete.");
   }
@@ -357,7 +356,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
   {
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->registerRegex(regexWildcard);
     LOG("StepFour complete.");
   }
diff --git a/cppcache/integration-test/ThinClientRegex3.hpp b/cppcache/integration-test/ThinClientRegex3.hpp
index 3028cd83..40ae6e23 100644
--- a/cppcache/integration-test/ThinClientRegex3.hpp
+++ b/cppcache/integration-test/ThinClientRegex3.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -84,10 +83,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -200,8 +199,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -212,7 +211,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -225,13 +224,13 @@ void createEntry(const char* name, const char* key,
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
   if (value == nullptr) {
     value = "";
   }
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -253,10 +252,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -278,9 +277,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -338,8 +337,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterMalformedRegex)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     try {
       LOG("Registering regex: a*");
@@ -359,8 +358,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterEmptyNullAndNonExistentRegex)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     try {
       LOG("Registering empty regex");
diff --git a/cppcache/integration-test/ThinClientRemoveAll.hpp b/cppcache/integration-test/ThinClientRemoveAll.hpp
index 0205cf9c..a1376e9e 100644
--- a/cppcache/integration-test/ThinClientRemoveAll.hpp
+++ b/cppcache/integration-test/ThinClientRemoveAll.hpp
@@ -20,8 +20,10 @@
  * limitations under the License.
  */
 
+#define ROOT_NAME "ThinClientRemoveAll"
+#define ROOT_SCOPE DISTRIBUTED_ACK
+
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "testobject/PdxType.hpp"
@@ -32,8 +34,6 @@
 #include <Utils.hpp>
 #include <geode/statistics/StatisticsFactory.hpp>
 
-#define ROOT_NAME "ThinClientRemoveAll"
-#define ROOT_SCOPE DISTRIBUTED_ACK
 #include "CacheHelper.hpp"
 
 using namespace apache::geode::client;
@@ -88,8 +88,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, isCacheEnabled, nullptr, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, isCacheEnabled,
+                                          nullptr, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -100,7 +100,7 @@ void createRegionLocal(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(
+  auto regPtr = getHelper()->createRegion(
       name, ackMode, isCacheEnabled, nullptr, clientNotificationEnabled, true);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
@@ -113,7 +113,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -127,7 +127,7 @@ void createPooledRegionConcurrencyCheckDisabled(
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionConcurrencyCheckDisabled(
+  auto regPtr = getHelper()->createPooledRegionConcurrencyCheckDisabled(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled, concurrencyCheckEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -192,8 +192,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, removeAllValidation)
   {
     char key[2048];
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    VectorOfCacheableKey removeallkeys;
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    std::vector<std::shared_ptr<CacheableKey>> removeallkeys;
     try {
       regPtr0->removeAll(removeallkeys);
       FAIL("Did not get expected IllegalArgumentException exception");
@@ -244,8 +244,8 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, removeAllValidationLocal)
   {
     char key[2048];
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    VectorOfCacheableKey removeallkeys;
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    std::vector<std::shared_ptr<CacheableKey>> removeallkeys;
     try {
       regPtr0->removeAll(removeallkeys);
       FAIL("Did not get expected IllegalArgumentException exception");
@@ -307,11 +307,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, removeAllOps)
                        CacheableString::create(value));
     }
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->putAll(entryMap);
     LOG("putAll1 complete");
 
-    VectorOfCacheableKey removeallkeys;
+    std::vector<std::shared_ptr<CacheableKey>> removeallkeys;
     for (int32_t item = 0; item < 1; item++) {
       sprintf(key, "key-%d", item);
       removeallkeys.push_back(CacheableKey::create(key));
@@ -336,11 +336,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, removeAllSequence)
     entryMap.emplace(CacheableKey::create(3), CacheableInt32::create(3));
     entryMap.emplace(CacheableKey::create(4), CacheableInt32::create(4));
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->putAll(entryMap);
     LOG("putAll1 complete");
 
-    VectorOfCacheableKey removeallkeys;
+    std::vector<std::shared_ptr<CacheableKey>> removeallkeys;
     removeallkeys.push_back(CacheableKey::create(1));
     removeallkeys.push_back(CacheableKey::create(2));
     removeallkeys.push_back(CacheableKey::create(3));
@@ -381,11 +381,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, removeAllOpsLocal)
                        CacheableString::create(value));
     }
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->putAll(entryMap);
     LOG("putAll1 complete");
 
-    VectorOfCacheableKey removeallkeys;
+    std::vector<std::shared_ptr<CacheableKey>> removeallkeys;
     for (int32_t item = 0; item < 1; item++) {
       sprintf(key, "key-%d", item);
       removeallkeys.push_back(CacheableKey::create(key));
diff --git a/cppcache/integration-test/ThinClientSSL.hpp b/cppcache/integration-test/ThinClientSSL.hpp
index c52b4ece..01dbc194 100644
--- a/cppcache/integration-test/ThinClientSSL.hpp
+++ b/cppcache/integration-test/ThinClientSSL.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -47,7 +46,7 @@ const char* locatorsG =
 #include "LocatorHelper.hpp"
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr props = Properties::create();
+    auto props = Properties::create();
     props->insert("ssl-enabled", "true");
     std::string keystore = std::string(ACE_OS::getenv("TESTSRC")) + "/keystore";
     std::string pubkey = keystore + "/client_truststore.pem";
@@ -89,10 +88,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   LOG("Before contains key");
   // if the region is no ack, then we may need to wait...
@@ -185,7 +184,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -198,10 +197,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -223,10 +222,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -248,9 +247,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -259,7 +258,7 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   ASSERT(!regPtr->containsValueForKey(keyPtr),
          "Value should not have been found in region.");
 
-  CacheablePtr theValue = regPtr->get(keyPtr);
+  auto theValue = regPtr->get(keyPtr);
   auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
       theValue);  // force a netsearch
 
@@ -281,9 +280,9 @@ void invalidateEntry(const char* name, const char* key) {
   fprintf(stdout, "Invalidating entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Invalidate entry, verify entry is invalidated
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -302,9 +301,9 @@ void destroyEntry(const char* name, const char* key) {
   fprintf(stdout, "Destroying entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Destroy entry, verify entry is destroyed
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -318,7 +317,7 @@ void destroyEntry(const char* name, const char* key) {
 
 void destroyRegion(const char* name) {
   LOG("destroyRegion() entered.");
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->localDestroyRegion();
   LOG("Region destroyed.");
 }
@@ -353,7 +352,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateRegions1_PoolLocators)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TESTPOOL1_", true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
@@ -366,7 +365,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateRegions2_PoolLocators)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TESTPOOL1_", true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
diff --git a/cppcache/integration-test/ThinClientSSLWithPassword.hpp b/cppcache/integration-test/ThinClientSSLWithPassword.hpp
index ac74c6ce..22297cc3 100644
--- a/cppcache/integration-test/ThinClientSSLWithPassword.hpp
+++ b/cppcache/integration-test/ThinClientSSLWithPassword.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -47,7 +46,7 @@ const char* locatorsG =
 #include "LocatorHelper.hpp"
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr props = Properties::create();
+    auto props = Properties::create();
     props->insert("ssl-enabled", "true");
     std::string keystore = std::string(ACE_OS::getenv("TESTSRC")) + "/keystore";
     std::string pubkey = keystore + "/client_truststore.pem";
@@ -91,10 +90,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   LOG("Before contains key");
   // if the region is no ack, then we may need to wait...
@@ -186,8 +185,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -199,7 +198,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -212,10 +211,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -237,10 +236,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -262,9 +261,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -273,7 +272,7 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   ASSERT(!regPtr->containsValueForKey(keyPtr),
          "Value should not have been found in region.");
 
-  CacheablePtr theValue = regPtr->get(keyPtr);
+  auto theValue = regPtr->get(keyPtr);
   auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
       theValue);  // force a netsearch
 
@@ -295,9 +294,9 @@ void invalidateEntry(const char* name, const char* key) {
   fprintf(stdout, "Invalidating entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Invalidate entry, verify entry is invalidated
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -316,9 +315,9 @@ void destroyEntry(const char* name, const char* key) {
   fprintf(stdout, "Destroying entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Destroy entry, verify entry is destroyed
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -332,7 +331,7 @@ void destroyEntry(const char* name, const char* key) {
 
 void destroyRegion(const char* name) {
   LOG("destroyRegion() entered.");
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->localDestroyRegion();
   LOG("Region destroyed.");
 }
@@ -367,7 +366,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateRegions1_PoolLocators)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TESTPOOL1_", true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
@@ -380,7 +379,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateRegions2_PoolLocators)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     createPooledRegion(regionNames[1], NO_ACK, locatorsG, "__TESTPOOL1_", true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys(false, false, false);
     regPtr = getHelper()->getRegion(regionNames[1]);
     regPtr->registerAllKeys(false, false, false);
diff --git a/cppcache/integration-test/ThinClientSecurity.hpp b/cppcache/integration-test/ThinClientSecurity.hpp
index 64cfc5b5..ac93f7cd 100644
--- a/cppcache/integration-test/ThinClientSecurity.hpp
+++ b/cppcache/integration-test/ThinClientSecurity.hpp
@@ -37,20 +37,20 @@ static int numberOfLocators = 1;
 const char* locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, numberOfLocators);
 
-void setCacheListener(const char* regName, const CacheListenerPtr& listener) {
+void setCacheListener(const char* regName,
+                      const std::shared_ptr<CacheListener>& listener) {
   if (listener != nullptr) {
-    RegionPtr reg = getHelper()->getRegion(regName);
-    AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+    auto reg = getHelper()->getRegion(regName);
+    auto attrMutator = reg->getAttributesMutator();
     attrMutator->setCacheListener(listener);
   }
 }
 
-void createRegionForSecurity(const char* name, bool ackMode,
-                             bool clientNotificationEnabled = false,
-                             const CacheListenerPtr& listener = nullptr,
-                             bool caching = true, int connections = -1,
-                             bool isMultiuserMode = false,
-                             int subscriptionRedundancy = -1) {
+void createRegionForSecurity(
+    const char* name, bool ackMode, bool clientNotificationEnabled = false,
+    const std::shared_ptr<CacheListener>& listener = nullptr,
+    bool caching = true, int connections = -1, bool isMultiuserMode = false,
+    int subscriptionRedundancy = -1) {
   char msg[128] = {'\0'};
   LOG(msg);
   LOG(" pool is creating");
@@ -69,14 +69,12 @@ void createRegionForSecurity(const char* name, bool ackMode,
   createRegionAndAttachPool(name, ackMode, poolName, caching);
   setCacheListener(name, listener);
 }
-
-PoolPtr getPool(const char* name) {
+std::shared_ptr<Pool> getPool(const char* name) {
   return getHelper()->getCache()->getPoolManager().find(name);
 }
-
-RegionServicePtr getVirtualCache(PropertiesPtr creds, PoolPtr pool) {
-  CachePtr cachePtr = getHelper()->getCache();
-  return cachePtr->createAuthenticatedView(creds, pool->getName());
-}
+ std::shared_ptr<RegionService> getVirtualCache(std::shared_ptr<Properties> creds, std::shared_ptr<Pool> pool) {
+   auto cachePtr = getHelper()->getCache();
+   return cachePtr->createAuthenticatedView(creds, pool->getName());
+ }
 
 #endif  // GEODE_INTEGRATION_TEST_THINCLIENTSECURITY_H_
diff --git a/cppcache/integration-test/ThinClientSecurityHelper.hpp b/cppcache/integration-test/ThinClientSecurityHelper.hpp
index f4570f04..72cdfe38 100644
--- a/cppcache/integration-test/ThinClientSecurityHelper.hpp
+++ b/cppcache/integration-test/ThinClientSecurityHelper.hpp
@@ -20,7 +20,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include "ThinClientHelper.hpp"
 #include "ace/Process.h"
 
@@ -33,8 +32,7 @@ const char* locHostPort =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
 
 const char* regionNamesAuth[] = {"DistRegionAck"};
-
-CredentialGeneratorPtr credentialGeneratorHandler;
+std::shared_ptr<CredentialGenerator> credentialGeneratorHandler;
 
 std::string getXmlPath() {
   char xmlPath[1000] = {'\0'};
@@ -111,44 +109,44 @@ opCodeList::value_type tmpAArr[] = {OP_CREATE,       OP_UPDATE,
 #define TYPE_USER_CLIENT 'U'
 
 void initClientAuth(char UserType) {
-  PropertiesPtr config = Properties::create();
-  opCodeList wr(tmpWArr, tmpWArr + sizeof tmpWArr / sizeof *tmpWArr);
-  opCodeList rt(tmpRArr, tmpRArr + sizeof tmpRArr / sizeof *tmpRArr);
-  opCodeList ad(tmpAArr, tmpAArr + sizeof tmpAArr / sizeof *tmpAArr);
-  credentialGeneratorHandler->getAuthInit(config);
-  switch (UserType) {
-    case 'W':
-      credentialGeneratorHandler->getAllowedCredentialsForOps(wr, config,
-                                                              nullptr);
-      printf("User is %s Pass is %s ",
-             config->find("security-username")->asChar(),
-             (config->find("security-password") != nullptr
-                  ? config->find("security-password")->asChar()
-                  : " not set"));
-      break;
-    case 'R':
-      credentialGeneratorHandler->getAllowedCredentialsForOps(rt, config,
-                                                              nullptr);
-      printf("User is %s Pass is %s ",
-             config->find("security-username")->asChar(),
-             (config->find("security-password") != nullptr
-                  ? config->find("security-password")->asChar()
-                  : " not set"));
-      break;
-    case 'A':
-      credentialGeneratorHandler->getAllowedCredentialsForOps(ad, config,
-                                                              nullptr);
-      printf("User is %s Pass is %s ",
-             config->find("security-username")->asChar(),
-             (config->find("security-password") != nullptr
-                  ? config->find("security-password")->asChar()
-                  : " not set"));
-    default:
-      break;
-  }
+ auto config = Properties::create();
+ opCodeList wr(tmpWArr, tmpWArr + sizeof tmpWArr / sizeof *tmpWArr);
+ opCodeList rt(tmpRArr, tmpRArr + sizeof tmpRArr / sizeof *tmpRArr);
+ opCodeList ad(tmpAArr, tmpAArr + sizeof tmpAArr / sizeof *tmpAArr);
+ credentialGeneratorHandler->getAuthInit(config);
+ switch (UserType) {
+   case 'W':
+     credentialGeneratorHandler->getAllowedCredentialsForOps(wr, config,
+                                                             nullptr);
+     printf("User is %s Pass is %s ",
+            config->find("security-username")->asChar(),
+            (config->find("security-password") != nullptr
+                 ? config->find("security-password")->asChar()
+                 : " not set"));
+     break;
+   case 'R':
+     credentialGeneratorHandler->getAllowedCredentialsForOps(rt, config,
+                                                             nullptr);
+     printf("User is %s Pass is %s ",
+            config->find("security-username")->asChar(),
+            (config->find("security-password") != nullptr
+                 ? config->find("security-password")->asChar()
+                 : " not set"));
+     break;
+   case 'A':
+     credentialGeneratorHandler->getAllowedCredentialsForOps(ad, config,
+                                                             nullptr);
+     printf("User is %s Pass is %s ",
+            config->find("security-username")->asChar(),
+            (config->find("security-password") != nullptr
+                 ? config->find("security-password")->asChar()
+                 : " not set"));
+   default:
+     break;
+ }
 
-  try {
-    initClient(true, config);
+ try {
+   initClient(true, config);
   } catch (...) {
     throw;
   }
@@ -159,7 +157,7 @@ void initClientAuth(char UserType) {
 
 class putThread : public ACE_Task_Base {
  public:
-  putThread(RegionPtr r, bool regInt = false, int waitTime = 0) {
+  putThread(std::shared_ptr<Region> r, bool regInt = false, int waitTime = 0) {
     m_reg = r;
     m_regInt = regInt;
     m_numthreads = 1;
@@ -196,9 +194,9 @@ class putThread : public ACE_Task_Base {
     int ops = 0;
     int32_t pid = ACE_OS::getpid();
     ACE_thread_t thr_id = ACE_OS::thr_self();
-    CacheableKeyPtr key;
-    CacheableStringPtr value;
-    VectorOfCacheableKey keys0;
+    std::shared_ptr<CacheableKey> key;
+    std::shared_ptr<CacheableString> value;
+    std::vector<std::shared_ptr<CacheableKey>> keys0;
     char buf[20];
     char valbuf[20];
     if (m_regInt) {
@@ -216,10 +214,10 @@ class putThread : public ACE_Task_Base {
       key = CacheableKey::create(buf);
       if (m_opcode == 0) {
         if (m_isCallBack) {
-          CacheableBooleanPtr boolptr = CacheableBoolean::create("true");
-          sprintf(valbuf, "client1-value%d", ops);
-          value = CacheableString::create(valbuf);
-          m_reg->put(key, value, boolptr);
+         auto boolptr = CacheableBoolean::create("true");
+         sprintf(valbuf, "client1-value%d", ops);
+         value = CacheableString::create(valbuf);
+         m_reg->put(key, value, boolptr);
         } else {
           sprintf(valbuf, "client2-value%d", ops);
           value = CacheableString::create(valbuf);
@@ -237,8 +235,8 @@ class putThread : public ACE_Task_Base {
       } else {
         try {
           if (m_isCallBack) {
-            CacheableBooleanPtr boolptr = CacheableBoolean::create("true");
-            m_reg->destroy(key, boolptr);
+           auto boolptr = CacheableBoolean::create("true");
+           m_reg->destroy(key, boolptr);
           } else {
             m_reg->destroy(key);
           }
@@ -251,7 +249,7 @@ class putThread : public ACE_Task_Base {
     return 0;
   }
 
-  RegionPtr m_reg;
+  std::shared_ptr<Region> m_reg;
   bool m_run;
   int m_opcode;
   int m_numops;
diff --git a/cppcache/integration-test/ThinClientTXFailover.hpp b/cppcache/integration-test/ThinClientTXFailover.hpp
index 35dc0ade..83fd1a7c 100644
--- a/cppcache/integration-test/ThinClientTXFailover.hpp
+++ b/cppcache/integration-test/ThinClientTXFailover.hpp
@@ -21,7 +21,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/High_Res_Timer.h>
 
 #include <ace/OS.h>
@@ -84,10 +83,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   if (noKey == false) {  // need to find the key!
     ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -155,8 +154,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -167,7 +166,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -181,7 +180,7 @@ void createPooledRegionSticky(const char* name, bool ackMode,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionSticky(
+  auto regPtr = getHelper()->createPooledRegionSticky(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -194,10 +193,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   //  ASSERT( !regPtr->containsKey( keyPtr ), "Key should not have been found in
@@ -219,10 +218,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   //  ASSERT( regPtr->containsKeyOnServer( keyPtr ), "Key should have been found
@@ -245,9 +244,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
diff --git a/cppcache/integration-test/ThinClientTransactions.hpp b/cppcache/integration-test/ThinClientTransactions.hpp
index 82562dfb..c8dc6aa9 100644
--- a/cppcache/integration-test/ThinClientTransactions.hpp
+++ b/cppcache/integration-test/ThinClientTransactions.hpp
@@ -21,7 +21,6 @@
 #define GEODE_INTEGRATION_TEST_THINCLIENTTRANSACTIONS_H_
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/Auto_Event.h>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
@@ -62,7 +61,7 @@ END_TASK_DEFINITION
 
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (g_isGridClient) {
       config->insert("grid-client", "true");
     }
@@ -103,10 +102,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (noKey == false) {  // need to find the key!
@@ -198,9 +197,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
-      getHelper()->createRegion(name, ackMode, cachingEnable, nullptr,
-                                endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, cachingEnable, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -211,7 +209,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -225,7 +223,7 @@ void createPooledRegionSticky(const char* name, bool ackMode,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionSticky(
+  auto regPtr = getHelper()->createPooledRegionSticky(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -238,10 +236,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -262,9 +260,9 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
   sprintf(message, "Creating entry -- key: %s  value: %s in region %s\n", key,
           value, name);
   LOG(message);
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->create(keyPtr, valPtr);
   try {
     regPtr->create(keyPtr, valPtr);
@@ -285,10 +283,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -309,9 +307,9 @@ void doGetAgain(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "get  region name%s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -341,9 +339,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   fflush(stdout);
   static int count = 0;
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -393,7 +391,7 @@ const bool NO_ACK = false;
 
 class SuspendTransactionThread : public ACE_Task_Base {
  private:
-  TransactionIdPtr m_suspendedTransaction;
+  std::shared_ptr<TransactionId> m_suspendedTransaction;
   bool m_sleep;
   ACE_Auto_Event* m_txEvent;
 
@@ -406,8 +404,7 @@ class SuspendTransactionThread : public ACE_Task_Base {
     sprintf(buf, " In SuspendTransactionThread");
     LOG(buf);
 
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
 
     txManager->begin();
 
@@ -435,11 +432,13 @@ class SuspendTransactionThread : public ACE_Task_Base {
   }
   void start() { activate(); }
   void stop() { wait(); }
-  TransactionIdPtr getSuspendedTx() { return m_suspendedTransaction; }
+  std::shared_ptr<TransactionId> getSuspendedTx() {
+    return m_suspendedTransaction;
+  }
 };
 class ResumeTransactionThread : public ACE_Task_Base {
  private:
-  TransactionIdPtr m_suspendedTransaction;
+  std::shared_ptr<TransactionId> m_suspendedTransaction;
   bool m_commit;
   bool m_tryResumeWithSleep;
   bool m_isFailed;
@@ -447,8 +446,9 @@ class ResumeTransactionThread : public ACE_Task_Base {
   ACE_Auto_Event* m_txEvent;
 
  public:
-  ResumeTransactionThread(TransactionIdPtr suspendedTransaction, bool commit,
-                          bool tryResumeWithSleep, ACE_Auto_Event* txEvent)
+  ResumeTransactionThread(std::shared_ptr<TransactionId> suspendedTransaction,
+                          bool commit, bool tryResumeWithSleep,
+                          ACE_Auto_Event* txEvent)
       : m_suspendedTransaction(suspendedTransaction),
         m_commit(commit),
         m_tryResumeWithSleep(tryResumeWithSleep),
@@ -460,15 +460,15 @@ class ResumeTransactionThread : public ACE_Task_Base {
     sprintf(buf, "In ResumeTransactionThread");
     LOG(buf);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     THREADERRORCHECK(regPtr0 != nullptr,
                      "In ResumeTransactionThread - Region not found.");
 
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
-    CacheableKeyPtr keyPtr6 = createKey(keys[6]);
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
+    auto keyPtr6 = createKey(keys[6]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     THREADERRORCHECK(regPtr1 != nullptr,
                      "In ResumeTransactionThread - Region not found.");
 
@@ -480,8 +480,7 @@ class ResumeTransactionThread : public ACE_Task_Base {
                      "In ResumeTransactionThread - Key should not have been "
                      "found in region.");
 
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
     if (m_tryResumeWithSleep) {
       THREADERRORCHECK(!txManager->isSuspended(m_suspendedTransaction),
                        "In ResumeTransactionThread - the transaction should "
@@ -595,20 +594,19 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeCommit)
   {
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr0 != nullptr, "In SuspendResumeCommit - Region not found.");
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     ASSERT(regPtr1 != nullptr, "In SuspendResumeCommit - Region not found.");
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
-    CacheableKeyPtr keyPtr6 = createKey(keys[6]);
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
+    auto keyPtr6 = createKey(keys[6]);
 
     txManager->begin();
     createEntry(regionNames[0], keys[4], vals[4]);
     createEntry(regionNames[1], keys[5], vals[5]);
-    TransactionIdPtr m_suspendedTransaction = txManager->suspend();
+    auto m_suspendedTransaction = txManager->suspend();
 
     ASSERT(
         !regPtr0->containsKeyOnServer(keyPtr4),
@@ -672,21 +670,20 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, SuspendTimeOut)
   {
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr0 != nullptr, "In SuspendTimeOut - Region not found.");
 
     txManager->begin();
     createEntry(regionNames[0], keys[4], vals[4]);
-    TransactionIdPtr tid1 = txManager->suspend();
+    auto tid1 = txManager->suspend();
 
     txManager->begin();
     createEntry(regionNames[0], keys[5], vals[5]);
-    TransactionIdPtr tid2 = txManager->suspend();
+    auto tid2 = txManager->suspend();
 
     txManager->resume(tid1);
     createEntry(regionNames[0], keys[6], vals[6]);
@@ -713,21 +710,20 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeRollback)
   {
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
-    CacheableKeyPtr keyPtr6 = createKey(keys[6]);
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
+    auto keyPtr6 = createKey(keys[6]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr0 != nullptr, "In SuspendResumeRollback - Region not found.");
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     ASSERT(regPtr1 != nullptr, "In SuspendResumeRollback - Region not found.");
 
     txManager->begin();
     createEntry(regionNames[0], keys[4], vals[4]);
     createEntry(regionNames[1], keys[5], vals[5]);
-    TransactionIdPtr m_suspendedTransaction = txManager->suspend();
+    auto m_suspendedTransaction = txManager->suspend();
 
     ASSERT(
         !regPtr0->containsKeyOnServer(keyPtr4),
@@ -957,8 +953,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1Entries)
   {
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
     txManager->begin();
     createEntry(regionNames[0], keys[0], vals[0]);
     createEntry(regionNames[1], keys[2], vals[2]);
@@ -971,8 +966,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2Entries)
   {
     doNetsearch(regionNames[0], keys[0], vals[0]);
     doNetsearch(regionNames[1], keys[2], vals[2]);
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
     txManager->begin();
     createEntry(regionNames[0], keys[1], vals[1]);
     createEntry(regionNames[1], keys[3], vals[3]);
@@ -984,8 +978,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2Entries)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, UpdateClient1Entries)
   {
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     auto vec0 = reg0->serverKeys();
     auto vec1 = reg1->serverKeys();
     ASSERT(vec0.size() == 2, "Should have 2 keys in first region.");
@@ -1018,8 +1012,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, UpdateClient2Entries)
   {
     doNetsearch(regionNames[0], keys[0], vals[0]);
     doNetsearch(regionNames[1], keys[2], vals[2]);
-    CacheTransactionManagerPtr txManager =
-        getHelper()->getCache()->getCacheTransactionManager();
+    auto txManager = getHelper()->getCache()->getCacheTransactionManager();
     txManager->begin();
     updateEntry(regionNames[0], keys[1], nvals[1]);
     updateEntry(regionNames[1], keys[3], nvals[3]);
@@ -1035,10 +1028,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1KeyThriceWithoutSticky)
   {
     createPooledRegion(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_", false,
                        false);
-    RegionPtr reg = getHelper()->getRegion(regionNames[2]);
+    auto reg = getHelper()->getRegion(regionNames[2]);
     LOG("REGION Created with Caching Enabled false");
-    CacheableKeyPtr keyPtr = createKey(CREATE_TWICE_KEY);
-    CacheableStringPtr valPtr = CacheableString::create(CREATE_TWICE_VALUE);
+    auto keyPtr = createKey(CREATE_TWICE_KEY);
+    auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
     try {
       reg->create(keyPtr, valPtr);
       char message[200];
@@ -1063,17 +1056,16 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1KeyThriceWithSticky)
   {
     createPooledRegionSticky(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_",
                              false, false);
-    RegionPtr reg = getHelper()->getRegion(regionNames[2]);
+    auto reg = getHelper()->getRegion(regionNames[2]);
     LOG("REGION Created with Caching Enabled false");
-    CacheableKeyPtr keyPtr = createKey(CREATE_TWICE_KEY);
-    CacheableStringPtr valPtr = CacheableString::create(CREATE_TWICE_VALUE);
+    auto keyPtr = createKey(CREATE_TWICE_KEY);
+    auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
 
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     reg0->localInvalidate(createKey(keys[1]));
     reg1->localInvalidate(createKey(keys[3]));
-    PoolPtr pool =
-        getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
+    auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
     ASSERT(pool != nullptr, "Pool Should have been found");
     doNetsearch(regionNames[0], keys[1], nvals[1]);
     doNetsearch(regionNames[1], keys[3], nvals[3]);
diff --git a/cppcache/integration-test/ThinClientTransactionsXA.hpp b/cppcache/integration-test/ThinClientTransactionsXA.hpp
index 05fe9904..1b2e4f13 100644
--- a/cppcache/integration-test/ThinClientTransactionsXA.hpp
+++ b/cppcache/integration-test/ThinClientTransactionsXA.hpp
@@ -21,7 +21,6 @@
 #define GEODE_INTEGRATION_TEST_THINCLIENTTRANSACTIONSXA_H_
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/Auto_Event.h>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
@@ -61,7 +60,7 @@ END_TASK_DEFINITION
 
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (g_isGridClient) {
       config->insert("grid-client", "true");
     }
@@ -102,10 +101,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (noKey == false) {  // need to find the key!
@@ -197,9 +196,8 @@ void createRegion(const char* name, bool ackMode, const char* endpoints,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
-      getHelper()->createRegion(name, ackMode, cachingEnable, nullptr,
-                                endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, cachingEnable, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -210,7 +208,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -224,7 +222,7 @@ void createPooledRegionSticky(const char* name, bool ackMode,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createPooledRegionSticky(
+  auto regPtr = getHelper()->createPooledRegionSticky(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -237,10 +235,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -261,9 +259,9 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
   sprintf(message, "Creating entry -- key: %s  value: %s in region %s\n", key,
           value, name);
   LOG(message);
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
+  auto regPtr = getHelper()->getRegion(name);
   regPtr->create(keyPtr, valPtr);
   try {
     regPtr->create(keyPtr, valPtr);
@@ -284,10 +282,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -308,9 +306,9 @@ void doGetAgain(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "get  region name%s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -340,9 +338,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   fflush(stdout);
   static int count = 0;
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -392,7 +390,7 @@ const bool NO_ACK = false;
 
 class SuspendTransactionThread : public ACE_Task_Base {
  private:
-  TransactionIdPtr m_suspendedTransaction;
+  std::shared_ptr<TransactionId> m_suspendedTransaction;
   bool m_sleep;
   ACE_Auto_Event* m_txEvent;
 
@@ -435,11 +433,13 @@ class SuspendTransactionThread : public ACE_Task_Base {
   }
   void start() { activate(); }
   void stop() { wait(); }
-  TransactionIdPtr getSuspendedTx() { return m_suspendedTransaction; }
+  std::shared_ptr<TransactionId> getSuspendedTx() {
+    return m_suspendedTransaction;
+  }
 };
 class ResumeTransactionThread : public ACE_Task_Base {
  private:
-  TransactionIdPtr m_suspendedTransaction;
+  std::shared_ptr<TransactionId> m_suspendedTransaction;
   bool m_commit;
   bool m_tryResumeWithSleep;
   bool m_isFailed;
@@ -447,8 +447,9 @@ class ResumeTransactionThread : public ACE_Task_Base {
   ACE_Auto_Event* m_txEvent;
 
  public:
-  ResumeTransactionThread(TransactionIdPtr suspendedTransaction, bool commit,
-                          bool tryResumeWithSleep, ACE_Auto_Event* txEvent)
+  ResumeTransactionThread(std::shared_ptr<TransactionId> suspendedTransaction,
+                          bool commit, bool tryResumeWithSleep,
+                          ACE_Auto_Event* txEvent)
       : m_suspendedTransaction(suspendedTransaction),
         m_commit(commit),
         m_tryResumeWithSleep(tryResumeWithSleep),
@@ -460,15 +461,15 @@ class ResumeTransactionThread : public ACE_Task_Base {
     sprintf(buf, "In ResumeTransactionThread");
     LOG(buf);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     THREADERRORCHECK(regPtr0 != nullptr,
                      "In ResumeTransactionThread - Region not found.");
 
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
-    CacheableKeyPtr keyPtr6 = createKey(keys[6]);
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
+    auto keyPtr6 = createKey(keys[6]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     THREADERRORCHECK(regPtr1 != nullptr,
                      "In ResumeTransactionThread - Region not found.");
 
@@ -601,18 +602,18 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeCommit)
     auto txManager =
         std::dynamic_pointer_cast<InternalCacheTransactionManager2PC>(
             getHelper()->getCache()->getCacheTransactionManager());
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr0 != nullptr, "In SuspendResumeCommit - Region not found.");
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     ASSERT(regPtr1 != nullptr, "In SuspendResumeCommit - Region not found.");
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
-    CacheableKeyPtr keyPtr6 = createKey(keys[6]);
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
+    auto keyPtr6 = createKey(keys[6]);
 
     txManager->begin();
     createEntry(regionNames[0], keys[4], vals[4]);
     createEntry(regionNames[1], keys[5], vals[5]);
-    TransactionIdPtr m_suspendedTransaction = txManager->suspend();
+    auto m_suspendedTransaction = txManager->suspend();
 
     ASSERT(
         !regPtr0->containsKeyOnServer(keyPtr4),
@@ -680,19 +681,19 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendTimeOut)
     auto txManager =
         std::dynamic_pointer_cast<InternalCacheTransactionManager2PC>(
             getHelper()->getCache()->getCacheTransactionManager());
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr0 != nullptr, "In SuspendTimeOut - Region not found.");
 
     txManager->begin();
     createEntry(regionNames[0], keys[4], vals[4]);
-    TransactionIdPtr tid1 = txManager->suspend();
+    auto tid1 = txManager->suspend();
 
     txManager->begin();
     createEntry(regionNames[0], keys[5], vals[5]);
-    TransactionIdPtr tid2 = txManager->suspend();
+    auto tid2 = txManager->suspend();
 
     txManager->resume(tid1);
     createEntry(regionNames[0], keys[6], vals[6]);
@@ -723,19 +724,19 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeRollback)
     auto txManager =
         std::dynamic_pointer_cast<InternalCacheTransactionManager2PC>(
             getHelper()->getCache()->getCacheTransactionManager());
-    CacheableKeyPtr keyPtr4 = createKey(keys[4]);
-    CacheableKeyPtr keyPtr5 = createKey(keys[5]);
-    CacheableKeyPtr keyPtr6 = createKey(keys[6]);
+    auto keyPtr4 = createKey(keys[4]);
+    auto keyPtr5 = createKey(keys[5]);
+    auto keyPtr6 = createKey(keys[6]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr0 != nullptr, "In SuspendResumeRollback - Region not found.");
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     ASSERT(regPtr1 != nullptr, "In SuspendResumeRollback - Region not found.");
 
     txManager->begin();
     createEntry(regionNames[0], keys[4], vals[4]);
     createEntry(regionNames[1], keys[5], vals[5]);
-    TransactionIdPtr m_suspendedTransaction = txManager->suspend();
+    auto m_suspendedTransaction = txManager->suspend();
 
     ASSERT(
         !regPtr0->containsKeyOnServer(keyPtr4),
@@ -997,8 +998,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepFour)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepFive)
   {
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     auto vec0 = reg0->serverKeys();
     auto vec1 = reg1->serverKeys();
     ASSERT(vec0.size() == 2, "Should have 2 keys in first region.");
@@ -1050,10 +1051,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool)
   {
     createPooledRegion(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_", false,
                        false);
-    RegionPtr reg = getHelper()->getRegion(regionNames[2]);
+    auto reg = getHelper()->getRegion(regionNames[2]);
     LOG("REGION Created with Caching Enabled false");
-    CacheableKeyPtr keyPtr = createKey(CREATE_TWICE_KEY);
-    CacheableStringPtr valPtr = CacheableString::create(CREATE_TWICE_VALUE);
+    auto keyPtr = createKey(CREATE_TWICE_KEY);
+    auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
     try {
       reg->create(keyPtr, valPtr);
       char message[200];
@@ -1078,17 +1079,16 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool_Sticky)
   {
     createPooledRegionSticky(regionNames[2], NO_ACK, locatorsG, "__TESTPOOL1_",
                              false, false);
-    RegionPtr reg = getHelper()->getRegion(regionNames[2]);
+    auto reg = getHelper()->getRegion(regionNames[2]);
     LOG("REGION Created with Caching Enabled false");
-    CacheableKeyPtr keyPtr = createKey(CREATE_TWICE_KEY);
-    CacheableStringPtr valPtr = CacheableString::create(CREATE_TWICE_VALUE);
+    auto keyPtr = createKey(CREATE_TWICE_KEY);
+    auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
 
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     reg0->localInvalidate(createKey(keys[1]));
     reg1->localInvalidate(createKey(keys[3]));
-    PoolPtr pool =
-        getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
+    auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
     ASSERT(pool != nullptr, "Pool Should have been found");
     doNetsearch(regionNames[0], keys[1], nvals[1]);
     doNetsearch(regionNames[1], keys[3], nvals[3]);
diff --git a/cppcache/integration-test/ThinClientVersionedOps.hpp b/cppcache/integration-test/ThinClientVersionedOps.hpp
index 9319c7c8..54f26c60 100644
--- a/cppcache/integration-test/ThinClientVersionedOps.hpp
+++ b/cppcache/integration-test/ThinClientVersionedOps.hpp
@@ -48,30 +48,26 @@ bool isLocalServer1 = false;
 static bool isLocator1 = false;
 const char *locatorsG =
     CacheHelper::getLocatorHostPort(isLocator1, isLocalServer1, 1);
-
-CacheableStringPtr c1v11;
-CacheableStringPtr c1v12;
-CacheableStringPtr c1v13;
-CacheableStringPtr c1v14;
-CacheableStringPtr c1v15;
-
-CacheableStringPtr s1v11;
-CacheableStringPtr s1v12;
-CacheableStringPtr s1v13;
-CacheableStringPtr s1v14;
-CacheableStringPtr s1v15;
-
-CacheableStringPtr c2v11;
-CacheableStringPtr c2v12;
-CacheableStringPtr c2v13;
-CacheableStringPtr c2v14;
-CacheableStringPtr c2v15;
-
-CacheableStringPtr s2v11;
-CacheableStringPtr s2v12;
-CacheableStringPtr s2v13;
-CacheableStringPtr s2v14;
-CacheableStringPtr s2v15;
+std::shared_ptr<CacheableString> c1v11;
+std::shared_ptr<CacheableString> c1v12;
+std::shared_ptr<CacheableString> c1v13;
+std::shared_ptr<CacheableString> c1v14;
+std::shared_ptr<CacheableString> c1v15;
+std::shared_ptr<CacheableString> s1v11;
+std::shared_ptr<CacheableString> s1v12;
+std::shared_ptr<CacheableString> s1v13;
+std::shared_ptr<CacheableString> s1v14;
+std::shared_ptr<CacheableString> s1v15;
+std::shared_ptr<CacheableString> c2v11;
+std::shared_ptr<CacheableString> c2v12;
+std::shared_ptr<CacheableString> c2v13;
+std::shared_ptr<CacheableString> c2v14;
+std::shared_ptr<CacheableString> c2v15;
+std::shared_ptr<CacheableString> s2v11;
+std::shared_ptr<CacheableString> s2v12;
+std::shared_ptr<CacheableString> s2v13;
+std::shared_ptr<CacheableString> s2v14;
+std::shared_ptr<CacheableString> s2v15;
 
 void verifyAllValues() {
   LOGINFO("verifyAllValues TEST-1");
@@ -138,14 +134,14 @@ DUNIT_TASK_DEFINITION(CLIENT1, StartClient1)
     // 0/*redundancy*/, true/*clientNotification*/,
     // -1/*subscriptionAckInterval*/,
     // 5/*connections*/, 60000/*loadConditioningInterval*/);
-    // RegionPtr regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK,
+    //auto regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK,
     // nullptr);
 
     initClient(true);
     getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, -1,
                                         std::chrono::milliseconds::zero(), -1,
                                         false, group1);
-    RegionPtr regPtr0 = getHelper()->createRegionAndAttachPool(
+    auto regPtr0 = getHelper()->createRegionAndAttachPool(
         regNames[0], USE_ACK, "__TEST_POOL1__", true);
     LOG("StepOne_Pooled_Locator1 complete.");
 
@@ -171,7 +167,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StartClient2)
     gfendpoints2.c_str(), nullptr, 0, true, -1, 5, 60000); LOG( "Client-2 Init
     -5" );
 
-    RegionPtr regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK, nullptr);
+   auto regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK, nullptr);
     LOG( "Client-2 Init -6" );
 
     */
@@ -179,7 +175,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StartClient2)
     getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, -1,
                                         std::chrono::milliseconds::zero(), -1,
                                         false, group2);
-    RegionPtr regPtr0 = getHelper()->createRegionAndAttachPool(
+   auto regPtr0 = getHelper()->createRegionAndAttachPool(
         regNames[0], USE_ACK, "__TEST_POOL1__", true);
     LOG("StepOne_Pooled_Locator1 complete.");
 
@@ -191,7 +187,7 @@ END_TASK_DEFINITION
 // threadPutonClient1
 DUNIT_TASK_DEFINITION(CLIENT1, threadPutonClient1)
   {
-    RegionPtr rptr = getHelper()->getRegion(regNames[0]);
+    auto rptr = getHelper()->getRegion(regNames[0]);
     thread4 = new putThread(rptr, false);
     thread4->setParams(0, 10, 1, true, false, 0);
     thread4->start();
@@ -201,20 +197,20 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, transactionPutOnClient2)
   {
-    RegionPtr rptr = getHelper()->getRegion(regNames[0]);
-    CacheTransactionManagerPtr txManager =
+   auto rptr = getHelper()->getRegion(regNames[0]);
+   auto txManager =
         getHelper()->getCache()->getCacheTransactionManager();
 
-    txManager->begin();
-    CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
-    CacheableStringPtr valPtr = CacheableString::create("client2-value1");
+   txManager->begin();
+   auto keyPtr1 = CacheableKey::create("key-1");
+   auto valPtr = CacheableString::create("client2-value1");
     rptr->put(keyPtr1, valPtr);
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
+    auto keyPtr2 = CacheableKey::create("key-2");
     valPtr = CacheableString::create("client2-value2");
     rptr->put(keyPtr2, valPtr);
 
-    CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
+    auto keyPtr3 = CacheableKey::create("key-3");
     valPtr = CacheableString::create("client2-value3");
     rptr->put(keyPtr3, valPtr);
     txManager->commit();
@@ -270,56 +266,56 @@ DUNIT_TASK_DEFINITION(CLIENT1, verifyGetonClient1)
     thread4->stop();
     delete thread4;
 
-    RegionPtr rptr = getHelper()->getRegion(regNames[0]);
-
-    CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
-    CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
-    CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
-
-    // localGet
-    c1v11 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr1));
-    c1v12 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr2));
-    c1v13 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr3));
-
-    // localDestroy
-    rptr->localDestroy(keyPtr1);
-    rptr->localDestroy(keyPtr2);
-    rptr->localDestroy(keyPtr3);
-
-    // remoteGet
-    s1v11 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr1));
-    s1v12 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr2));
-    s1v13 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr3));
-
-    // Print remoteGet Values
-    LOGINFO(
-        "CLIENT-2 :: verifyGetonClient1: localGet Val1 = %s remoteGet Val1 = "
-        "%s ",
-        c1v11->asChar(), s1v11->asChar());
-    LOGINFO(
-        "CLIENT-2 :: verifyGetonClient1: localGet Val2 = %s remoteGet Val2 = "
-        "%s ",
-        c1v12->asChar(), s1v12->asChar());
-    LOGINFO(
-        "CLIENT-2 :: verifyGetonClient1: localGet Val3 = %s remoteGet Val3 = "
-        "%s ",
-        c1v13->asChar(), s1v13->asChar());
-
-    ASSERT(*c1v11.get() == *s1v11.get(),
-           "verifyGetonClient1:Values should be equal-1");
-    ASSERT(*c1v12.get() == *s1v12.get(),
-           "verifyGetonClient1:Values should be equal-2");
-    ASSERT(*c1v13.get() == *s1v13.get(),
-           "verifyGetonClient1:Values should be equal-3");
-
-    LOG("CLIENT-2 :: TASK: verifyGetonClient1 completed successfully");
+   auto rptr = getHelper()->getRegion(regNames[0]);
+
+   auto keyPtr1 = CacheableKey::create("key-1");
+   auto keyPtr2 = CacheableKey::create("key-2");
+   auto keyPtr3 = CacheableKey::create("key-3");
+
+   // localGet
+   c1v11 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr1));
+   c1v12 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr2));
+   c1v13 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr3));
+
+   // localDestroy
+   rptr->localDestroy(keyPtr1);
+   rptr->localDestroy(keyPtr2);
+   rptr->localDestroy(keyPtr3);
+
+   // remoteGet
+   s1v11 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr1));
+   s1v12 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr2));
+   s1v13 = std::dynamic_pointer_cast<CacheableString>(rptr->get(keyPtr3));
+
+   // Print remoteGet Values
+   LOGINFO(
+       "CLIENT-2 :: verifyGetonClient1: localGet Val1 = %s remoteGet Val1 = "
+       "%s ",
+       c1v11->asChar(), s1v11->asChar());
+   LOGINFO(
+       "CLIENT-2 :: verifyGetonClient1: localGet Val2 = %s remoteGet Val2 = "
+       "%s ",
+       c1v12->asChar(), s1v12->asChar());
+   LOGINFO(
+       "CLIENT-2 :: verifyGetonClient1: localGet Val3 = %s remoteGet Val3 = "
+       "%s ",
+       c1v13->asChar(), s1v13->asChar());
+
+   ASSERT(*c1v11.get() == *s1v11.get(),
+          "verifyGetonClient1:Values should be equal-1");
+   ASSERT(*c1v12.get() == *s1v12.get(),
+          "verifyGetonClient1:Values should be equal-2");
+   ASSERT(*c1v13.get() == *s1v13.get(),
+          "verifyGetonClient1:Values should be equal-3");
+
+   LOG("CLIENT-2 :: TASK: verifyGetonClient1 completed successfully");
   }
 END_TASK_DEFINITION
 
 //
 DUNIT_TASK_DEFINITION(CLIENT1, PutOnClient1)
   {
-    RegionPtr rptr = getHelper()->getRegion(regNames[0]);
+   auto rptr = getHelper()->getRegion(regNames[0]);
     thread1 = new putThread(rptr, false);
     thread1->setParams(0, 5, 1, true, false, 1);
     thread1->start();
@@ -329,7 +325,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, PutOnClient2)
   {
-    RegionPtr rptr = getHelper()->getRegion(regNames[0]);
+   auto rptr = getHelper()->getRegion(regNames[0]);
     thread2 = new putThread(rptr, false);
     thread2->setParams(0, 5, 1, false, false, 0);  // 0, 5, 1, false, false, 0
     thread2->start();
@@ -339,7 +335,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, testServerGC)
   {
-    RegionPtr rptr = getHelper()->getRegion(regNames[0]);
+    auto rptr = getHelper()->getRegion(regNames[0]);
     thread3 = new putThread(rptr, false);
     thread3->setParams(0, 5000, 1, true, false, 0);  // 0, 5, 1, false, false, 0
     thread3->start();
@@ -363,130 +359,128 @@ DUNIT_TASK_DEFINITION(CLIENT1, GetOnClient1)
     thread1->stop();
     delete thread1;
     dunit::sleep(3000);
-    RegionPtr regPtr = getHelper()->getRegion(regNames[0]);
+   auto regPtr = getHelper()->getRegion(regNames[0]);
     // localGet
-    CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
-    CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
-    CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
-    CacheableKeyPtr keyPtr4 = CacheableKey::create("key-4");
-    CacheableKeyPtr keyPtr5 = CacheableKey::create("key-5");
-
-    c1v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
-    c1v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
-    c1v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
-    c1v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
-    c1v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
-
-    // Print local Get Values
-    LOGINFO("CLIENT-1 :: local GET operation -6 c1v11 = %s", c1v11->asChar());
-    LOGINFO("CLIENT-1 :: local GET operation -7 c1v12 = %s", c1v12->asChar());
-    LOGINFO("CLIENT-1 :: local GET operation -8 c1v13 = %s", c1v13->asChar());
-    LOGINFO("CLIENT-1 :: local GET operation -9 c1v14=%s", c1v14->asChar());
-    LOGINFO("CLIENT-1 :: local GET operation....Done c1v15=%s",
-            c1v15->asChar());
-
-    // localDestroy
-    regPtr->localDestroy(keyPtr1);
-    regPtr->localDestroy(keyPtr2);
-    regPtr->localDestroy(keyPtr3);
-    regPtr->localDestroy(keyPtr4);
-    regPtr->localDestroy(keyPtr5);
-
-    LOG("CLIENT-1 :: localDestroy() operation....Done");
-
-    // remoteGet
-    s1v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
-    s1v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
-    s1v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
-    s1v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
-    s1v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
-
-    // Print remoteGet Values
-    LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v11 = %s", s1v11->asChar());
-    LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v12 = %s", s1v12->asChar());
-    LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v13 = %s", s1v13->asChar());
-    LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v14 = %s", s1v14->asChar());
-    LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v15 = %s", s1v15->asChar());
-
-    ASSERT(*c1v11.get() == *s1v11.get(),
-           "GetOnClient1:Values should be equal-1");
-    ASSERT(*c1v12.get() == *s1v12.get(),
-           "GetOnClient1:Values should be equal-2");
-    ASSERT(*c1v13.get() == *s1v13.get(),
-           "GetOnClient1:Values should be equal-3");
-    ASSERT(*c1v14.get() == *s1v14.get(),
-           "GetOnClient1:Values should be equal-4");
-    ASSERT(*c1v15.get() == *s1v15.get(),
-           "GetOnClient1:Values should be equal-5");
-    LOG("CLIENT-1 ::local GET operation....Done");
+   auto keyPtr1 = CacheableKey::create("key-1");
+   auto keyPtr2 = CacheableKey::create("key-2");
+   auto keyPtr3 = CacheableKey::create("key-3");
+   auto keyPtr4 = CacheableKey::create("key-4");
+   auto keyPtr5 = CacheableKey::create("key-5");
+
+   c1v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
+   c1v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
+   c1v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
+   c1v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
+   c1v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
+
+   // Print local Get Values
+   LOGINFO("CLIENT-1 :: local GET operation -6 c1v11 = %s", c1v11->asChar());
+   LOGINFO("CLIENT-1 :: local GET operation -7 c1v12 = %s", c1v12->asChar());
+   LOGINFO("CLIENT-1 :: local GET operation -8 c1v13 = %s", c1v13->asChar());
+   LOGINFO("CLIENT-1 :: local GET operation -9 c1v14=%s", c1v14->asChar());
+   LOGINFO("CLIENT-1 :: local GET operation....Done c1v15=%s", c1v15->asChar());
+
+   // localDestroy
+   regPtr->localDestroy(keyPtr1);
+   regPtr->localDestroy(keyPtr2);
+   regPtr->localDestroy(keyPtr3);
+   regPtr->localDestroy(keyPtr4);
+   regPtr->localDestroy(keyPtr5);
+
+   LOG("CLIENT-1 :: localDestroy() operation....Done");
+
+   // remoteGet
+   s1v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
+   s1v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
+   s1v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
+   s1v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
+   s1v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
+
+   // Print remoteGet Values
+   LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v11 = %s", s1v11->asChar());
+   LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v12 = %s", s1v12->asChar());
+   LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v13 = %s", s1v13->asChar());
+   LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v14 = %s", s1v14->asChar());
+   LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v15 = %s", s1v15->asChar());
+
+   ASSERT(*c1v11.get() == *s1v11.get(),
+          "GetOnClient1:Values should be equal-1");
+   ASSERT(*c1v12.get() == *s1v12.get(),
+          "GetOnClient1:Values should be equal-2");
+   ASSERT(*c1v13.get() == *s1v13.get(),
+          "GetOnClient1:Values should be equal-3");
+   ASSERT(*c1v14.get() == *s1v14.get(),
+          "GetOnClient1:Values should be equal-4");
+   ASSERT(*c1v15.get() == *s1v15.get(),
+          "GetOnClient1:Values should be equal-5");
+   LOG("CLIENT-1 ::local GET operation....Done");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, GetOnClient2)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regNames[0]);
+   auto regPtr = getHelper()->getRegion(regNames[0]);
     thread2->stop();
     delete thread2;
 
     dunit::sleep(3000);
     // localGet
-    CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
-    CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
-    CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
-    CacheableKeyPtr keyPtr4 = CacheableKey::create("key-4");
-    CacheableKeyPtr keyPtr5 = CacheableKey::create("key-5");
-
-    c2v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
-    c2v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
-    c2v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
-    c2v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
-    c2v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
-
-    // Print localGets
-    // Print local Get Values
-    LOGINFO("CLIENT-2 :: local GET operation  c2v11 = %s", c2v11->asChar());
-    LOGINFO("CLIENT-2 :: local GET operation  c2v12 = %s", c2v12->asChar());
-    LOGINFO("CLIENT-2 :: local GET operation  c2v13 = %s", c2v13->asChar());
-    LOGINFO("CLIENT-2 :: local GET operation  c2v14=%s", c2v14->asChar());
-    LOGINFO("CLIENT-2 :: local GET operation....Done c2v15=%s",
-            c2v15->asChar());
-
-    LOG("CLIENT-2 :: local GET operation....Done");
-
-    // localDestroy
-    regPtr->localDestroy(keyPtr1);
-    regPtr->localDestroy(keyPtr2);
-    regPtr->localDestroy(keyPtr3);
-    regPtr->localDestroy(keyPtr4);
-    regPtr->localDestroy(keyPtr5);
-    LOG("CLIENT-2 :: localDestroy() operation....Done");
-
-    // remoteGet
-    s2v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
-    s2v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
-    s2v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
-    s2v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
-    s2v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
-
-    // Print remoteGet Values
-    LOGINFO("CLIENT-2 :: remoteGet operation  s2v11 = %s", s2v11->asChar());
-    LOGINFO("CLIENT-2 :: remoteGet operation  s2v12 = %s", s2v12->asChar());
-    LOGINFO("CLIENT-2 :: remoteGet operation  s2v13 = %s", s2v13->asChar());
-    LOGINFO("CLIENT-2 :: remoteGet operation  s2v14 = %s", s2v14->asChar());
-    LOGINFO("CLIENT-2 :: remoteGet operation  s2v15 = %s", s2v15->asChar());
-
-    ASSERT(*c2v11.get() == *s2v11.get(),
-           "GetOnClient2:Values should be equal-1");
-    ASSERT(*c2v12.get() == *s2v12.get(),
-           "GetOnClient2:Values should be equal-2");
-    ASSERT(*c2v13.get() == *s2v13.get(),
-           "GetOnClient2:Values should be equal-3");
-    ASSERT(*c2v14.get() == *s2v14.get(),
-           "GetOnClient2:Values should be equal-4");
-    ASSERT(*c2v15.get() == *s2v15.get(),
-           "GetOnClient2:Values should be equal-5");
-
-    LOG("GetOnClient2 completed");
+   auto keyPtr1 = CacheableKey::create("key-1");
+   auto keyPtr2 = CacheableKey::create("key-2");
+   auto keyPtr3 = CacheableKey::create("key-3");
+   auto keyPtr4 = CacheableKey::create("key-4");
+   auto keyPtr5 = CacheableKey::create("key-5");
+
+   c2v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
+   c2v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
+   c2v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
+   c2v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
+   c2v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
+
+   // Print localGets
+   // Print local Get Values
+   LOGINFO("CLIENT-2 :: local GET operation  c2v11 = %s", c2v11->asChar());
+   LOGINFO("CLIENT-2 :: local GET operation  c2v12 = %s", c2v12->asChar());
+   LOGINFO("CLIENT-2 :: local GET operation  c2v13 = %s", c2v13->asChar());
+   LOGINFO("CLIENT-2 :: local GET operation  c2v14=%s", c2v14->asChar());
+   LOGINFO("CLIENT-2 :: local GET operation....Done c2v15=%s", c2v15->asChar());
+
+   LOG("CLIENT-2 :: local GET operation....Done");
+
+   // localDestroy
+   regPtr->localDestroy(keyPtr1);
+   regPtr->localDestroy(keyPtr2);
+   regPtr->localDestroy(keyPtr3);
+   regPtr->localDestroy(keyPtr4);
+   regPtr->localDestroy(keyPtr5);
+   LOG("CLIENT-2 :: localDestroy() operation....Done");
+
+   // remoteGet
+   s2v11 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr1));
+   s2v12 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr2));
+   s2v13 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr3));
+   s2v14 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr4));
+   s2v15 = std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr5));
+
+   // Print remoteGet Values
+   LOGINFO("CLIENT-2 :: remoteGet operation  s2v11 = %s", s2v11->asChar());
+   LOGINFO("CLIENT-2 :: remoteGet operation  s2v12 = %s", s2v12->asChar());
+   LOGINFO("CLIENT-2 :: remoteGet operation  s2v13 = %s", s2v13->asChar());
+   LOGINFO("CLIENT-2 :: remoteGet operation  s2v14 = %s", s2v14->asChar());
+   LOGINFO("CLIENT-2 :: remoteGet operation  s2v15 = %s", s2v15->asChar());
+
+   ASSERT(*c2v11.get() == *s2v11.get(),
+          "GetOnClient2:Values should be equal-1");
+   ASSERT(*c2v12.get() == *s2v12.get(),
+          "GetOnClient2:Values should be equal-2");
+   ASSERT(*c2v13.get() == *s2v13.get(),
+          "GetOnClient2:Values should be equal-3");
+   ASSERT(*c2v14.get() == *s2v14.get(),
+          "GetOnClient2:Values should be equal-4");
+   ASSERT(*c2v15.get() == *s2v15.get(),
+          "GetOnClient2:Values should be equal-5");
+
+   LOG("GetOnClient2 completed");
   }
 END_TASK_DEFINITION
 
diff --git a/cppcache/integration-test/fw_perf.hpp b/cppcache/integration-test/fw_perf.hpp
index a000e576..a18e1f16 100644
--- a/cppcache/integration-test/fw_perf.hpp
+++ b/cppcache/integration-test/fw_perf.hpp
@@ -230,7 +230,7 @@ class Thread : public ACE_Task_Base {
 //
 //    argsv[0] = strdup( pbuf );
 //    argsv[1] = 0;
-//    ACE_Service_Object_Ptr svcObj = ACE_SVC_INVOKE( ACE_Name_Acceptor );
+//   auto svcObj = ACE_SVC_INVOKE( ACE_Name_Acceptor );
 //
 //    if ( svcObj->init( 1, argsv ) == -1 ) {
 //      fprintf( stdout, "Failed to construct the Naming Service." );
diff --git a/cppcache/integration-test/testAttributesFactory.cpp b/cppcache/integration-test/testAttributesFactory.cpp
index ef84c40d..e667b5ae 100644
--- a/cppcache/integration-test/testAttributesFactory.cpp
+++ b/cppcache/integration-test/testAttributesFactory.cpp
@@ -18,7 +18,6 @@
 #define ROOT_NAME "testAttributesFactory"
 
 #include "fw_helper.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <CacheRegionHelper.hpp>
 
 using namespace apache::geode::client;
diff --git a/cppcache/integration-test/testAttributesMutator.cpp b/cppcache/integration-test/testAttributesMutator.cpp
index e93a791e..9ae54192 100644
--- a/cppcache/integration-test/testAttributesMutator.cpp
+++ b/cppcache/integration-test/testAttributesMutator.cpp
@@ -18,7 +18,6 @@
 #define ROOT_NAME "testAttributesMutator"
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
 
@@ -28,8 +27,8 @@ using namespace apache::geode::client;
 
 class TestData {
  public:
-  RegionPtr m_region;
-  CachePtr m_cache;
+  std::shared_ptr<Region> m_region;
+  std::shared_ptr<Cache> m_cache;
 
 } Test;
 
@@ -38,13 +37,13 @@ class TestData {
 /* setup recipient */
 DUNIT_TASK(A, Init)
   {
-    CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
+    auto cacheFactoryPtr = CacheFactory::createCacheFactory();
     Test.m_cache = cacheFactoryPtr->create();
 
     AttributesFactory af;
     af.setEntryTimeToLive(ExpirationAction::LOCAL_INVALIDATE,
                           std::chrono::seconds(5));
-    RegionAttributesPtr attrs = af.createRegionAttributes();
+    std::shared_ptr<RegionAttributes> attrs = af.createRegionAttributes();
 
     CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(Test.m_cache.get());
     cacheImpl->createRegion("Local_ETTL_LI", attrs, Test.m_region);
@@ -53,7 +52,7 @@ ENDTASK
 
 DUNIT_TASK(A, CreateAndVerifyExpiry)
   {
-    CacheableInt32Ptr value = CacheableInt32::create(1);
+    auto value = CacheableInt32::create(1);
     LOGDEBUG("### About to put of :one:1: ###");
     Test.m_region->put("one", value);
     LOGDEBUG("### Finished put of :one:1: ###");
diff --git a/cppcache/integration-test/testCache.cpp b/cppcache/integration-test/testCache.cpp
index 8ac78900..716cde52 100644
--- a/cppcache/integration-test/testCache.cpp
+++ b/cppcache/integration-test/testCache.cpp
@@ -20,7 +20,6 @@
 #include <string>
 #include <iostream>
 
-#include <geode/GeodeCppCache.hpp>
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
 #include "fw_helper.hpp"
@@ -35,16 +34,16 @@ BEGIN_TEST(CacheFunction)
   char* subRegionName1 = (char*)"TESTCACHE_SUB_REGION1";
   char* subRegionName2 = (char*)"TESTCACHE_SUB_REGION2";
   char* subRegionName21 = (char*)"TESTCACHE_SUB_REGION21";
-  CachePtr cptr;
+  std::shared_ptr<Cache> cptr;
   if (cptr != nullptr) {
     std::cout << "cptr is not null" << std::endl;
   }
   std::cout << "create Cache with name=" << host_name
             << " and unitialized system" << std::endl;
-  CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
+  auto cacheFactoryPtr = CacheFactory::createCacheFactory();
   cptr = cacheFactoryPtr->create();
   AttributesFactory attrFac;
-  RegionAttributesPtr rAttr;
+  std::shared_ptr<RegionAttributes> rAttr;
   std::cout << "create RegionAttributes" << std::endl;
   try {
     rAttr = attrFac.createRegionAttributes();
@@ -55,7 +54,7 @@ BEGIN_TEST(CacheFunction)
   if (rAttr == nullptr) {
     std::cout << "Warnning! : AttributesFactory returned nullptr" << std::endl;
   }
-  RegionPtr rptr;
+  std::shared_ptr<Region> rptr;
   if (rptr != nullptr) {
     std::cout << "rptr is not null" << std::endl;
   }
@@ -68,7 +67,7 @@ BEGIN_TEST(CacheFunction)
     ASSERT(false, (char*)"attribute create failed");
   }
   std::cout << "create Sub Region with name=" << subRegionName1 << std::endl;
-  RegionPtr subRptr1;
+  std::shared_ptr<Region> subRptr1;
   try {
     subRptr1 = rptr->createSubregion(subRegionName1, rAttr);
   } catch (Exception& ex) {
@@ -76,7 +75,7 @@ BEGIN_TEST(CacheFunction)
     ASSERT(false, (char*)"subregion create failed");
   }
   std::cout << "create Sub Region with name=" << subRegionName2 << std::endl;
-  RegionPtr subRptr2;
+  std::shared_ptr<Region> subRptr2;
   try {
     subRptr2 = rptr->createSubregion(subRegionName2, rAttr);
   } catch (Exception& ex) {
@@ -85,14 +84,14 @@ BEGIN_TEST(CacheFunction)
   }
   std::cout << "create Sub Region with name=" << subRegionName21
             << "inside region=" << subRegionName2 << std::endl;
-  RegionPtr subRptr21;
+  std::shared_ptr<Region> subRptr21;
   try {
     subRptr21 = subRptr2->createSubregion(subRegionName21, rAttr);
   } catch (Exception& ex) {
     std::cout << ex.getMessage() << std::endl;
     ASSERT(false, (char*)"subregion create failed");
   }
-  VectorOfRegion vr = rptr->subregions(true);
+  std::vector<std::shared_ptr<Region>> vr = rptr->subregions(true);
   std::cout << "  vr.size=" << vr.size() << std::endl;
   ASSERT(vr.size() == totalSubRegions, "Number of Subregions does not match");
   std::cout << "sub regions:" << std::endl;
@@ -120,7 +119,7 @@ BEGIN_TEST(CacheFunction)
   std::cout << "subRegion1=" << subRegion1.c_str() << std::endl;
   subRegion21 = subRegion2 + sptor + subRegion21;
   std::cout << "subRegion21=" << subRegion21.c_str() << std::endl;
-  RegionPtr region;
+  std::shared_ptr<Region> region;
   std::cout << "find region:" << regionName << std::endl;
   try {
     region = cptr->getRegion(root.c_str());
diff --git a/cppcache/integration-test/testCacheless.cpp b/cppcache/integration-test/testCacheless.cpp
index 6eec6c7a..f597c004 100644
--- a/cppcache/integration-test/testCacheless.cpp
+++ b/cppcache/integration-test/testCacheless.cpp
@@ -16,7 +16,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 
 #define ROOT_SCOPE DISTRIBUTED_ACK
 
@@ -24,14 +23,13 @@
 #include "TallyListener.hpp"
 
 using namespace apache::geode::client;
-
-CacheListenerPtr nullListenerPtr;
+std::shared_ptr<CacheListener> nullListenerPtr;
 
 class RegionWrapper {
  public:
   explicit RegionWrapper(const char* name)
       : m_regionPtr(cacheHelper->getRegion(name)) {
-    RegionAttributesPtr attrs;
+    std::shared_ptr<RegionAttributes> attrs;
     attrs = m_regionPtr->getAttributes();
     m_noack = true;
   }
@@ -41,11 +39,11 @@ class RegionWrapper {
     char valbuf[100];
     sprintf(keybuf, "key%d", key);
     sprintf(valbuf, "%d", value);
-    CacheableStringPtr valPtr = CacheableString::create(valbuf);
-    m_regionPtr->put(keybuf, valPtr);
+   auto valPtr = CacheableString::create(valbuf);
+   m_regionPtr->put(keybuf, valPtr);
   }
 
-  void waitForKey(CacheableKeyPtr& keyPtr) {
+  void waitForKey(std::shared_ptr<CacheableKey>& keyPtr) {
     if (m_noack) {
       // might have to wait for a moment.
       int tries = 0;
@@ -56,8 +54,8 @@ class RegionWrapper {
     }
   }
 
-  int waitForValue(CacheableKeyPtr& keyPtr, int expected,
-                   CacheableStringPtr& valPtr) {
+  int waitForValue(std::shared_ptr<CacheableKey>& keyPtr, int expected,
+                   std::shared_ptr<CacheableString>& valPtr) {
     int tries = 0;
     int val = 0;
     do {
@@ -76,12 +74,12 @@ class RegionWrapper {
   void test(int key, int value, int line) {
     char keybuf[100];
     sprintf(keybuf, "key%d", key);
-    CacheableKeyPtr keyPtr = createKey(keybuf);
+   auto keyPtr = createKey(keybuf);
 
-    if (value == -1) {
-      char ebuf[1024];
-      sprintf(ebuf, "unexpected key found at %d", line);
-      ASSERT(!m_regionPtr->containsKey(keyPtr), ebuf);
+   if (value == -1) {
+     char ebuf[1024];
+     sprintf(ebuf, "unexpected key found at %d", line);
+     ASSERT(!m_regionPtr->containsKey(keyPtr), ebuf);
     } else if (value == 0) {
       waitForKey(keyPtr);
       ASSERT(m_regionPtr->containsKey(keyPtr), "missing key.");
@@ -90,7 +88,7 @@ class RegionWrapper {
     } else {
       waitForKey(keyPtr);
       ASSERT(m_regionPtr->containsKey(keyPtr), "missing key.");
-      CacheableStringPtr valPtr;
+      std::shared_ptr<CacheableString> valPtr;
       int val = waitForValue(keyPtr, value, valPtr);
       char ebuf[1024];
       sprintf(ebuf, "unexpected value: \"%s\", expected \"%d\" from line %d",
@@ -99,7 +97,7 @@ class RegionWrapper {
     }
   }
 
-  RegionPtr m_regionPtr;
+  std::shared_ptr<Region> m_regionPtr;
   bool m_noack;
 };
 
@@ -108,7 +106,7 @@ bool isLocalServer = true;
 bool isLocator = true;
 const char* locHostPort =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, numberOfLocators);
-TallyListenerPtr listener;
+std::shared_ptr<TallyListener> listener;
 
 #define REGIONNAME "DistRegionAck"
 DUNIT_TASK_DEFINITION(s1p1, Setup)
diff --git a/cppcache/integration-test/testConnect.cpp b/cppcache/integration-test/testConnect.cpp
index 7cf284c5..236c49bc 100644
--- a/cppcache/integration-test/testConnect.cpp
+++ b/cppcache/integration-test/testConnect.cpp
@@ -18,15 +18,15 @@
 #define ROOT_NAME "testConnect"
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
+#include <geode/CacheFactory.hpp>
 
 using namespace apache::geode::client;
 
 const char* host_name = "Suds";
 DUNIT_TASK(s1p1, CreateRegionOne)
   {
-    CacheFactoryPtr factory = CacheFactory::createCacheFactory();
-    CachePtr cache = factory->create();
+    auto factory = CacheFactory::createCacheFactory();
+    auto cache = factory->create();
     try {
       cache->getDistributedSystem().connect();
       FAIL("Expected an exception.");
diff --git a/cppcache/integration-test/testCreateAndDestroyPool.cpp b/cppcache/integration-test/testCreateAndDestroyPool.cpp
index 269ea3ae..bdf83f44 100644
--- a/cppcache/integration-test/testCreateAndDestroyPool.cpp
+++ b/cppcache/integration-test/testCreateAndDestroyPool.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <ace/Task.h>
diff --git a/cppcache/integration-test/testDunit.cpp b/cppcache/integration-test/testDunit.cpp
index 08308549..99bbfeda 100644
--- a/cppcache/integration-test/testDunit.cpp
+++ b/cppcache/integration-test/testDunit.cpp
@@ -20,7 +20,6 @@
 #include <iostream>
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 
 int getSlaveTest() {
   return dunit::globals()->getIntValue("test_alive_slaves");
diff --git a/cppcache/integration-test/testExpiration.cpp b/cppcache/integration-test/testExpiration.cpp
index b88a0539..ff578c1e 100644
--- a/cppcache/integration-test/testExpiration.cpp
+++ b/cppcache/integration-test/testExpiration.cpp
@@ -18,7 +18,6 @@
 #define ROOT_NAME "testExpiration"
 
 #include "fw_helper.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
 
@@ -28,21 +27,21 @@ ExpirationAction::Action action = ExpirationAction::DESTROY;
 
 // This test is for serially running the tests.
 
-size_t getNumOfEntries(RegionPtr& R1) {
-  VectorOfCacheableKey v = R1->keys();
+size_t getNumOfEntries(std::shared_ptr<Region>& R1) {
+  std::vector<std::shared_ptr<CacheableKey>> v = R1->keys();
   LOGFINE("Number of keys in region %s is %d", R1->getFullPath(), v.size());
   return v.size();
 }
 
-void startDSandCreateCache(CachePtr& cache) {
-  PropertiesPtr pp = Properties::create();
-  CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
+void startDSandCreateCache(std::shared_ptr<Cache>& cache) {
+  auto pp = Properties::create();
+  auto cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
   cache = cacheFactoryPtr->create();
   ASSERT(cache != nullptr, "cache not equal to null expected");
 }
 
-void doNPuts(RegionPtr& rptr, int n) {
-  CacheableStringPtr value;
+void doNPuts(std::shared_ptr<Region>& rptr, int n) {
+  std::shared_ptr<CacheableString> value;
   char buf[16];
   memset(buf, 'A', 15);
   buf[15] = '\0';
@@ -52,15 +51,14 @@ void doNPuts(RegionPtr& rptr, int n) {
 
   for (int i = 0; i < n; i++) {
     sprintf(buf, "KeyA - %d", i + 1);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     LOGINFO("Putting key %s value %s in region %s", buf, value->toString(),
             rptr->getFullPath());
     rptr->put(key, value);
   }
 }
-
-CacheableKeyPtr do1Put(RegionPtr& rptr) {
-  CacheableStringPtr value;
+std::shared_ptr<CacheableKey> do1Put(std::shared_ptr<Region>& rptr) {
+  std::shared_ptr<CacheableString> value;
   char buf[16];
   memset(buf, 'A', 15);
   buf[15] = '\0';
@@ -69,15 +67,15 @@ CacheableKeyPtr do1Put(RegionPtr& rptr) {
   ASSERT(value != nullptr, "Failed to create value.");
 
   sprintf(buf, "KeyA - %d", 0 + 1);
-  CacheableKeyPtr key = CacheableKey::create(buf);
-  LOGINFO("Putting key %s value %s in region %s", buf, value->toString(),
-          rptr->getFullPath());
-  rptr->put(key, value);
-  return key;
+ auto key = CacheableKey::create(buf);
+ LOGINFO("Putting key %s value %s in region %s", buf, value->toString(),
+         rptr->getFullPath());
+ rptr->put(key, value);
+ return key;
 }
 
 void setExpTimes(
-    RegionAttributesPtr& attrs,
+    std::shared_ptr<RegionAttributes>& attrs,
     const std::chrono::seconds& ettl = std::chrono::seconds::zero(),
     const std::chrono::seconds& eit = std::chrono::seconds::zero(),
     const std::chrono::seconds& rttl = std::chrono::seconds::zero(),
@@ -94,7 +92,7 @@ void setExpTimes(
 
 BEGIN_TEST(TEST_EXPIRATION)
   {
-    CachePtr cache;
+    std::shared_ptr<Cache> cache;
 
     startDSandCreateCache(cache);
 
@@ -104,10 +102,10 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     size_t n;
 
-    RegionAttributesPtr attrs_1;
+    std::shared_ptr<RegionAttributes> attrs_1;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_1);
-    RegionPtr R1;
+    std::shared_ptr<Region> R1;
     cacheImpl->createRegion("R1", attrs_1, R1);
     ASSERT(R1 != nullptr, "Expected R1 to be NON-nullptr");
 
@@ -120,12 +118,12 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R1->isDestroyed() == false, "Expected R1 to be alive");
 
-    RegionAttributesPtr attrs_2;
+    std::shared_ptr<RegionAttributes> attrs_2;
 
     setExpTimes(attrs_2, std::chrono::seconds(20), std::chrono::seconds(2),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R2;
+    std::shared_ptr<Region> R2;
     cacheImpl->createRegion("R2", attrs_2, R2);
     ASSERT(R2 != nullptr, "Expected R2 to be NON-nullptr");
     LOG("Region R2 created");
@@ -138,12 +136,12 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R2->isDestroyed() == false, "Expected R2 to be alive");
 
-    RegionAttributesPtr attrs_3;
+    std::shared_ptr<RegionAttributes> attrs_3;
     // rttl = 20, reit = 2
     setExpTimes(attrs_3, std::chrono::seconds(0), std::chrono::seconds(0),
                 std::chrono::seconds(20), std::chrono::seconds(2));
 
-    RegionPtr R3;
+    std::shared_ptr<Region> R3;
     cacheImpl->createRegion("R3", attrs_3, R3);
     ASSERT(R3 != nullptr, "Expected R3 to be NON-nullptr");
 
@@ -151,12 +149,12 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R3->isDestroyed() == false, "Expected R3 to be alive");
 
-    RegionAttributesPtr attrs_4;
+    std::shared_ptr<RegionAttributes> attrs_4;
 
     setExpTimes(attrs_4, std::chrono::seconds(5), std::chrono::seconds(0),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R4;
+    std::shared_ptr<Region> R4;
     cacheImpl->createRegion("R4", attrs_4, R4);
     ASSERT(R4 != nullptr, "Expected R4 to be NON-nullptr");
 
@@ -170,16 +168,16 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R4->isDestroyed() == false, "Expected R4 to be alive");
 
-    RegionAttributesPtr attrs_5;
+    std::shared_ptr<RegionAttributes> attrs_5;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_5, std::chrono::seconds(0), std::chrono::seconds(5),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R5;
+    std::shared_ptr<Region> R5;
     cacheImpl->createRegion("R5", attrs_5, R5);
     ASSERT(R5 != nullptr, "Expected R5 to be NON-nullptr");
 
-    CacheableKeyPtr key_0 = do1Put(R5);
+    auto key_0 = do1Put(R5);
 
     ACE_OS::sleep(2);
 
@@ -198,12 +196,12 @@ BEGIN_TEST(TEST_EXPIRATION)
     ASSERT(n == 0, "Expected 0 entry");
     ASSERT(R5->isDestroyed() == false, "Expected R5 to be alive");
 
-    RegionAttributesPtr attrs_6;
+    std::shared_ptr<RegionAttributes> attrs_6;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_6, std::chrono::seconds(0), std::chrono::seconds(0),
                 std::chrono::seconds(5), std::chrono::seconds(0));
 
-    RegionPtr R6;
+    std::shared_ptr<Region> R6;
     cacheImpl->createRegion("R6", attrs_6, R6);
     ASSERT(R6 != nullptr, "Expected R6 to be NON-nullptr");
 
@@ -217,12 +215,12 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R6->isDestroyed() == true, "Expected R6 to be dead");
 
-    RegionAttributesPtr attrs_7;
+    std::shared_ptr<RegionAttributes> attrs_7;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_7, std::chrono::seconds(0), std::chrono::seconds(0),
                 std::chrono::seconds(0), std::chrono::seconds(5));
 
-    RegionPtr R7;
+    std::shared_ptr<Region> R7;
     cacheImpl->createRegion("R7", attrs_7, R7);
     ASSERT(R7 != nullptr, "Expected R7 to be NON-nullptr");
 
@@ -236,16 +234,16 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R7->isDestroyed() == true, "Expected R7 to be dead");
 
-    RegionAttributesPtr attrs_8;
+    std::shared_ptr<RegionAttributes> attrs_8;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_8, std::chrono::seconds(10), std::chrono::seconds(0),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R8;
+    std::shared_ptr<Region> R8;
     cacheImpl->createRegion("R8", attrs_8, R8);
     ASSERT(R8 != nullptr, "Expected R8 to be NON-nullptr");
 
-    CacheableKeyPtr key = do1Put(R8);
+    auto key = do1Put(R8);
 
     ACE_OS::sleep(5);
 
@@ -256,16 +254,16 @@ BEGIN_TEST(TEST_EXPIRATION)
     n = getNumOfEntries(R8);
     ASSERT(n == 0, "Expected 1 entries");
 
-    RegionAttributesPtr attrs_9;
+    std::shared_ptr<RegionAttributes> attrs_9;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_9, std::chrono::seconds(0), std::chrono::seconds(0),
                 std::chrono::seconds(0), std::chrono::seconds(8));
 
-    RegionPtr R9;
+    std::shared_ptr<Region> R9;
     cacheImpl->createRegion("R9", attrs_9, R9);
     ASSERT(R9 != nullptr, "Expected R9 to be NON-nullptr");
 
-    CacheableKeyPtr key_1 = do1Put(R9);
+    auto key_1 = do1Put(R9);
 
     ACE_OS::sleep(5);
 
@@ -278,12 +276,12 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R9->isDestroyed() == false, "Expected R9 to be alive");
 
-    RegionAttributesPtr attrs_10;
+    std::shared_ptr<RegionAttributes> attrs_10;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_10, std::chrono::seconds(6), std::chrono::seconds(0),
                 std::chrono::seconds(0), std::chrono::seconds(12));
 
-    RegionPtr R10;
+    std::shared_ptr<Region> R10;
     cacheImpl->createRegion("R10", attrs_10, R10);
     ASSERT(R10 != nullptr, "Expected R10 to be NON-nullptr");
 
@@ -298,17 +296,17 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R10->isDestroyed() == true, "Expected R10 to be dead");
 
-    RegionAttributesPtr attrs_11;
+    std::shared_ptr<RegionAttributes> attrs_11;
 
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_11, std::chrono::seconds(0), std::chrono::seconds(4),
                 std::chrono::seconds(0), std::chrono::seconds(7));
 
-    RegionPtr R11;
+    std::shared_ptr<Region> R11;
     cacheImpl->createRegion("R11", attrs_11, R11);
     ASSERT(R11 != nullptr, "Expected R11 to be NON-nullptr");
 
-    CacheableKeyPtr k11 = do1Put(R11);
+    auto k11 = do1Put(R11);
 
     ACE_OS::sleep(3);
 
@@ -326,16 +324,16 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R11->isDestroyed() == true, "Expected R11 to be dead");
 
-    RegionAttributesPtr attrs_12;
+    std::shared_ptr<RegionAttributes> attrs_12;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_12, std::chrono::seconds(5), std::chrono::seconds(0),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R12;
+    std::shared_ptr<Region> R12;
     cacheImpl->createRegion("R12", attrs_12, R12);
     ASSERT(R12 != nullptr, "Expected R12 to be NON-nullptr");
 
-    CacheableKeyPtr key_3 = do1Put(R12);
+    auto key_3 = do1Put(R12);
 
     ACE_OS::sleep(6);
 
@@ -345,12 +343,12 @@ BEGIN_TEST(TEST_EXPIRATION)
     ASSERT(R12->isDestroyed() == false, "Expected R12 to be alive");
     /////////
 
-    RegionAttributesPtr attrs_14;
+    std::shared_ptr<RegionAttributes> attrs_14;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_14, std::chrono::seconds(0), std::chrono::seconds(0),
                 std::chrono::seconds(10), std::chrono::seconds(0));
 
-    RegionPtr R14;
+    std::shared_ptr<Region> R14;
     cacheImpl->createRegion("R14", attrs_14, R14);
     ASSERT(R14 != nullptr, "Expected R14 to be NON-nullptr");
 
@@ -360,16 +358,16 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     ASSERT(R14->isDestroyed() == true, "Expected R14 to be dead");
 
-    RegionAttributesPtr attrs_15;
+    std::shared_ptr<RegionAttributes> attrs_15;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_15, std::chrono::seconds(0), std::chrono::seconds(5),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R15;
+    std::shared_ptr<Region> R15;
     cacheImpl->createRegion("R15", attrs_15, R15);
     ASSERT(R15 != nullptr, "Expected R15 to be NON-nullptr");
 
-    CacheableKeyPtr key_4 = do1Put(R15);
+    auto key_4 = do1Put(R15);
 
     ACE_OS::sleep(2);
 
@@ -380,12 +378,12 @@ BEGIN_TEST(TEST_EXPIRATION)
     ASSERT(R15->isDestroyed() == false, "Expected R15 to be alive");
 
     //////////////
-    RegionAttributesPtr attrs_18;
+    std::shared_ptr<RegionAttributes> attrs_18;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_18, std::chrono::seconds(6), std::chrono::seconds(3),
                 std::chrono::seconds(0), std::chrono::seconds(0));
 
-    RegionPtr R18;
+    std::shared_ptr<Region> R18;
     cacheImpl->createRegion("R18", attrs_18, R18);
     ASSERT(R18 != nullptr, "Expected R18 to be NON-nullptr");
 
@@ -400,12 +398,12 @@ BEGIN_TEST(TEST_EXPIRATION)
     n = getNumOfEntries(R18);
     ASSERT(n == 0, "ttl is over so it should be 0");
 
-    RegionAttributesPtr attrs_19;
+    std::shared_ptr<RegionAttributes> attrs_19;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
     setExpTimes(attrs_19, std::chrono::seconds(0), std::chrono::seconds(0),
                 std::chrono::seconds(6), std::chrono::seconds(3));
 
-    RegionPtr R19;
+    std::shared_ptr<Region> R19;
     cacheImpl->createRegion("R19x", attrs_19, R19);
     ASSERT(R19 != nullptr, "Expected R19 to be NON-nullptr");
 
diff --git a/cppcache/integration-test/testFwPerf.cpp b/cppcache/integration-test/testFwPerf.cpp
index a8e73c10..ffed7184 100644
--- a/cppcache/integration-test/testFwPerf.cpp
+++ b/cppcache/integration-test/testFwPerf.cpp
@@ -16,7 +16,6 @@
  */
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 
 #define ROOT_NAME "testFwPerf"
 
diff --git a/cppcache/integration-test/testLRUList.cpp b/cppcache/integration-test/testLRUList.cpp
index 7a513704..6fe6aca1 100644
--- a/cppcache/integration-test/testLRUList.cpp
+++ b/cppcache/integration-test/testLRUList.cpp
@@ -32,13 +32,13 @@ END_TEST(NotOnWindows)
 //#define BUILD_CPPCACHE
 
 #include <LRUList.cpp>
-#include <geode/GeodeCppCache.hpp>
+#include <geode/CacheableKey.hpp>
 
 using namespace apache::geode::client;
 
 class MyNode : public LRUEntryProperties {
  public:
-  static MyNode* create(const CacheableKeyPtr& key = nullptr) {
+  static MyNode* create(const std::shared_ptr<CacheableKey>& key = nullptr) {
     return new MyNode();
   }
   virtual ~MyNode() {}
@@ -52,8 +52,6 @@ class MyNode : public LRUEntryProperties {
   int m_value;
 };
 
-typedef std::shared_ptr<MyNode> MyNodePtr;
-
 /**
  * @brief Test the LRU-ness of the LRUList.
  */
@@ -61,7 +59,7 @@ BEGIN_TEST(LRUListTest)
   {
     LRUList<MyNode, MyNode> lruList;
     // Create 10 Nodes to keep track of.
-    MyNodePtr* tenNodes = new MyNodePtr[10];
+    std::shared_ptr<MyNode>* tenNodes = new std::shared_ptr<MyNode>[10];
 
     for (int i = 0; i < 10; i++) {
       tenNodes[i] = std::shared_ptr<MyNode>(MyNode::create());
@@ -77,7 +75,7 @@ BEGIN_TEST(LRUListTest)
       tenNodes[j]->setRecentlyUsed();
     }
 
-    MyNodePtr aNode;
+    std::shared_ptr<MyNode> aNode;
     char msgbuf[100];
     // check that we get the unmarked entries first. 0,2,4,6,8
     for (int k = 0; k < 10; k += 2) {
@@ -101,7 +99,7 @@ BEGIN_TEST(TestEndOfList)
     LRUList<MyNode, MyNode> lruList;
     // add ten entries.
     for (int i = 0; i < 10; i++) {
-      MyNodePtr tmp(MyNode::create());
+      std::shared_ptr<MyNode> tmp(MyNode::create());
       tmp->setValue(i);
       lruList.appendEntry(tmp);
     }
@@ -109,7 +107,7 @@ BEGIN_TEST(TestEndOfList)
     int k = 0;
     char msgbuf[100];
     while (k < 10) {
-      MyNodePtr nodePtr;
+      std::shared_ptr<MyNode> nodePtr;
       lruList.getLRUEntry(nodePtr);
       sprintf(msgbuf, "expected node %d", k);
       ASSERT(std::dynamic_pointer_cast<MyNode>(nodePtr)->getValue() == k,
@@ -117,7 +115,7 @@ BEGIN_TEST(TestEndOfList)
       k++;
     }
     // now list should be empty...
-    MyNodePtr emptyPtr;
+    std::shared_ptr<MyNode> emptyPtr;
     lruList.getLRUEntry(emptyPtr);
     ASSERT(emptyPtr == nullptr, "expected nullptr");
     // do it again...
@@ -127,11 +125,11 @@ BEGIN_TEST(TestEndOfList)
     ASSERT(emptyPtr == nullptr, "expected nullptr");
     // now add something to the list... and retest...
     {
-      MyNodePtr tmp(MyNode::create());
+      std::shared_ptr<MyNode> tmp(MyNode::create());
       tmp->setValue(100);
       lruList.appendEntry(tmp);
     }
-    MyNodePtr hundredPtr;
+    std::shared_ptr<MyNode> hundredPtr;
     lruList.getLRUEntry(hundredPtr);
     ASSERT(hundredPtr != nullptr, "expected to not be nullptr");
     ASSERT(std::dynamic_pointer_cast<MyNode>(hundredPtr)->getValue() == 100,
@@ -146,7 +144,7 @@ END_TEST(TestEndOfList)
  */
 BEGIN_TEST(LRUListEntryTest)
   {
-    MyNodePtr node(MyNode::create());
+    std::shared_ptr<MyNode> node(MyNode::create());
     node->setValue(20);
     // test initial state.
     ASSERT(node->testRecentlyUsed() == false, "should not be marked used.");
diff --git a/cppcache/integration-test/testLinkage.cpp b/cppcache/integration-test/testLinkage.cpp
index 5a7b7fcd..53108e7c 100644
--- a/cppcache/integration-test/testLinkage.cpp
+++ b/cppcache/integration-test/testLinkage.cpp
@@ -17,7 +17,7 @@
 
 #define ROOT_NAME "testLinkage"
 
-#include <geode/GeodeCppCache.hpp>
+#include <geode/AttributesFactory.hpp>
 #include "fw_helper.hpp"
 
 using namespace apache::geode::client;
@@ -31,13 +31,13 @@ BEGIN_TEST(LinkageTest)
   AttributesFactory af;
 
   {
-    CacheablePtr cacheablePtr;
-    CacheableKeyPtr cacheableKeyPtr;
-    RegionPtr regionPtr;
+    std::shared_ptr<Cacheable> cacheablePtr;
+    std::shared_ptr<CacheableKey> cacheableKeyPtr;
+    std::shared_ptr<Region> regionPtr;
     AttributesMutator am(regionPtr);
-    RegionEntryPtr regionEntryPtr;
-    CacheableStringPtr cacheableStringPtr;
-    CachePtr cachePtr;
+    std::shared_ptr<RegionEntry> regionEntryPtr;
+    std::shared_ptr<CacheableString> cacheableStringPtr;
+    std::shared_ptr<Cache> cachePtr;
     // add other ptr types here...
   }
   {
@@ -77,19 +77,19 @@ BEGIN_TEST(LinkageTest)
     EntryExistsException aEntryExistsException("EntryExistsException");
   }
 
-  CachePtr cachePtr;
-  CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
+  std::shared_ptr<Cache> cachePtr;
+  auto cacheFactoryPtr = CacheFactory::createCacheFactory();
   cachePtr = cacheFactoryPtr->create();
   // Cache cache;
   ASSERT((!cachePtr->isClosed()), "cache shouldn't be closed.");
-  RegionPtr rptr;
-  SerializablePtr callback;
+  std::shared_ptr<Region> rptr;
+  std::shared_ptr<Serializable> callback;
   //    CacheListener cl;
-  CacheListenerPtr clPtr;
+  std::shared_ptr<CacheListener> clPtr;
   //    CacheLoader cacheloader;
-  CacheLoaderPtr cldPtr;
+  std::shared_ptr<CacheLoader> cldPtr;
   //    CacheStatistics cstats; NOT yet...
 
   //    CacheWriter cwriter;
-  CacheWriterPtr cwPtr;
+  std::shared_ptr<CacheWriter> cwPtr;
 END_TEST(LinkageTest)
diff --git a/cppcache/integration-test/testLogger.cpp b/cppcache/integration-test/testLogger.cpp
index ab46eeb2..f9654024 100644
--- a/cppcache/integration-test/testLogger.cpp
+++ b/cppcache/integration-test/testLogger.cpp
@@ -18,7 +18,7 @@
 #define ROOT_NAME "testLogger"
 
 #include "fw_helper.hpp"
-#include <geode/GeodeCppCache.hpp>
+#include <geode/ExceptionTypes.hpp>
 
 #ifndef WIN32
 #include <unistd.h>
diff --git a/cppcache/integration-test/testOverflowPutGetSqLite.cpp b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
index cc89dd37..29e4bd93 100644
--- a/cppcache/integration-test/testOverflowPutGetSqLite.cpp
+++ b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
@@ -22,8 +22,6 @@
 
 #include <ace/OS.h>
 
-#include <geode/GeodeCppCache.hpp>
-
 #include "fw_helper.hpp"
 #include <CacheableToken.hpp>
 #include <MapEntry.hpp>
@@ -35,7 +33,7 @@ uint32_t numOfEnt;
 std::string sqlite_dir = "SqLiteRegionData";
 
 // Return the number of keys and values in entries map.
-void getNumOfEntries(RegionPtr& regionPtr, uint32_t num) {
+void getNumOfEntries(std::shared_ptr<Region>& regionPtr, uint32_t num) {
   auto v = regionPtr->keys();
   auto vecValues = regionPtr->values();
   printf("Values vector size is %zd\n", vecValues.size());
@@ -43,14 +41,14 @@ void getNumOfEntries(RegionPtr& regionPtr, uint32_t num) {
   ASSERT(vecValues.size() == num, (char*)"size of value vec and num not equal");
 }
 
-void setAttributes(RegionAttributesPtr& attrsPtr,
+void setAttributes(std::shared_ptr<RegionAttributes>& attrsPtr,
                    std::string pDir = sqlite_dir) {
   AttributesFactory attrsFact;
   attrsFact.setCachingEnabled(true);
   attrsFact.setLruEntriesLimit(10);
   attrsFact.setInitialCapacity(1000);
   attrsFact.setDiskPolicy(DiskPolicyType::OVERFLOWS);
-  PropertiesPtr sqliteProperties = Properties::create();
+  auto sqliteProperties = Properties::create();
   sqliteProperties->insert("MaxPageCount", "1073741823");
   sqliteProperties->insert("PageSize", "65536");
   sqliteProperties->insert("PersistenceDirectory", pDir.c_str());
@@ -59,13 +57,13 @@ void setAttributes(RegionAttributesPtr& attrsPtr,
 
   attrsPtr = attrsFact.createRegionAttributes();
 }
-void setAttributesWithMirror(RegionAttributesPtr& attrsPtr) {
+void setAttributesWithMirror(std::shared_ptr<RegionAttributes>& attrsPtr) {
   AttributesFactory attrsFact;
   attrsFact.setCachingEnabled(true);
   attrsFact.setLruEntriesLimit(20);
   attrsFact.setInitialCapacity(1000);
   attrsFact.setDiskPolicy(DiskPolicyType::OVERFLOWS);
-  PropertiesPtr sqliteProperties = Properties::create();
+  auto sqliteProperties = Properties::create();
   sqliteProperties->insert("MaxPageCount", "1073741823");
   sqliteProperties->insert("PageSize", "65536");
   sqliteProperties->insert("PersistenceDirectory", sqlite_dir.c_str());
@@ -75,8 +73,8 @@ void setAttributesWithMirror(RegionAttributesPtr& attrsPtr) {
 }
 
 // Testing for attibute validation.
-void validateAttribute(RegionPtr& regionPtr) {
-  RegionAttributesPtr regAttr = regionPtr->getAttributes();
+void validateAttribute(std::shared_ptr<Region>& regionPtr) {
+  std::shared_ptr<RegionAttributes> regAttr = regionPtr->getAttributes();
   int initialCapacity = regAttr->getInitialCapacity();
   ASSERT(initialCapacity == 1000, "Expected initial capacity to be 1000");
   const DiskPolicyType::PolicyType type = regAttr->getDiskPolicy();
@@ -84,15 +82,16 @@ void validateAttribute(RegionPtr& regionPtr) {
          "Expected Action should overflow to disk");
 }
 
-void checkOverflowTokenValues(RegionPtr& regionPtr, uint32_t num) {
-  VectorOfCacheableKey v = regionPtr->keys();
-  CacheableKeyPtr keyPtr;
-  CacheablePtr valuePtr;
+void checkOverflowTokenValues(std::shared_ptr<Region>& regionPtr,
+                              uint32_t num) {
+  std::vector<std::shared_ptr<CacheableKey>> v = regionPtr->keys();
+  std::shared_ptr<CacheableKey> keyPtr;
+  std::shared_ptr<Cacheable> valuePtr;
   int count = 0;
   int nonoverflowCount = 0;
   for (uint32_t i = 0; i < num; i++) {
     keyPtr = v.at(i);
-    RegionEntryPtr rPtr = regionPtr->getEntry(keyPtr);
+    auto rPtr = regionPtr->getEntry(keyPtr);
     valuePtr = rPtr->getValue();
     if (CacheableToken::isOverflowed(valuePtr) == true) {
       count++;
@@ -107,10 +106,10 @@ void checkOverflowTokenValues(RegionPtr& regionPtr, uint32_t num) {
          "Non overflowed entries should match key size");
 }
 
-void checkOverflowToken(RegionPtr& regionPtr, uint32_t lruLimit) {
-  VectorOfCacheableKey v = regionPtr->keys();
-  CacheableKeyPtr keyPtr;
-  CacheablePtr valuePtr;
+void checkOverflowToken(std::shared_ptr<Region>& regionPtr, uint32_t lruLimit) {
+  std::vector<std::shared_ptr<CacheableKey>> v = regionPtr->keys();
+  std::shared_ptr<CacheableKey> keyPtr;
+  std::shared_ptr<Cacheable> valuePtr;
   int normalCount = 0;
   int overflowCount = 0;
   int invalidCount = 0;
@@ -118,7 +117,7 @@ void checkOverflowToken(RegionPtr& regionPtr, uint32_t lruLimit) {
   int tombstoneCount = 0;
   for (uint32_t i = 0; i < static_cast<uint32_t>(v.size()); i++) {
     keyPtr = v.at(i);
-    RegionEntryPtr rPtr = regionPtr->getEntry(keyPtr);
+    auto rPtr = regionPtr->getEntry(keyPtr);
     valuePtr = rPtr->getValue();
     if (CacheableToken::isOverflowed(valuePtr) == true) {
       overflowCount++;
@@ -145,28 +144,29 @@ void checkOverflowToken(RegionPtr& regionPtr, uint32_t lruLimit) {
 }
 
 // Testing for put operation
-void doNput(RegionPtr& regionPtr, uint32_t num, uint32_t start = 0) {
+void doNput(std::shared_ptr<Region>& regionPtr, uint32_t num,
+            uint32_t start = 0) {
   char keybuf[100];
   // Put 1 KB of data locally for each entry
   char* text = new char[1024];
   memset(text, 'A', 1023);
   text[1023] = '\0';
-  CacheableStringPtr valuePtr = CacheableString::create(text);
+  auto valuePtr = CacheableString::create(text);
 
   for (uint32_t i = start; i < num; i++) {
     sprintf(keybuf, "key-%d", i);
-    CacheableKeyPtr key = CacheableKey::create(keybuf);
+    auto key = CacheableKey::create(keybuf);
     printf("Putting key = %s\n", keybuf);
     regionPtr->put(key, valuePtr);
   }
 }
 
-void doNputLargeData(RegionPtr& regionPtr, int num) {
+void doNputLargeData(std::shared_ptr<Region>& regionPtr, int num) {
   // Put 1 MB of data locally for each entry
   char* text = new char[1024 * 1024 /* 1 MB */];
   memset(text, 'A', 1024 * 1024 - 1);
   text[1024 * 1024 - 1] = '\0';
-  CacheableStringPtr valuePtr = CacheableString::create(text);
+  auto valuePtr = CacheableString::create(text);
   for (int item = 0; item < num; item++) {
     regionPtr->put(CacheableKey::create(item), valuePtr);
   }
@@ -175,7 +175,7 @@ void doNputLargeData(RegionPtr& regionPtr, int num) {
 }
 
 // Testing for get operation
-uint32_t doNgetLargeData(RegionPtr& regionPtr, int num) {
+uint32_t doNgetLargeData(std::shared_ptr<Region>& regionPtr, int num) {
   uint32_t countFound = 0;
   uint32_t countNotFound = 0;
 
@@ -194,7 +194,8 @@ uint32_t doNgetLargeData(RegionPtr& regionPtr, int num) {
 }
 
 // Testing for get operation
-uint32_t doNget(RegionPtr& regionPtr, uint32_t num, uint32_t start = 0) {
+uint32_t doNget(std::shared_ptr<Region>& regionPtr, uint32_t num,
+                uint32_t start = 0) {
   uint32_t countFound = 0;
   uint32_t countNotFound = 0;
 
@@ -221,10 +222,10 @@ uint32_t doNget(RegionPtr& regionPtr, uint32_t num, uint32_t start = 0) {
 /**
  *  Test the entry operation ( local invalidate, localDestroy ).
  */
-void testEntryDestroy(RegionPtr& regionPtr, uint32_t num) {
-  VectorOfCacheableKey v = regionPtr->keys();
-  VectorOfCacheable vecValues;
-  CacheablePtr valuePtr;
+void testEntryDestroy(std::shared_ptr<Region>& regionPtr, uint32_t num) {
+  std::vector<std::shared_ptr<CacheableKey>> v = regionPtr->keys();
+  std::vector<std::shared_ptr<Cacheable>> vecValues;
+  std::shared_ptr<Cacheable> valuePtr;
   for (uint32_t i = 45; i < 50; i++) {
     try {
       std::cout << "try to destroy key" << i << std::endl;
@@ -238,10 +239,10 @@ void testEntryDestroy(RegionPtr& regionPtr, uint32_t num) {
   ASSERT(v.size() == num - 5, (char*)"size of key vec not equal");
 }
 
-void testEntryInvalidate(RegionPtr& regionPtr, uint32_t num) {
-  VectorOfCacheableKey v = regionPtr->keys();
-  VectorOfCacheable vecValues;
-  CacheablePtr valuePtr;
+void testEntryInvalidate(std::shared_ptr<Region>& regionPtr, uint32_t num) {
+  std::vector<std::shared_ptr<CacheableKey>> v = regionPtr->keys();
+  std::vector<std::shared_ptr<Cacheable>> vecValues;
+  std::shared_ptr<Cacheable> valuePtr;
   for (uint32_t i = 40; i < 45; i++) {
     try {
       std::cout << "try to invalidate key" << i << std::endl;
@@ -257,12 +258,12 @@ void testEntryInvalidate(RegionPtr& regionPtr, uint32_t num) {
 
 class PutThread : public ACE_Task_Base {
  private:
-  RegionPtr m_regPtr;
+  std::shared_ptr<Region> m_regPtr;
   int m_min;
   int m_max;
 
  public:
-  PutThread(RegionPtr& regPtr, int min, int max)
+  PutThread(std::shared_ptr<Region>& regPtr, int min, int max)
       : m_regPtr(regPtr), m_min(min), m_max(max) {}
 
   int svc(void) {
@@ -279,8 +280,8 @@ class PutThread : public ACE_Task_Base {
   void stop() { wait(); }
 };
 
-void verifyGetAll(RegionPtr region, int startIndex) {
-  VectorOfCacheableKey keysVector;
+void verifyGetAll(std::shared_ptr<Region> region, int startIndex) {
+  std::vector<std::shared_ptr<CacheableKey>> keysVector;
   for (int i = 0; i <= 100; i++) keysVector.push_back(CacheableKey::create(i));
 
   // keysVector.push_back(CacheableKey::create(101)); //key not there
@@ -289,7 +290,7 @@ void verifyGetAll(RegionPtr region, int startIndex) {
     int i = startIndex;
     for (const auto& iter : valuesMap) {
       auto key = std::dynamic_pointer_cast<CacheableKey>(iter.first);
-      CacheablePtr mVal = iter.second;
+      auto mVal = iter.second;
       if (mVal != nullptr) {
         int val = atoi(mVal->toString()->asChar());
         ASSERT(val == i, "value not matched");
@@ -298,8 +299,9 @@ void verifyGetAll(RegionPtr region, int startIndex) {
   }
 }
 
-void createRegion(RegionPtr& regionPtr, const char* regionName,
-                  PropertiesPtr& cacheProps, PropertiesPtr& sqLiteProps) {
+void createRegion(std::shared_ptr<Region>& regionPtr, const char* regionName,
+                  std::shared_ptr<Properties>& cacheProps,
+                  std::shared_ptr<Properties>& sqLiteProps) {
   auto cacheFactoryPtr = CacheFactory::createCacheFactory(cacheProps);
   auto cachePtr = CacheFactory::createCacheFactory()->create();
   ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
@@ -314,7 +316,7 @@ void createRegion(RegionPtr& regionPtr, const char* regionName,
   ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
 }
 
-void setSqLiteProperties(PropertiesPtr& sqliteProperties,
+void setSqLiteProperties(std::shared_ptr<Properties>& sqliteProperties,
                          int maxPageCount = 1073741823, int pageSize = 65536,
                          std::string pDir = sqlite_dir) {
   sqliteProperties = Properties::create();
@@ -326,9 +328,10 @@ void setSqLiteProperties(PropertiesPtr& sqliteProperties,
 }
 // creation of subregion.
 
-void createSubRegion(RegionPtr& regionPtr, RegionPtr& subRegion,
-                     const char* regionName, std::string pDir = sqlite_dir) {
-  RegionAttributesPtr regionAttributesPtr;
+void createSubRegion(std::shared_ptr<Region>& regionPtr,
+                     std::shared_ptr<Region>& subRegion, const char* regionName,
+                     std::string pDir = sqlite_dir) {
+  std::shared_ptr<RegionAttributes> regionAttributesPtr;
   setAttributes(regionAttributesPtr, pDir);
   subRegion = regionPtr->createSubregion(regionName, regionAttributesPtr);
   ASSERT(subRegion != nullptr, "Expected region to be NON-nullptr");
@@ -344,10 +347,10 @@ void createSubRegion(RegionPtr& regionPtr, RegionPtr& subRegion,
 BEGIN_TEST(OverFlowTest)
   {
     /** Creating a cache to manage regions. */
-    PropertiesPtr sqliteProperties;
-    PropertiesPtr cacheProperties = Properties::create();
+    std::shared_ptr<Properties> sqliteProperties;
+    auto cacheProperties = Properties::create();
     setSqLiteProperties(sqliteProperties);
-    RegionPtr regionPtr;
+    std::shared_ptr<Region> regionPtr;
     createRegion(regionPtr, "OverFlowRegion", cacheProperties,
                  sqliteProperties);
     ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
@@ -375,7 +378,7 @@ BEGIN_TEST(OverFlowTest)
     /** test to verify same region repeatedly to ensure that the persistece
     files are created and destroyed correctly */
 
-    RegionPtr subRegion;
+    std::shared_ptr<Region> subRegion;
     for (int i = 0; i < 10; i++) {
       createSubRegion(regionPtr, subRegion, "SubRegion");
       ASSERT(subRegion != nullptr, "Expected region to be NON-nullptr");
@@ -402,7 +405,7 @@ END_TEST(OverFlowTest)
 
 BEGIN_TEST(OverFlowTest_absPath)
   {
-    RegionAttributesPtr attrsPtr;
+    std::shared_ptr<RegionAttributes> attrsPtr;
     char currWDPath[512];
     char* wdPath = ACE_OS::getcwd(currWDPath, 512);
     ASSERT(wdPath != nullptr,
@@ -410,10 +413,10 @@ BEGIN_TEST(OverFlowTest_absPath)
     std::string absPersistenceDir = std::string(wdPath) + "/absSqLite";
 
     /** Creating a cache to manage regions. */
-    PropertiesPtr sqliteProperties;
-    PropertiesPtr cacheProperties = Properties::create();
+    std::shared_ptr<Properties> sqliteProperties;
+    auto cacheProperties = Properties::create();
     setSqLiteProperties(sqliteProperties, 1073741823, 65536, absPersistenceDir);
-    RegionPtr regionPtr;
+    std::shared_ptr<Region> regionPtr;
     createRegion(regionPtr, "OverFlowRegion", cacheProperties,
                  sqliteProperties);
     ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
@@ -441,7 +444,7 @@ BEGIN_TEST(OverFlowTest_absPath)
     /** check whether value get evicted and token gets set as overflow */
     checkOverflowTokenValues(regionPtr, 45);
 
-    RegionPtr subRegion;
+    std::shared_ptr<Region> subRegion;
     for (int i = 0; i < 10; i++) {
       createSubRegion(regionPtr, subRegion, "SubRegion", absPersistenceDir);
       ASSERT(subRegion != nullptr, "Expected region to be NON-nullptr");
@@ -539,9 +542,9 @@ BEGIN_TEST(OverFlowTest_HeapLRU)
     /** test to verify same region repeatedly to ensure that the persistece
     files are created and destroyed correctly */
 
-    RegionPtr subRegion;
+    std::shared_ptr<Region> subRegion;
     for (int i = 0; i < 10; i++) {
-      RegionAttributesPtr regionAttributesPtr;
+      std::shared_ptr<RegionAttributes> regionAttributesPtr;
       setAttributes(regionAttributesPtr);
       subRegion = regionPtr->createSubregion("SubRegion", regionAttributesPtr);
       ASSERT(subRegion != nullptr, "Expected region to be NON-nullptr");
@@ -567,15 +570,15 @@ END_TEST(OverFlowTest_HeapLRU)
 BEGIN_TEST(OverFlowTest_MultiThreaded)
   {
     /** Creating a cache to manage regions. */
-    CachePtr cachePtr = CacheFactory::createCacheFactory()->create();
+    auto cachePtr = CacheFactory::createCacheFactory()->create();
     ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
 
-    RegionAttributesPtr attrsPtr;
+    std::shared_ptr<RegionAttributes> attrsPtr;
     setAttributes(attrsPtr);
     ASSERT(attrsPtr != nullptr, "Expected region attributes to be NON-nullptr");
     /** Create a region with caching and LRU. */
 
-    RegionPtr regionPtr;
+    std::shared_ptr<Region> regionPtr;
     CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cachePtr.get());
     cacheImpl->createRegion("OverFlowRegion", attrsPtr, regionPtr);
     ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
@@ -608,15 +611,15 @@ END_TEST(OverFlowTest_MultiThreaded)
 BEGIN_TEST(OverFlowTest_PutGetAll)
   {
     /** Creating a cache to manage regions. */
-    CachePtr cachePtr = CacheFactory::createCacheFactory()->create();
+    auto cachePtr = CacheFactory::createCacheFactory()->create();
     ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
 
-    RegionAttributesPtr attrsPtr;
+    std::shared_ptr<RegionAttributes> attrsPtr;
     setAttributes(attrsPtr);
     ASSERT(attrsPtr != nullptr, "Expected region attributes to be NON-nullptr");
     /** Create a region with caching and LRU. */
 
-    RegionPtr regionPtr;
+    std::shared_ptr<Region> regionPtr;
     CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cachePtr.get());
     cacheImpl->createRegion("OverFlowRegion", attrsPtr, regionPtr);
     ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
diff --git a/cppcache/integration-test/testRegionAccessThreadSafe.cpp b/cppcache/integration-test/testRegionAccessThreadSafe.cpp
index 46ff49ca..541e3258 100644
--- a/cppcache/integration-test/testRegionAccessThreadSafe.cpp
+++ b/cppcache/integration-test/testRegionAccessThreadSafe.cpp
@@ -16,7 +16,6 @@
  */
 #include "fw_dunit.hpp"
 #include "ThinClientHelper.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/Task.h>
 #include <ace/Recursive_Thread_Mutex.h>
 
@@ -41,7 +40,7 @@ class GetRegionThread : public ACE_Task_Base {
     while (m_running == true) {
       SLEEP(40);
       try {
-        RegionPtr rptr = getHelper()->getRegion(m_path.c_str());
+        auto rptr = getHelper()->getRegion(m_path.c_str());
         if (rptr != nullptr) {
           ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_mutex);
           ASSERT(m_regionCreateDone == true, "regionCreate Not Done");
@@ -57,7 +56,7 @@ class GetRegionThread : public ACE_Task_Base {
         continue;
       }
       try {
-        RegionPtr rptr = getHelper()->getRegion(m_subPath.c_str());
+        auto rptr = getHelper()->getRegion(m_subPath.c_str());
         if (rptr != nullptr) {
           ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_mutex);
           ASSERT(m_subRegionCreateDone == true, "subRegionCreate Not Done");
@@ -97,7 +96,7 @@ bool isLocator = true;
 const char* locHostPort =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, numberOfLocators);
 GetRegionThread* getThread = nullptr;
-RegionPtr regionPtr;
+std::shared_ptr<Region> regionPtr;
 DUNIT_TASK(s1p1, Setup)
   {
     CacheHelper::initLocator(1);
@@ -120,9 +119,9 @@ DUNIT_TASK(s2p2, CreateNormalRegion)
         "DistRegionAck", USE_ACK, locHostPort, "__TEST_POOL1__", true, true);
     getThread->setRegionFlag();
     AttributesFactory af;
-    RegionAttributesPtr rattrsPtr = af.createRegionAttributes();
-    getThread->setSubRegionFlag();
-    LOG("create normal region successful");
+   std::shared_ptr<RegionAttributes> rattrsPtr = af.createRegionAttributes();
+   getThread->setSubRegionFlag();
+   LOG("create normal region successful");
   }
 END_TASK(CreateNormalRegion)
 
diff --git a/cppcache/integration-test/testRegionMap.cpp b/cppcache/integration-test/testRegionMap.cpp
index 96a0ff77..a62813e0 100644
--- a/cppcache/integration-test/testRegionMap.cpp
+++ b/cppcache/integration-test/testRegionMap.cpp
@@ -17,8 +17,6 @@
 
 #include <iostream>
 
-#include <geode/GeodeCppCache.hpp>
-
 #include "fw_helper.hpp"
 
 using namespace apache::geode::client;
@@ -33,7 +31,7 @@ using namespace apache::geode::client;
 BEGIN_TEST(TestRegionLRULastTen)
 #if 1
   CacheHelper& cacheHelper = CacheHelper::getHelper();
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheHelper.createLRURegion(fwtest_Name, regionPtr);
   std::cout << regionPtr->getFullPath() << std::endl;
   // put more than 10 items... verify limit is held.
@@ -41,25 +39,25 @@ BEGIN_TEST(TestRegionLRULastTen)
   for (i = 0; i < 10; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     ASSERT(vecKeys.size() == (i + 1), "expected more entries");
   }
   for (i = 10; i < 20; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     cacheHelper.showKeys(vecKeys);
     ASSERT(vecKeys.size() == (10), "expected 10 entries");
   }
-  VectorOfCacheableKey vecKeys = regionPtr->keys();
+  std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
   ASSERT(vecKeys.size() == 10, "expected 10 entries");
   // verify it is the last 10 keys..
   int expected = 0;
@@ -78,18 +76,18 @@ END_TEST(TestRegionLRULastTen)
 BEGIN_TEST(TestRegionNoLRU)
 #if 1
   CacheHelper& cacheHelper = CacheHelper::getHelper();
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheHelper.createPlainRegion(fwtest_Name, regionPtr);
   // put more than 10 items... verify limit is held.
   uint32_t i;
   for (i = 0; i < 20; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     cacheHelper.showKeys(vecKeys);
     ASSERT(vecKeys.size() == (i + 1), "unexpected entries count");
   }
@@ -101,7 +99,7 @@ END_TEST(TestRegionNoLRU)
 BEGIN_TEST(TestRegionLRULocal)
 #if 1
   CacheHelper& cacheHelper = CacheHelper::getHelper();
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheHelper.createLRURegion(fwtest_Name, regionPtr);
   std::cout << regionPtr->getFullPath() << std::endl;
   // put more than 10 items... verify limit is held.
@@ -111,11 +109,11 @@ BEGIN_TEST(TestRegionLRULocal)
   for (i = 0; i < 1000; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     ASSERT(vecKeys.size() == (i < 10 ? i + 1 : 10), "expected more entries");
   }
 
@@ -129,7 +127,7 @@ BEGIN_TEST(TestRecentlyUsedBit)
   // put 9 more...  check that 15 was skipped for eviction.
   // put 1 more...  15 should then have been evicted.
   CacheHelper& cacheHelper = CacheHelper::getHelper();
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheHelper.createLRURegion(fwtest_Name, regionPtr);
   std::cout << regionPtr->getFullPath() << std::endl;
   // put more than 10 items... verify limit is held.
@@ -137,32 +135,32 @@ BEGIN_TEST(TestRecentlyUsedBit)
   char buf[100];
   for (i = 0; i < 20; i++) {
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
   }
   sprintf(buf, "%d", 15);
-  CacheableStringPtr value2Ptr;
-  CacheableKeyPtr key2 = CacheableKey::create(buf);
+  std::shared_ptr<CacheableString> value2Ptr;
+  auto key2 = CacheableKey::create(buf);
   value2Ptr = std::dynamic_pointer_cast<CacheableString>(regionPtr->get(key2));
   ASSERT(value2Ptr != nullptr, "expected to find key 15 in cache.");
   for (i = 20; i < 35; i++) {
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto key = CacheableKey::create(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     cacheHelper.showKeys(vecKeys);
     ASSERT(vecKeys.size() == 10, "expected more entries");
   }
   ASSERT(regionPtr->containsKey(key2), "expected to find key 15 in cache.");
   {
     sprintf(buf, "%d", 35);
-    CacheableKeyPtr key = CacheableKey::create(buf);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto key = CacheableKey::create(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     cacheHelper.showKeys(vecKeys);
     ASSERT(vecKeys.size() == 10, "expected more entries");
   }
@@ -172,7 +170,7 @@ END_TEST(TestRecentlyUsedBit)
 
 BEGIN_TEST(TestEmptiedMap)
   CacheHelper& cacheHelper = CacheHelper::getHelper();
-  RegionPtr regionPtr;
+  std::shared_ptr<Region> regionPtr;
   cacheHelper.createLRURegion(fwtest_Name, regionPtr);
   std::cout << regionPtr->getFullPath() << std::endl;
   // put more than 10 items... verify limit is held.
@@ -180,30 +178,30 @@ BEGIN_TEST(TestEmptiedMap)
   for (i = 0; i < 10; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
-    VectorOfCacheableKey vecKeys = regionPtr->keys();
+    std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
     ASSERT(vecKeys.size() == (i + 1), "expected more entries");
   }
   for (i = 0; i < 10; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     regionPtr->destroy(key);
     std::cout << "removed key "
               << std::dynamic_pointer_cast<CacheableString>(key)->asChar()
               << std::endl;
   }
-  VectorOfCacheableKey vecKeys = regionPtr->keys();
+  std::vector<std::shared_ptr<CacheableKey>> vecKeys = regionPtr->keys();
   ASSERT(vecKeys.size() == 0, "expected more entries");
   for (i = 20; i < 40; i++) {
     char buf[100];
     sprintf(buf, "%d", i);
-    CacheableKeyPtr key = CacheableKey::create(buf);
+    auto key = CacheableKey::create(buf);
     sprintf(buf, "value of %d", i);
-    CacheableStringPtr valuePtr = cacheHelper.createCacheable(buf);
+    auto valuePtr = cacheHelper.createCacheable(buf);
     regionPtr->put(key, valuePtr);
   }
   vecKeys = regionPtr->keys();
diff --git a/cppcache/integration-test/testRegionTemplateArgs.cpp b/cppcache/integration-test/testRegionTemplateArgs.cpp
index 1418bea5..18357e3d 100644
--- a/cppcache/integration-test/testRegionTemplateArgs.cpp
+++ b/cppcache/integration-test/testRegionTemplateArgs.cpp
@@ -17,14 +17,14 @@
 
 #define ROOT_NAME "testRegionTemplateArgs"
 
-#include <geode/GeodeCppCache.hpp>
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
 #include "fw_helper.hpp"
 
 using namespace apache::geode::client;
 
-bool CheckBytesEqual(CacheableBytesPtr result, CacheablePtr expected) {
+bool CheckBytesEqual(std::shared_ptr<CacheableBytes> result,
+                     std::shared_ptr<Cacheable> expected) {
   auto expectedPtr = std::dynamic_pointer_cast<CacheableBytes>(expected);
   // Assume that the bytes are really a char*
   return (strcmp((char*)result->value(), (char*)expectedPtr->value()) == 0);
@@ -35,11 +35,11 @@ bool CheckBytesEqual(CacheableBytesPtr result, CacheablePtr expected) {
 
 BEGIN_TEST(CheckTemplates)
   {
-    CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
-    CachePtr cache = cacheFactoryPtr->create();
+    auto cacheFactoryPtr = CacheFactory::createCacheFactory();
+    auto cache = cacheFactoryPtr->create();
     AttributesFactory afact;
-    RegionAttributesPtr attrs = afact.createRegionAttributes();
-    RegionPtr regPtr;
+    std::shared_ptr<RegionAttributes> attrs = afact.createRegionAttributes();
+    std::shared_ptr<Region> regPtr;
     CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
     cacheImpl->createRegion("TestRegion", attrs, regPtr);
 
@@ -52,18 +52,18 @@ BEGIN_TEST(CheckTemplates)
     const char baseKey[] = "test base key";
     const char baseVal[] = "test base value";
     int int32Key = 100;
-    CacheableStringPtr stringPtr = CacheableString::create(stringKey);
-    CacheableInt32Ptr int32Ptr = CacheableInt32::create(int32Key);
-    CacheableBytesPtr bytesPtr = CacheableBytes::create(
+    auto stringPtr = CacheableString::create(stringKey);
+    auto int32Ptr = CacheableInt32::create(int32Key);
+    auto bytesPtr = CacheableBytes::create(
         reinterpret_cast<const uint8_t*>(stringVal), sizeof(stringVal));
-    CacheableKeyPtr keyPtr = CacheableString::create(baseKey);
-    CacheablePtr valPtr = CacheableBytes::create(
+    auto keyPtr = CacheableString::create(baseKey);
+    auto valPtr = CacheableBytes::create(
         reinterpret_cast<const uint8_t*>(baseVal), sizeof(baseVal));
 
-    CacheableBytesPtr resValPtr;
-    CacheableStringPtr resStringPtr;
-    CacheableInt32Ptr resInt32Ptr;
-    RegionEntryPtr resEntryPtr;
+    std::shared_ptr<CacheableBytes> resValPtr;
+    std::shared_ptr<CacheableString> resStringPtr;
+    std::shared_ptr<CacheableInt32> resInt32Ptr;
+    std::shared_ptr<RegionEntry> resEntryPtr;
 
     /* ------ Test puts/gets of various shapes and sizes --------- */
 
diff --git a/cppcache/integration-test/testSerialization.cpp b/cppcache/integration-test/testSerialization.cpp
index 49419623..0f688290 100644
--- a/cppcache/integration-test/testSerialization.cpp
+++ b/cppcache/integration-test/testSerialization.cpp
@@ -22,7 +22,6 @@
 
 #define ROOT_SCOPE DISTRIBUTED_ACK
 
-#include <geode/GeodeCppCache.hpp>
 #include <SerializationRegistry.hpp>
 #include <geode/CacheableString.hpp>
 #include <geode/GeodeTypeIds.hpp>
@@ -106,8 +105,8 @@ class OtherType : public Serializable {
 
   uint32_t size() const { return sizeof(CData); }
 
-  static CacheablePtr uniqueCT(int32_t i,
-                               int32_t classIdToReturn = g_classIdToReturn) {
+  static std::shared_ptr<Cacheable> uniqueCT(
+      int32_t i, int32_t classIdToReturn = g_classIdToReturn) {
     OtherType* ot = new OtherType(classIdToReturn);
     ot->m_struct.a = (int)i;
     ot->m_struct.b = (i % 2 == 0) ? true : false;
@@ -119,10 +118,10 @@ class OtherType : public Serializable {
 
     printf("double hex 0x%016" PRIX64 "\n", ot->m_struct.e);
 
-    return CacheablePtr(ot);
+    return std::shared_ptr<Cacheable>(ot);
   }
 
-  static void validateCT(int32_t i, const CacheablePtr otPtr) {
+  static void validateCT(int32_t i, const std::shared_ptr<Cacheable> otPtr) {
     char logmsg[1000];
     sprintf(logmsg, "validateCT for %d", i);
     LOG(logmsg);
@@ -145,8 +144,7 @@ class OtherType : public Serializable {
 #define NoDist s2p2
 #define Sender s1p1
 #define Receiver s1p2
-
-RegionPtr regionPtr;
+std::shared_ptr<Region> regionPtr;
 
 DUNIT_TASK(Receiver, SetupR)
   {
@@ -161,7 +159,7 @@ DUNIT_TASK(Sender, SetupAndPutInts)
   {
     initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, nullptr, 0,
                        true);
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     serializationRegistry->addType(OtherType::createDeserializable);
diff --git a/cppcache/integration-test/testSpinLock.cpp b/cppcache/integration-test/testSpinLock.cpp
index 7c134416..15b380a8 100644
--- a/cppcache/integration-test/testSpinLock.cpp
+++ b/cppcache/integration-test/testSpinLock.cpp
@@ -18,7 +18,6 @@
 #define ROOT_NAME "testSpinLock"
 
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 
 #include <mutex>
 #include <util/concurrent/spinlock_mutex.hpp>
diff --git a/cppcache/integration-test/testSystemProperties.cpp b/cppcache/integration-test/testSystemProperties.cpp
index 9c725765..87d40729 100644
--- a/cppcache/integration-test/testSystemProperties.cpp
+++ b/cppcache/integration-test/testSystemProperties.cpp
@@ -18,7 +18,6 @@
 #define ROOT_NAME "testSystemProperties"
 
 #include "fw_helper.hpp"
-#include "geode/GeodeCppCache.hpp"
 #include "geode/SystemProperties.hpp"
 #include "geode/Properties.hpp"
 
@@ -28,13 +27,14 @@
 
 using namespace apache::geode::client;
 
-const bool checkSecurityProperties(PropertiesPtr securityProperties,
-                                   const char* key, const char* value) {
+const bool checkSecurityProperties(
+    std::shared_ptr<Properties> securityProperties, const char* key,
+    const char* value) {
   bool flag;
   if (key == nullptr || value == nullptr) {
     return false;
   }
-  CacheableStringPtr tempValue = securityProperties->find(key);
+  auto tempValue = securityProperties->find(key);
   if (tempValue == nullptr) {
     return (false);
   }
@@ -156,7 +156,7 @@ BEGIN_TEST(NEW_CONFIG)
     ASSERT(sp->connectTimeout() == std::chrono::milliseconds(345),
            "expected 345 for connect timeout");
 
-    PropertiesPtr securityProperties = sp->getSecurityProperties();
+    auto securityProperties = sp->getSecurityProperties();
     ASSERT(checkSecurityProperties(securityProperties, "security-username",
                                    "username") == true,
            "SecurityProperties Not Stored");
diff --git a/cppcache/integration-test/testThinClientAfterRegionLive.cpp b/cppcache/integration-test/testThinClientAfterRegionLive.cpp
index ffaa6311..d76aded0 100644
--- a/cppcache/integration-test/testThinClientAfterRegionLive.cpp
+++ b/cppcache/integration-test/testThinClientAfterRegionLive.cpp
@@ -40,7 +40,7 @@ class DisconnectCacheListioner : public CacheListener {
  public:
   explicit DisconnectCacheListioner(int index) { m_index = index; };
 
-  void afterRegionDisconnected(const RegionPtr& region) {
+  void afterRegionDisconnected(const std::shared_ptr<Region>& region) {
     isRegionDead[m_index] = true;
     LOG("After Region Disconnected event received");
   }
@@ -59,12 +59,12 @@ auto cptr4 = std::make_shared<DisconnectCacheListioner>(3);
 
 void createPooledRegionMine(bool callReadyForEventsAPI = false) {
   auto& poolManager = getHelper()->getCache()->getPoolManager();
-  PoolFactoryPtr poolFacPtr = poolManager.createFactory();
+  auto poolFacPtr = poolManager.createFactory();
   poolFacPtr->setSubscriptionEnabled(true);
   getHelper()->addServerLocatorEPs(locatorsG, poolFacPtr);
   if ((poolManager.find("__TEST_POOL1__")) ==
       nullptr) {  // Pool does not exist with the same name.
-    PoolPtr pptr = poolFacPtr->create("__TEST_POOL1__");
+    auto pptr = poolFacPtr->create("__TEST_POOL1__");
   }
   SLEEP(10000);
   AttributesFactory af;
@@ -78,21 +78,21 @@ void createPooledRegionMine(bool callReadyForEventsAPI = false) {
   LOG("poolName = ");
   LOG("__TEST_POOL1__");
   af.setCacheListener(cptr1);
-  RegionAttributesPtr rattrsPtr1 = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr1 = af.createRegionAttributes();
   af.setCacheListener(cptr2);
-  RegionAttributesPtr rattrsPtr2 = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr2 = af.createRegionAttributes();
   af.setCacheListener(cptr3);
-  RegionAttributesPtr rattrsPtr3 = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr3 = af.createRegionAttributes();
   af.setCacheListener(cptr4);
-  RegionAttributesPtr rattrsPtr4 = af.createRegionAttributes();
+  std::shared_ptr<RegionAttributes> rattrsPtr4 = af.createRegionAttributes();
   CacheImpl* cacheImpl =
       CacheRegionHelper::getCacheImpl(getHelper()->cachePtr.get());
-  RegionPtr region1;
+  std::shared_ptr<Region> region1;
   cacheImpl->createRegion(regionNames[0], rattrsPtr1, region1);
-  RegionPtr region2;
+  std::shared_ptr<Region> region2;
   cacheImpl->createRegion(regionNames[1], rattrsPtr2, region2);
-  RegionPtr subregion1 = region1->createSubregion(regionNames[0], rattrsPtr3);
-  RegionPtr subregion2 = region2->createSubregion(regionNames[1], rattrsPtr4);
+  auto subregion1 = region1->createSubregion(regionNames[0], rattrsPtr3);
+  auto subregion2 = region2->createSubregion(regionNames[1], rattrsPtr4);
   if (callReadyForEventsAPI) {
     getHelper()->cachePtr->readyForEvents();
   }
@@ -106,7 +106,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, NotAutoReady_CallReadyForEvents)
   {
-    PropertiesPtr props(Properties::create());
+    std::shared_ptr<Properties> props(Properties::create());
     props->insert("auto-ready-for-events", "false");
     initClient(true, props);
     createPooledRegionMine(true);
@@ -115,7 +115,7 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, NotAutoReady_DontCallReadyForEvents)
   {
-    PropertiesPtr props(Properties::create());
+    std::shared_ptr<Properties> props(Properties::create());
     props->insert("auto-ready-for-events", "false");
     initClient(true, props);
     createPooledRegionMine(false);
@@ -185,9 +185,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, populateServer)
   {
     SLEEP(10000);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr = createKey("PXR");
-    CacheableStringPtr valPtr = CacheableString::create("PXR1");
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr = createKey("PXR");
+    auto valPtr = CacheableString::create("PXR1");
     regPtr->create(keyPtr, valPtr);
   }
 END_TASK_DEFINITION
diff --git a/cppcache/integration-test/testThinClientBigValue.cpp b/cppcache/integration-test/testThinClientBigValue.cpp
index c88065f1..4ff1c544 100644
--- a/cppcache/integration-test/testThinClientBigValue.cpp
+++ b/cppcache/integration-test/testThinClientBigValue.cpp
@@ -34,9 +34,9 @@ using namespace test;
 
 void grow(int* iptr) { *iptr = *iptr + GROWTH; }
 
-void putSize(RegionPtr& rptr, const char* buf, int size) {
+void putSize(std::shared_ptr<Region>& rptr, const char* buf, int size) {
   char msg[1024];
-  CacheableKeyPtr keyPtr = CacheableKey::create(buf);
+  auto keyPtr = CacheableKey::create(buf);
   uint8_t base = 0;
 
   uint8_t* valbuf = new uint8_t[size + 1];
@@ -48,8 +48,8 @@ void putSize(RegionPtr& rptr, const char* buf, int size) {
       base++;
     }
   }
-  CacheableBytesPtr valPtr = CacheableBytes::create(valbuf, size);
-  // CacheableStringPtr valPtr = CacheableString::create( valbuf);
+  auto valPtr = CacheableBytes::create(valbuf, size);
+  // auto valPtr = CacheableString::create( valbuf);
   sprintf(msg, "about to put key: %s, with value size: %d", buf, size);
   LOG(msg);
   rptr->put(keyPtr, valPtr);
@@ -58,7 +58,7 @@ void putSize(RegionPtr& rptr, const char* buf, int size) {
   LOG(msg);
 }
 
-void verify(CacheableBytesPtr& valuePtr, int size) {
+void verify(std::shared_ptr<CacheableBytes>& valuePtr, int size) {
   char msg[200];
   sprintf(msg, "verifying value of size %d", size);
   ASSERT(size == 0 || valuePtr != nullptr, msg);
@@ -126,7 +126,7 @@ END_TASK(SetupClient2)
 
 DUNIT_TASK(CLIENT1, puts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     char buf[1024];
     LOG("Beginning puts.");
     int expectEntries = 0;
@@ -145,7 +145,7 @@ END_TASK(puts)
 
 DUNIT_TASK(CLIENT2, VerifyPuts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     // region should already have n entries...
     int entriesExpected ATTR_UNUSED =
         dunit::globals()->getIntValue("entriesToExpect");
@@ -153,8 +153,8 @@ DUNIT_TASK(CLIENT2, VerifyPuts)
     for (int i = 0; i <= MAX_PAYLOAD; grow(&i)) {
       char keybuf[100];
       sprintf(keybuf, "key%010d", i);
-      CacheableKeyPtr keyPtr = CacheableKey::create(keybuf);
-      CacheableBytesPtr valPtr =
+      auto keyPtr = CacheableKey::create(keybuf);
+      auto valPtr =
           std::dynamic_pointer_cast<CacheableBytes>(regPtr->get(keyPtr));
       int ntry = 20;
       while ((ntry-- > 0) && (valPtr == nullptr)) {
@@ -170,7 +170,7 @@ END_TASK(VerifyPuts)
 
 DUNIT_TASK(CLIENT1, ManyPuts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     LOG("Beginning many puts.");
     int expectEntries = 0;
     char keybuf[100];
@@ -188,7 +188,7 @@ END_TASK(ManyPuts)
 
 DUNIT_TASK(CLIENT2, VerifyManyPuts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     // region should already have n entries...
     int entriesExpected = dunit::globals()->getIntValue("entriesToExpect");
 
@@ -206,7 +206,7 @@ END_TASK(VerifyManyPuts)
 
 DUNIT_TASK(CLIENT1, UpdateManyPuts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     LOG("Beginning updated many puts.");
     int expectEntries = 0;
     char keybuf[100];
@@ -225,7 +225,7 @@ END_TASK(UpdateManyPuts)
 DUNIT_TASK(CLIENT2, VerifyOldManyPuts)
   {
     // region should given old entries from cache
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     int entriesExpected = dunit::globals()->getIntValue("entriesToExpect");
 
     char keybuf[100];
@@ -243,7 +243,7 @@ END_TASK(VerifyOldManyPuts)
 
 DUNIT_TASK(CLIENT2, VerifyUpdatedManyPuts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     // region should already have n entries...
     int entriesExpected = dunit::globals()->getIntValue("entriesToExpect");
     // invalidate the region to force getting new values
@@ -264,13 +264,13 @@ END_TASK(VerifyUpdatedManyPuts)
 
 DUNIT_TASK(CLIENT2, VerifyUpdatedManyPutsGetAll)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     // region should already have n entries...
     int entriesExpected = dunit::globals()->getIntValue("entriesToExpect");
     // invalidate the region to force getting new values
     regPtr->localInvalidateRegion();
 
-    VectorOfCacheableKey vec;
+    std::vector<std::shared_ptr<CacheableKey>> vec;
     char keybuf[100];
     for (int index = 0; index < entriesExpected; ++index) {
       sprintf(keybuf, "keys1%010d", index);
@@ -309,12 +309,12 @@ END_TASK(UpdateManyPutsInt64)
 
 DUNIT_TASK(CLIENT2, VerifyManyPutsInt64)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     int entriesExpected = dunit::globals()->getIntValue("entriesToExpect");
 
     for (int64_t index = 0; index < entriesExpected; ++index) {
       int64_t key = index * index * index;
-      // CacheableStringPtr valPtr =
+      // auto valPtr =
       // std::dynamic_pointer_cast<CacheableString>(regPtr->get(key));
       auto valPtr = std::dynamic_pointer_cast<CacheableString>(
           regPtr->get(CacheableInt64::create(key)));
@@ -324,11 +324,11 @@ DUNIT_TASK(CLIENT2, VerifyManyPutsInt64)
     LOG("On client Found all int64 entries with "
         "correct size via get.");
     for (int64_t index = 0; index < entriesExpected; ++index) {
-      // CacheableKeyPtr key =
+      // auto key =
       // CacheableKey::create(CacheableInt64::create(index
       // * index * index));
-      CacheableKeyPtr key = CacheableInt64::create(index * index * index);
-      RegionEntryPtr entry = regPtr->getEntry(key);
+      auto key = CacheableInt64::create(index * index * index);
+      auto entry = regPtr->getEntry(key);
       ASSERT(entry != nullptr, "expected non-null entry");
       auto valPtr =
           std::dynamic_pointer_cast<CacheableString>(entry->getValue());
@@ -342,14 +342,14 @@ END_TASK(VerifyManyPutsInt64)
 
 DUNIT_TASK(CLIENT2, VerifyUpdatedManyPutsInt64GetAll)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     // region should already have n entries...
     int entriesExpected = dunit::globals()->getIntValue("entriesToExpect");
     // invalidate the region to force getting new
     // values
     regPtr->localInvalidateRegion();
 
-    VectorOfCacheableKey vec;
+    std::vector<std::shared_ptr<CacheableKey>> vec;
     for (int64_t index = 0; index < entriesExpected; ++index) {
       int64_t key = index * index * index;
       vec.push_back(CacheableInt64::create(key));
diff --git a/cppcache/integration-test/testThinClientCacheableStringArray.cpp b/cppcache/integration-test/testThinClientCacheableStringArray.cpp
index b6f56965..b2485000 100644
--- a/cppcache/integration-test/testThinClientCacheableStringArray.cpp
+++ b/cppcache/integration-test/testThinClientCacheableStringArray.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <ace/Task.h>
@@ -69,25 +68,29 @@ DUNIT_TASK(CLIENT1, StepOne)
   {
     initClientWithPool(true, "__TEST_POOL1__", locHostPort, nullptr, nullptr, 0,
                        true);
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
 
     serializationRegistry->addType(Position::createDeserializable);
     serializationRegistry->addType(Portfolio::createDeserializable);
 
-    RegionPtr regptr = getHelper()->createPooledRegion(
+    auto regptr = getHelper()->createPooledRegion(
         _regionNames[0], USE_ACK, locHostPort, "__TEST_POOL1__", true, true);
-    RegionAttributesPtr lattribPtr = regptr->getAttributes();
-    RegionPtr subregPtr = regptr->createSubregion(_regionNames[1], lattribPtr);
+    std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+    auto subregPtr = regptr->createSubregion(_regionNames[1], lattribPtr);
 
     QueryHelper* qh = &QueryHelper::getHelper();
-    CacheableStringPtr cstr[4] = {
-        CacheableStringPtr(CacheableString::create((const char*)"Taaa", 4)),
-        CacheableStringPtr(CacheableString::create((const char*)"Tbbb", 4)),
-        CacheableStringPtr(CacheableString::create((const char*)"Tccc", 4)),
-        CacheableStringPtr(CacheableString::create((const char*)"Tddd", 4))};
-    CacheableStringArrayPtr nm = CacheableStringArray::create(cstr, 4);
+    std::shared_ptr<CacheableString> cstr[4] = {
+        std::shared_ptr<CacheableString>(
+            CacheableString::create((const char*)"Taaa", 4)),
+        std::shared_ptr<CacheableString>(
+            CacheableString::create((const char*)"Tbbb", 4)),
+        std::shared_ptr<CacheableString>(
+            CacheableString::create((const char*)"Tccc", 4)),
+        std::shared_ptr<CacheableString>(
+            CacheableString::create((const char*)"Tddd", 4))};
+    auto nm = CacheableStringArray::create(cstr, 4);
     qh->populatePortfolioData(regptr, 4, 3, 2, nm);
     qh->populatePositionData(subregPtr, 4, 3);
 
@@ -98,12 +101,11 @@ END_TASK(StepOne)
 DUNIT_TASK(CLIENT1, StepThree)
   {
     try {
-      QueryServicePtr qs =
-          getHelper()->cachePtr->getQueryService("__TEST_POOL1__");
+      auto qs = getHelper()->cachePtr->getQueryService("__TEST_POOL1__");
 
       char* qryStr = (char*)"select * from /Portfolios p where p.ID < 3";
-      QueryPtr qry = qs->newQuery(qryStr);
-      SelectResultsPtr results;
+      auto qry = qs->newQuery(qryStr);
+      std::shared_ptr<SelectResults> results;
       results = qry->execute();
 
       SelectResultsIterator iter = results->getIterator();
@@ -113,9 +115,9 @@ DUNIT_TASK(CLIENT1, StepThree)
       LOG(buf);
       while (iter.hasNext()) {
         count--;
-        SerializablePtr ser = iter.next();
-        PortfolioPtr portfolio = std::dynamic_pointer_cast<Portfolio>(ser);
-        PositionPtr position = std::dynamic_pointer_cast<Position>(ser);
+        auto ser = iter.next();
+        auto portfolio = std::dynamic_pointer_cast<Portfolio>(ser);
+        auto position = std::dynamic_pointer_cast<Position>(ser);
 
         if (portfolio != nullptr) {
           printf("   query pulled portfolio object ID %d, pkid %s\n",
diff --git a/cppcache/integration-test/testThinClientCacheables.cpp b/cppcache/integration-test/testThinClientCacheables.cpp
index 195da71a..9a2efbb3 100644
--- a/cppcache/integration-test/testThinClientCacheables.cpp
+++ b/cppcache/integration-test/testThinClientCacheables.cpp
@@ -14,8 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#define ROOT_NAME "testThinClientCacheables"
+#define ROOT_SCOPE DISTRIBUTED_ACK
+
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include "BuiltinCacheableWrappers.hpp"
 #include <Utils.hpp>
 
@@ -24,9 +27,6 @@
 
 #include <string>
 
-#define ROOT_NAME "testThinClientCacheables"
-#define ROOT_SCOPE DISTRIBUTED_ACK
-
 #include "CacheHelper.hpp"
 
 using namespace apache::geode::client;
@@ -71,14 +71,15 @@ void createRegion(const char* name, bool ackMode,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
 
 void checkGets(int maxKeys, int8_t keyTypeId, int8_t valTypeId,
-               const RegionPtr& dataReg, const RegionPtr& verifyReg) {
+               const std::shared_ptr<Region>& dataReg,
+               const std::shared_ptr<Region>& verifyReg) {
   for (int i = 0; i < maxKeys; i++) {
     CacheableWrapper* tmpkey =
         CacheableWrapperFactory::createInstance(keyTypeId);
@@ -88,11 +89,11 @@ void checkGets(int maxKeys, int8_t keyTypeId, int8_t valTypeId,
     ASSERT(tmpval != nullptr, "tmpval is nullptr");
     tmpkey->initKey(i, KEYSIZE);
     auto key = std::dynamic_pointer_cast<CacheableKey>(tmpkey->getCacheable());
-    CacheablePtr val = dataReg->get(key);
+    auto val = dataReg->get(key);
     // also check that value is in local cache
-    RegionEntryPtr entry = dataReg->getEntry(key);
+    auto entry = dataReg->getEntry(key);
     ASSERT(entry != nullptr, "entry is nullptr");
-    CacheablePtr localVal = entry->getValue();
+    auto localVal = entry->getValue();
     uint32_t keychksum = tmpkey->getCheckSum();
     auto int32val = std::dynamic_pointer_cast<CacheableInt32>(
         verifyReg->get(static_cast<int32_t>(keychksum)));
@@ -149,10 +150,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutsTask)
     LOG("PutsTask started.");
     static int taskIndexPut = 0;
 
-    std::vector<int8_t> keyTypes =
-        CacheableWrapperFactory::getRegisteredKeyTypes();
-    std::vector<int8_t> valueTypes =
-        CacheableWrapperFactory::getRegisteredValueTypes();
+    auto keyTypes = CacheableWrapperFactory::getRegisteredKeyTypes();
+    auto valueTypes = CacheableWrapperFactory::getRegisteredValueTypes();
 
     size_t keyTypeIndex = taskIndexPut / valueTypes.size();
     size_t valueTypeIndex = taskIndexPut % valueTypes.size();
@@ -170,8 +169,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutsTask)
         (key->maxKeys() < DEFAULTNUMKEYS ? key->maxKeys() : DEFAULTNUMKEYS);
     delete key;
 
-    RegionPtr dataReg = getHelper()->getRegion(regionNames[0]);
-    RegionPtr verifyReg = getHelper()->getRegion(regionNames[1]);
+    auto dataReg = getHelper()->getRegion(regionNames[0]);
+    auto verifyReg = getHelper()->getRegion(regionNames[1]);
     for (int i = 0; i < maxKeys; i++) {
       CacheableWrapper* tmpkey =
           CacheableWrapperFactory::createInstance(keyTypeId);
@@ -202,9 +201,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutsTask)
       verifyReg->put(static_cast<int32_t>(keychksum),
                      static_cast<int32_t>(valchksum));
       // also check that value is in local cache
-      RegionEntryPtr entry = dataReg->getEntry(
+      auto entry = dataReg->getEntry(
           std::dynamic_pointer_cast<CacheableKey>(tmpkey->getCacheable()));
-      CacheablePtr localVal;
+      std::shared_ptr<Cacheable> localVal;
       if (entry != nullptr) {
         localVal = entry->getValue();
       }
@@ -224,10 +223,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, GetsTask)
     LOG("GetsTask started.");
     static int taskIndexGet = 0;
 
-    std::vector<int8_t> keyTypes =
-        CacheableWrapperFactory::getRegisteredKeyTypes();
-    std::vector<int8_t> valueTypes =
-        CacheableWrapperFactory::getRegisteredValueTypes();
+    auto keyTypes = CacheableWrapperFactory::getRegisteredKeyTypes();
+    auto valueTypes = CacheableWrapperFactory::getRegisteredValueTypes();
 
     size_t keyTypeIndex = taskIndexGet / valueTypes.size();
     size_t valueTypeIndex = taskIndexGet % valueTypes.size();
@@ -245,8 +242,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, GetsTask)
         (key->maxKeys() < DEFAULTNUMKEYS ? key->maxKeys() : DEFAULTNUMKEYS);
     delete key;
 
-    RegionPtr dataReg = getHelper()->getRegion(regionNames[0]);
-    RegionPtr verifyReg = getHelper()->getRegion(regionNames[1]);
+    auto dataReg = getHelper()->getRegion(regionNames[0]);
+    auto verifyReg = getHelper()->getRegion(regionNames[1]);
     dataReg->localInvalidateRegion();
     verifyReg->localInvalidateRegion();
     checkGets(maxKeys, keyTypeId, valTypeId, dataReg, verifyReg);
diff --git a/cppcache/integration-test/testThinClientCacheablesLimits.cpp b/cppcache/integration-test/testThinClientCacheablesLimits.cpp
index 1b70a5f8..f06eb6e7 100644
--- a/cppcache/integration-test/testThinClientCacheablesLimits.cpp
+++ b/cppcache/integration-test/testThinClientCacheablesLimits.cpp
@@ -14,8 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#define ROOT_NAME "testThinClientCacheablesLimits"
+#define ROOT_SCOPE DISTRIBUTED_ACK
+
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include "BuiltinCacheableWrappers.hpp"
 
 #include <ace/OS.h>
@@ -23,8 +26,6 @@
 
 #include <cstring>
 
-#define ROOT_NAME "testThinClientCacheablesLimits"
-#define ROOT_SCOPE DISTRIBUTED_ACK
 
 #include "CacheHelper.hpp"
 #include "ThinClientHelper.hpp"
@@ -64,8 +65,8 @@ void createRegion(const char* name, bool ackMode,
   LOG("createRegion() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, false, nullptr,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, false, nullptr,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -105,15 +106,14 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, PutsTask)
   {
     int sizeArray = sizeof(keyArr) / sizeof(int);
-    RegionPtr verifyReg = getHelper()->getRegion(_regionNames[1]);
+    auto verifyReg = getHelper()->getRegion(_regionNames[1]);
     for (int count = 0; count < sizeArray; count++) {
       uint8_t* ptr = createRandByteArray(keyArr[count]);
       char* ptrChar = createRandCharArray(keyArr[count]);
 
-      CacheableBytesPtr emptyBytesArr = CacheableBytes::create();
-      CacheableBytesPtr bytePtrSent =
-          CacheableBytes::createNoCopy(ptr, keyArr[count]);
-      CacheableStringPtr stringPtrSent =
+      auto emptyBytesArr = CacheableBytes::create();
+      auto bytePtrSent = CacheableBytes::createNoCopy(ptr, keyArr[count]);
+      auto stringPtrSent =
           CacheableString::createNoCopy(ptrChar, keyArr[count]);
 
       verifyReg->put(KEY_BYTE, bytePtrSent);
diff --git a/cppcache/integration-test/testThinClientClearRegion.cpp b/cppcache/integration-test/testThinClientClearRegion.cpp
index 17307d0b..3dbf838c 100644
--- a/cppcache/integration-test/testThinClientClearRegion.cpp
+++ b/cppcache/integration-test/testThinClientClearRegion.cpp
@@ -71,8 +71,8 @@ DUNIT_TASK(CLIENT1, SetupClient1)
                        true);
     getHelper()->createPooledRegion(regionNames[0], false, locHostPort,
                                     "__TEST_POOL1__", true, true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    AttributesMutatorPtr mtor = regPtr->getAttributesMutator();
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto mtor = regPtr->getAttributesMutator();
     auto lster = std::make_shared<MyCacheListener>();
     auto wter = std::make_shared<MyCacheWriter>();
     mtor->setCacheListener(lster);
@@ -87,10 +87,10 @@ DUNIT_TASK(CLIENT2, SetupClient2)
                        true);
     getHelper()->createPooledRegion(regionNames[0], false, locHostPort,
                                     "__TEST_POOL1__", true, true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys();
-    CacheableKeyPtr keyPtr = CacheableKey::create((const char*)"key01");
-    CacheableBytesPtr valPtr =
+    auto keyPtr = CacheableKey::create((const char*)"key01");
+    auto valPtr =
         CacheableBytes::create(reinterpret_cast<const uint8_t*>("value01"), 7);
     regPtr->put(keyPtr, valPtr);
     ASSERT(regPtr->size() == 1, "size incorrect");
@@ -99,7 +99,7 @@ END_TASK(SetupClient2)
 
 DUNIT_TASK(CLIENT1, clear)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr->size() == 1, "size incorrect");
     regPtr->clear();
     ASSERT(regPtr->size() == 0, "size incorrect");
@@ -108,10 +108,10 @@ END_TASK(clear)
 
 DUNIT_TASK(CLIENT2, VerifyClear)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr->size() == 0, "size incorrect");
-    CacheableKeyPtr keyPtr = CacheableKey::create((const char*)"key02");
-    CacheableBytesPtr valPtr =
+    auto keyPtr = CacheableKey::create((const char*)"key02");
+    auto valPtr =
         CacheableBytes::create(reinterpret_cast<const uint8_t*>("value02"), 7);
     regPtr->put(keyPtr, valPtr);
     ASSERT(regPtr->size() == 1, "size incorrect");
@@ -123,20 +123,20 @@ END_TASK(VerifyClear)
 
 DUNIT_TASK(CLIENT1, VerifyClear1)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     ASSERT(regPtr->size() == 1, "size incorrect");
     regPtr->localClear();
     ASSERT(regPtr->size() == 0, "size incorrect");
-    CacheableKeyPtr keyPtr = CacheableKey::create((const char*)"key02");
+    auto keyPtr = CacheableKey::create((const char*)"key02");
     ASSERT(regPtr->containsKeyOnServer(keyPtr), "key should be there");
-    RegionAttributesPtr attr = regPtr->getAttributes();
-    CacheListenerPtr clp = attr->getCacheListener();
+    std::shared_ptr<RegionAttributes> attr = regPtr->getAttributes();
+    auto clp = attr->getCacheListener();
     MyCacheListener* mcl = dynamic_cast<MyCacheListener*>(clp.get());
     char buf[1024];
     sprintf(buf, "listener clear count=%d", mcl->getClearCnt());
     LOG(buf);
     ASSERT(mcl->getClearCnt() == 2, buf);
-    CacheWriterPtr cwp = attr->getCacheWriter();
+    auto cwp = attr->getCacheWriter();
     MyCacheWriter* mcw = dynamic_cast<MyCacheWriter*>(cwp.get());
     sprintf(buf, "writer clear count=%d", mcw->getClearCnt());
     LOG(buf);
diff --git a/cppcache/integration-test/testThinClientConflation.cpp b/cppcache/integration-test/testThinClientConflation.cpp
index c13ae952..babd98c6 100644
--- a/cppcache/integration-test/testThinClientConflation.cpp
+++ b/cppcache/integration-test/testThinClientConflation.cpp
@@ -80,18 +80,12 @@ class OperMonitor : public CacheListener {
     ASSERT(m_value == 5, buf);
   }
 };
-typedef std::shared_ptr<OperMonitor> OperMonitorPtr;
 
-void setCacheListener(const char* regName, OperMonitorPtr monitor) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName, std::shared_ptr<OperMonitor> monitor) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(monitor);
-}
-
-OperMonitorPtr mon1C1 = nullptr;
-OperMonitorPtr mon2C1 = nullptr;
-OperMonitorPtr mon1C2 = nullptr;
-OperMonitorPtr mon2C2 = nullptr;
+}std::shared_ptr<OperMonitor> mon1C1 = nullptr;std::shared_ptr<OperMonitor> mon2C1=nullptr;std::shared_ptr<OperMonitor> mon1C2=nullptr;std::shared_ptr<OperMonitor> mon2C2=nullptr;
 
 const char* regions[] = {"ConflatedRegion", "NonConflatedRegion"};
 
@@ -99,7 +93,7 @@ const char* regions[] = {"ConflatedRegion", "NonConflatedRegion"};
 #include "ThinClientTasks_C2S2.hpp"
 #include "LocatorHelper.hpp"
 
-void initClientCache(OperMonitorPtr& mon1, OperMonitorPtr& mon2, int durableIdx,
+void initClientCache(std::shared_ptr<OperMonitor>& mon1, std::shared_ptr<OperMonitor>& mon2, int durableIdx,
                      const char* conflation) {
   initClientAndTwoRegions(durableIdx, 0, std::chrono::seconds(300), conflation,
                           regions);
@@ -110,8 +104,8 @@ void initClientCache(OperMonitorPtr& mon1, OperMonitorPtr& mon2, int durableIdx,
 
   setCacheListener(regions[0], mon1);
   setCacheListener(regions[1], mon2);
-  RegionPtr regPtr0 = getHelper()->getRegion(regions[0]);
-  RegionPtr regPtr1 = getHelper()->getRegion(regions[1]);
+ auto regPtr0 = getHelper()->getRegion(regions[0]);
+ auto regPtr1 = getHelper()->getRegion(regions[1]);
 
   regPtr0->registerAllKeys(true);
   regPtr1->registerAllKeys(true);
diff --git a/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp b/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
index b07bf1a0..9e975b42 100644
--- a/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
+++ b/cppcache/integration-test/testThinClientContainsKeyOnServer.cpp
@@ -44,8 +44,8 @@ DUNIT_TASK(CLIENT1, SetupClient1)
                        true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr key = CacheableKey::create((const char*)"key01");
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto key = CacheableKey::create((const char*)"key01");
     ASSERT(!regPtr->containsKeyOnServer(key), "key should not be there");
   }
 END_TASK(SetupClient1)
@@ -56,17 +56,17 @@ DUNIT_TASK(CLIENT2, SetupClient2)
                        true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr key = CacheableKey::create((const char*)"key01");
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto key = CacheableKey::create((const char*)"key01");
     ASSERT(!regPtr->containsKeyOnServer(key), "key should not be there");
   }
 END_TASK(SetupClient2)
 
 DUNIT_TASK(CLIENT1, puts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr = CacheableKey::create((const char*)"key01");
-    CacheableBytesPtr valPtr =
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr = CacheableKey::create((const char*)"key01");
+    auto valPtr =
         CacheableBytes::create(reinterpret_cast<const uint8_t*>("value01"), 7);
     regPtr->put(keyPtr, valPtr);
     ASSERT(regPtr->containsKeyOnServer(keyPtr), "key should be there");
@@ -75,8 +75,8 @@ END_TASK(puts)
 
 DUNIT_TASK(CLIENT2, VerifyPuts)
   {
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr = CacheableKey::create((const char*)"key01");
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr = CacheableKey::create((const char*)"key01");
     ASSERT(regPtr->containsKeyOnServer(keyPtr), "key should be there");
   }
 END_TASK(VerifyPuts)
diff --git a/cppcache/integration-test/testThinClientCq.cpp b/cppcache/integration-test/testThinClientCq.cpp
index 81225db0..fd2a51e5 100644
--- a/cppcache/integration-test/testThinClientCq.cpp
+++ b/cppcache/integration-test/testThinClientCq.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <geode/CqAttributesFactory.hpp>
 #include <geode/CqAttributes.hpp>
 #include <geode/CqListener.hpp>
@@ -83,7 +82,7 @@ void initClientCq(const bool isthinClient) {
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
 
   try {
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     serializationRegistry->addType(Position::createDeserializable);
@@ -231,7 +230,6 @@ class MyCqStatusListener : public CqStatusListener {
     m_cqsConnectedCount = 0;
   }
 };
-typedef std::shared_ptr<MyCqStatusListener> MyCqStatusListenerPtr;
 
 DUNIT_TASK_DEFINITION(LOCATORSERVER, CreateLocator)
   {
@@ -301,11 +299,11 @@ END_TASK_DEFINITION
 void stepOne() {
   initClientCq(true);
   createRegionForCQ(regionNamesCq[0], USE_ACK, true);
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+ auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+ std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+ auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
-  LOG("StepOne complete.");
+ LOG("StepOne complete.");
 }
 
 void initCqStatusClient() {
@@ -350,11 +348,11 @@ END_TASK_DEFINITION
 void stepOne2() {
   initClientCq(true);
   createRegionForCQ(regionNamesCq[0], USE_ACK, true);
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+ auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+ std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+ auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
-  LOG("StepOne2 complete.");
+ LOG("StepOne2 complete.");
 }
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepOne2_PoolLocator)
@@ -363,17 +361,17 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepTwo)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+   auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
-    QueryHelper* qh = &QueryHelper::getHelper();
+   QueryHelper* qh = &QueryHelper::getHelper();
 
-    if (!m_isPdx) {
-      qh->populatePortfolioData(regPtr0, 2, 1, 1);
-      qh->populatePositionData(subregPtr0, 2, 1);
-    } else {
-      qh->populatePortfolioPdxData(regPtr0, 2, 1, 1);
-      qh->populatePositionPdxData(subregPtr0, 2, 1);
+   if (!m_isPdx) {
+     qh->populatePortfolioData(regPtr0, 2, 1, 1);
+     qh->populatePositionData(subregPtr0, 2, 1);
+   } else {
+     qh->populatePortfolioPdxData(regPtr0, 2, 1, 1);
+     qh->populatePositionPdxData(subregPtr0, 2, 1);
     }
 
     LOG("StepTwo complete.");
@@ -385,9 +383,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     uint8_t i = 0;
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
       qs = pool->getQueryService();
@@ -398,8 +396,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     for (i = 0; i < MAX_LISTNER; i++) {
       auto cqLstner = std::make_shared<MyCqListener>(i);
       cqFac.addCqListener(cqLstner);
-      CqAttributesPtr cqAttr = cqFac.create();
-      CqQueryPtr qry = qs->newCq(cqNames[i], queryStrings[i], cqAttr);
+     auto cqAttr = cqFac.create();
+     auto qry = qs->newCq(cqNames[i], queryStrings[i], cqAttr);
     }
 
     try {
@@ -420,28 +418,28 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     {
       try {
         LOG("Testing bug #1026");
-        RegionPtr regionPtr = getHelper()->getRegion(regionNamesCq[0]);
-        regionPtr->put("1026_Key1", "asdas");
-        regionPtr->put("1026_Key2",
-                       "Schüler");  // string with extended charater set
-        regionPtr->put("1026_Key3",
-                       "Gebäude");  // string with extended charater set
-        regionPtr->put("1026_Key4",
-                       "Königin");  // string with extended charater set
-
-        const char* qryStr = "select * from /Portfolios p where p='Schüler'";
-
-        CqListenerPtr cqLstner(new MyCqListener1026);
-        cqFac.addCqListener(cqLstner);
-        CqAttributesPtr cqAttr = cqFac.create();
-        CqQueryPtr qry = qs->newCq((char*)"1026_MyCq", qryStr, cqAttr);
-
-        // execute Cq Query with initial Results
-        CqResultsPtr resultsPtr = qry->executeWithInitialResults();
-
-        LOGINFO("ResultSet Query returned %d rows", resultsPtr->size());
-        LOG("Testing bug #1026 Complete");
-        // Iterate through the rows of the query result.
+       auto regionPtr = getHelper()->getRegion(regionNamesCq[0]);
+       regionPtr->put("1026_Key1", "asdas");
+       regionPtr->put("1026_Key2",
+                      "Schüler");  // string with extended charater set
+       regionPtr->put("1026_Key3",
+                      "Gebäude");  // string with extended charater set
+       regionPtr->put("1026_Key4",
+                      "Königin");  // string with extended charater set
+
+       const char* qryStr = "select * from /Portfolios p where p='Schüler'";
+
+       std::shared_ptr<CqListener> cqLstner(new MyCqListener1026);
+       cqFac.addCqListener(cqLstner);
+       auto cqAttr = cqFac.create();
+       auto qry = qs->newCq((char*)"1026_MyCq", qryStr, cqAttr);
+
+       // execute Cq Query with initial Results
+       auto resultsPtr = qry->executeWithInitialResults();
+
+       LOGINFO("ResultSet Query returned %d rows", resultsPtr->size());
+       LOG("Testing bug #1026 Complete");
+       // Iterate through the rows of the query result.
       } catch (const Exception& geodeExcp) {
         LOGERROR("CqQuery Geode Exception: %s", geodeExcp.getMessage());
         FAIL(geodeExcp.getMessage());
@@ -453,34 +451,34 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, StepTwo2)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+   auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
-    QueryHelper* qh = &QueryHelper::getHelper();
+   QueryHelper* qh = &QueryHelper::getHelper();
+
+   if (!m_isPdx) {
+     qh->populatePortfolioData(regPtr0, 3, 2, 1);
+     qh->populatePositionData(subregPtr0, 3, 2);
+   } else {
+     qh->populatePortfolioPdxData(regPtr0, 3, 2, 1);
+     qh->populatePositionPdxData(subregPtr0, 3, 2);
+    }
 
+  std::shared_ptr<Cacheable> port = nullptr;
+  for (int i = 1; i < 3; i++) {
     if (!m_isPdx) {
-      qh->populatePortfolioData(regPtr0, 3, 2, 1);
-      qh->populatePositionData(subregPtr0, 3, 2);
+      port = std::shared_ptr<Cacheable>(new Portfolio(i, 2));
     } else {
-      qh->populatePortfolioPdxData(regPtr0, 3, 2, 1);
-      qh->populatePositionPdxData(subregPtr0, 3, 2);
+      port = std::shared_ptr<Cacheable>(new PortfolioPdx(i, 2));
     }
 
-    CacheablePtr port = nullptr;
-    for (int i = 1; i < 3; i++) {
-      if (!m_isPdx) {
-        port = CacheablePtr(new Portfolio(i, 2));
-      } else {
-        port = CacheablePtr(new PortfolioPdx(i, 2));
-      }
-
-      CacheableKeyPtr keyport = CacheableKey::create("port1-1");
-      regPtr0->put(keyport, port);
-      SLEEP(10);  // sleep a while to allow server query to complete
-    }
+    auto keyport = CacheableKey::create("port1-1");
+    regPtr0->put(keyport, port);
+    SLEEP(10);  // sleep a while to allow server query to complete
+  }
 
-    LOG("StepTwo2 complete. Sleeping .25 min for server query to complete...");
-    SLEEP(15000);  // sleep .25 min to allow server query to complete
+  LOG("StepTwo2 complete. Sleeping .25 min for server query to complete...");
+  SLEEP(15000);  // sleep .25 min to allow server query to complete
   }
 END_TASK_DEFINITION
 
@@ -488,9 +486,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
   {
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
       qs = pool->getQueryService();
@@ -517,83 +515,83 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
     for (i = 0; i < MAX_LISTNER; i++) {
       sprintf(buf, "get info for cq[%s]:", cqNames[i]);
       LOG(buf);
-      CqQueryPtr cqy = qs->getCq(cqNames[i]);
-      CqStatisticsPtr cqStats = cqy->getStatistics();
-      sprintf(buf,
-              "Cq[%s]From CqStatistics: numInserts[%d], numDeletes[%d], "
-              "numUpdates[%d], numEvents[%d]",
-              cqNames[i], cqStats->numInserts(), cqStats->numDeletes(),
-              cqStats->numUpdates(), cqStats->numEvents());
-      LOG(buf);
-      for (j = 0; j <= i; j++) {
-        inserts[j] += cqStats->numInserts();
-        updates[j] += cqStats->numUpdates();
-        deletes[j] += cqStats->numDeletes();
-        events[j] += cqStats->numEvents();
-      }
-      CqAttributesPtr cqAttr = cqy->getCqAttributes();
-      auto vl = cqAttr->getCqListeners();
-      sprintf(buf, "number of listeners for cq[%s] is %zd", cqNames[i],
-              vl.size());
-      LOG(buf);
-      ASSERT(vl.size() == i + 1, "incorrect number of listeners");
-      if (i == (MAX_LISTNER - 1)) {
-        MyCqListener* myLl[MAX_LISTNER];
-        for (int k = 0; k < MAX_LISTNER; k++) {
-          MyCqListener* ml = dynamic_cast<MyCqListener*>(vl[k].get());
-          myLl[ml->getId()] = ml;
-        }
-        for (j = 0; j < MAX_LISTNER; j++) {
-          MyCqListener* ml = myLl[j];
-          sprintf(buf,
-                  "MyCount for Listener[%d]: numInserts[%d], numDeletes[%d], "
-                  "numUpdates[%d], numEvents[%d]",
-                  j, ml->getNumInserts(), ml->getNumDeletes(),
-                  ml->getNumUpdates(), ml->getNumEvents());
-          LOG(buf);
-          sprintf(buf,
-                  "sum of stats for Listener[%d]: numInserts[%d], "
-                  "numDeletes[%d], numUpdates[%d], numEvents[%d]",
-                  j, inserts[j], deletes[j], updates[j], events[j]);
-          LOG(buf);
-          ASSERT(ml->getNumInserts() == inserts[j],
-                 "accumulative insert count incorrect");
-          ASSERT(ml->getNumUpdates() == updates[j],
-                 "accumulative updates count incorrect");
-          ASSERT(ml->getNumDeletes() == deletes[j],
-                 "accumulative deletes count incorrect");
-          ASSERT(ml->getNumEvents() == events[j],
-                 "accumulative events count incorrect");
-        }
-        LOG("removing listener");
-        CqAttributesMutatorPtr cqAttrMtor = cqy->getCqAttributesMutator();
-        CqListenerPtr ptr = vl[0];
-        cqAttrMtor->removeCqListener(ptr);
-        vl = cqAttr->getCqListeners();
-        sprintf(buf, "number of listeners for cq[%s] is %zd", cqNames[i],
-                vl.size());
-        LOG(buf);
-        ASSERT(vl.size() == i, "incorrect number of listeners");
-      }
+     auto cqy = qs->getCq(cqNames[i]);
+     auto cqStats = cqy->getStatistics();
+     sprintf(buf,
+             "Cq[%s]From CqStatistics: numInserts[%d], numDeletes[%d], "
+             "numUpdates[%d], numEvents[%d]",
+             cqNames[i], cqStats->numInserts(), cqStats->numDeletes(),
+             cqStats->numUpdates(), cqStats->numEvents());
+     LOG(buf);
+     for (j = 0; j <= i; j++) {
+       inserts[j] += cqStats->numInserts();
+       updates[j] += cqStats->numUpdates();
+       deletes[j] += cqStats->numDeletes();
+       events[j] += cqStats->numEvents();
+     }
+     auto cqAttr = cqy->getCqAttributes();
+     auto vl = cqAttr->getCqListeners();
+     sprintf(buf, "number of listeners for cq[%s] is %zd", cqNames[i],
+             vl.size());
+     LOG(buf);
+     ASSERT(vl.size() == i + 1, "incorrect number of listeners");
+     if (i == (MAX_LISTNER - 1)) {
+       MyCqListener* myLl[MAX_LISTNER];
+       for (int k = 0; k < MAX_LISTNER; k++) {
+         MyCqListener* ml = dynamic_cast<MyCqListener*>(vl[k].get());
+         myLl[ml->getId()] = ml;
+       }
+       for (j = 0; j < MAX_LISTNER; j++) {
+         MyCqListener* ml = myLl[j];
+         sprintf(buf,
+                 "MyCount for Listener[%d]: numInserts[%d], numDeletes[%d], "
+                 "numUpdates[%d], numEvents[%d]",
+                 j, ml->getNumInserts(), ml->getNumDeletes(),
+                 ml->getNumUpdates(), ml->getNumEvents());
+         LOG(buf);
+         sprintf(buf,
+                 "sum of stats for Listener[%d]: numInserts[%d], "
+                 "numDeletes[%d], numUpdates[%d], numEvents[%d]",
+                 j, inserts[j], deletes[j], updates[j], events[j]);
+         LOG(buf);
+         ASSERT(ml->getNumInserts() == inserts[j],
+                "accumulative insert count incorrect");
+         ASSERT(ml->getNumUpdates() == updates[j],
+                "accumulative updates count incorrect");
+         ASSERT(ml->getNumDeletes() == deletes[j],
+                "accumulative deletes count incorrect");
+         ASSERT(ml->getNumEvents() == events[j],
+                "accumulative events count incorrect");
+       }
+       LOG("removing listener");
+       auto cqAttrMtor = cqy->getCqAttributesMutator();
+       auto ptr = vl[0];
+       cqAttrMtor->removeCqListener(ptr);
+       vl = cqAttr->getCqListeners();
+       sprintf(buf, "number of listeners for cq[%s] is %zd", cqNames[i],
+               vl.size());
+       LOG(buf);
+       ASSERT(vl.size() == i, "incorrect number of listeners");
+     }
     }
     try {
-      CqQueryPtr cqy = qs->getCq(cqNames[1]);
-      cqy->stop();
-
-      cqy = qs->getCq(cqNames[6]);
-
-      sprintf(buf, "cq[%s] should have been running!", cqNames[6]);
-      ASSERT(cqy->isRunning() == true, buf);
-      bool got_exception = false;
-      try {
-        cqy->execute();
-      } catch (IllegalStateException& excp) {
-        std::string failmsg = "";
-        failmsg += excp.getName();
-        failmsg += ": ";
-        failmsg += excp.getMessage();
-        LOG(failmsg.c_str());
-        got_exception = true;
+     auto cqy = qs->getCq(cqNames[1]);
+     cqy->stop();
+
+     cqy = qs->getCq(cqNames[6]);
+
+     sprintf(buf, "cq[%s] should have been running!", cqNames[6]);
+     ASSERT(cqy->isRunning() == true, buf);
+     bool got_exception = false;
+     try {
+       cqy->execute();
+     } catch (IllegalStateException& excp) {
+       std::string failmsg = "";
+       failmsg += excp.getName();
+       failmsg += ": ";
+       failmsg += excp.getMessage();
+       LOG(failmsg.c_str());
+       got_exception = true;
       }
       sprintf(buf, "cq[%s] should gotten exception!", cqNames[6]);
       ASSERT(got_exception == true, buf);
@@ -621,43 +619,43 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
       FAIL(failmsg.c_str());
       excp.printStackTrace();
     }
-    CqServiceStatisticsPtr serviceStats = qs->getCqServiceStatistics();
-    ASSERT(serviceStats != nullptr, "serviceStats is nullptr");
-    sprintf(buf,
-            "numCqsActive=%d, numCqsCreated=%d, "
-            "numCqsClosed=%d,numCqsStopped=%d, numCqsOnClient=%d",
-            serviceStats->numCqsActive(), serviceStats->numCqsCreated(),
-            serviceStats->numCqsClosed(), serviceStats->numCqsStopped(),
-            serviceStats->numCqsOnClient());
+   auto serviceStats = qs->getCqServiceStatistics();
+   ASSERT(serviceStats != nullptr, "serviceStats is nullptr");
+   sprintf(buf,
+           "numCqsActive=%d, numCqsCreated=%d, "
+           "numCqsClosed=%d,numCqsStopped=%d, numCqsOnClient=%d",
+           serviceStats->numCqsActive(), serviceStats->numCqsCreated(),
+           serviceStats->numCqsClosed(), serviceStats->numCqsStopped(),
+           serviceStats->numCqsOnClient());
+   LOG(buf);
+   /*
+   for(i=0; i < MAX_LISTNER; i++)
+   {
+   auto cqy = qs->getCq(cqNames[i]);
+    CqState::StateType state = cqy->getState();
+    CqState cqState;
+    cqState.setState(state);
+    sprintf(buf, "cq[%s] is in state[%s]", cqNames[i], cqState.toString());
     LOG(buf);
-    /*
-    for(i=0; i < MAX_LISTNER; i++)
-    {
-     CqQueryPtr cqy = qs->getCq(cqNames[i]);
-     CqState::StateType state = cqy->getState();
-     CqState cqState;
-     cqState.setState(state);
-     sprintf(buf, "cq[%s] is in state[%s]", cqNames[i], cqState.toString());
-     LOG(buf);
-    }
-    */
-
-    ASSERT(serviceStats->numCqsActive() == 6, "active count incorrect!");
-    ASSERT(serviceStats->numCqsCreated() == 9, "created count incorrect!");
-    ASSERT(serviceStats->numCqsClosed() == 1, "closed count incorrect!");
-    ASSERT(serviceStats->numCqsStopped() == 2, "stopped count incorrect!");
-    ASSERT(serviceStats->numCqsOnClient() == 8, "cq count incorrect!");
-
-    try {
-      qs->stopCqs();
-    } catch (Exception& excp) {
-      std::string failmsg = "";
-      failmsg += excp.getName();
-      failmsg += ": ";
-      failmsg += excp.getMessage();
-      LOG(failmsg.c_str());
-      FAIL(failmsg.c_str());
-      excp.printStackTrace();
+   }
+   */
+
+   ASSERT(serviceStats->numCqsActive() == 6, "active count incorrect!");
+   ASSERT(serviceStats->numCqsCreated() == 9, "created count incorrect!");
+   ASSERT(serviceStats->numCqsClosed() == 1, "closed count incorrect!");
+   ASSERT(serviceStats->numCqsStopped() == 2, "stopped count incorrect!");
+   ASSERT(serviceStats->numCqsOnClient() == 8, "cq count incorrect!");
+
+   try {
+     qs->stopCqs();
+   } catch (Exception& excp) {
+     std::string failmsg = "";
+     failmsg += excp.getName();
+     failmsg += ": ";
+     failmsg += excp.getMessage();
+     LOG(failmsg.c_str());
+     FAIL(failmsg.c_str());
+     excp.printStackTrace();
     }
     sprintf(buf,
             "numCqsActive=%d, numCqsCreated=%d, "
@@ -698,20 +696,20 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
     i = 0;
     auto cqLstner = std::make_shared<MyCqListener>(i);
     cqFac.addCqListener(cqLstner);
-    CqAttributesPtr cqAttr = cqFac.create();
-    try {
-      CqQueryPtr qry = qs->newCq(cqNames[i], queryStrings[i], cqAttr);
-      qry->execute();
-      qry->stop();
-      qry->close();
-    } catch (Exception& excp) {
-      std::string failmsg = "";
-      failmsg += excp.getName();
-      failmsg += ": ";
-      failmsg += excp.getMessage();
-      LOG(failmsg.c_str());
-      FAIL(failmsg.c_str());
-      excp.printStackTrace();
+   auto cqAttr = cqFac.create();
+   try {
+     auto qry = qs->newCq(cqNames[i], queryStrings[i], cqAttr);
+     qry->execute();
+     qry->stop();
+     qry->close();
+   } catch (Exception& excp) {
+     std::string failmsg = "";
+     failmsg += excp.getName();
+     failmsg += ": ";
+     failmsg += excp.getMessage();
+     LOG(failmsg.c_str());
+     FAIL(failmsg.c_str());
+     excp.printStackTrace();
     }
 
     LOG("StepFour complete.");
@@ -798,41 +796,39 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ)
   {
     SLEEP(10000);
     // Create CqAttributes and Install Listener
-    PoolPtr pool = getHelper()->getCache()->getPoolManager().find(regionName);
-    QueryServicePtr qs = pool->getQueryService();
-    CqAttributesFactory cqFac;
-    auto cqLstner = std::make_shared<MyCqStatusListener>(100);
-    cqFac.addCqListener(cqLstner);
-    CqAttributesPtr cqAttr = cqFac.create();
-    CqQueryPtr cq =
-        qs->newCq(const_cast<char*>(cqName), cqQueryStatusString, cqAttr);
-
-    cq->execute();
-    SLEEP(20000);
-
-    cqAttr = cq->getCqAttributes();
-    auto vl = cqAttr->getCqListeners();
-    MyCqStatusListener* myStatusCq =
-        dynamic_cast<MyCqStatusListener*>(vl[0].get());
-    LOGINFO("checkCQStatusOnConnect = %d ", myStatusCq->getCqsConnectedCount());
-    ASSERT(myStatusCq->getCqsConnectedCount() == 1,
-           "incorrect number of CqStatus Connected count.");
-    LOG("createCQ complete.");
+   auto pool = getHelper()->getCache()->getPoolManager().find(regionName);
+   auto qs = pool->getQueryService();
+   CqAttributesFactory cqFac;
+   auto cqLstner = std::make_shared<MyCqStatusListener>(100);
+   cqFac.addCqListener(cqLstner);
+   auto cqAttr = cqFac.create();
+   auto cq = qs->newCq(const_cast<char*>(cqName), cqQueryStatusString, cqAttr);
+
+   cq->execute();
+   SLEEP(20000);
+
+   cqAttr = cq->getCqAttributes();
+   auto vl = cqAttr->getCqListeners();
+   MyCqStatusListener* myStatusCq =
+       dynamic_cast<MyCqStatusListener*>(vl[0].get());
+   LOGINFO("checkCQStatusOnConnect = %d ", myStatusCq->getCqsConnectedCount());
+   ASSERT(myStatusCq->getCqsConnectedCount() == 1,
+          "incorrect number of CqStatus Connected count.");
+   LOG("createCQ complete.");
   }
 END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find("__TEST_POOL1__");
-    QueryServicePtr qs = pool->getQueryService();
+    auto qs = pool->getQueryService();
     CqAttributesFactory cqFac;
     auto cqLstner = std::make_shared<MyCqStatusListener>(100);
     cqFac.addCqListener(cqLstner);
-    CqAttributesPtr cqAttr = cqFac.create();
+    auto cqAttr = cqFac.create();
 
-    CqQueryPtr cq =
-        qs->newCq(const_cast<char*>(cqName), cqQueryStatusString, cqAttr);
+    auto cq = qs->newCq(const_cast<char*>(cqName), cqQueryStatusString, cqAttr);
     cq->execute();
     SLEEP(20000);
 
@@ -844,14 +840,14 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
     ASSERT(myStatusCq->getCqsConnectedCount() == 1,
            "incorrect number of CqStatus Connected count.");
 
-    PoolPtr pool2 =
+    auto pool2 =
         getHelper()->getCache()->getPoolManager().find("__TEST_POOL2__");
-    QueryServicePtr qs2 = pool2->getQueryService();
+    auto qs2 = pool2->getQueryService();
     CqAttributesFactory cqFac1;
     auto cqLstner1 = std::make_shared<MyCqStatusListener>(101);
     cqFac1.addCqListener(cqLstner1);
-    CqAttributesPtr cqAttr1 = cqFac1.create();
-    CqQueryPtr cq2 =
+    auto cqAttr1 = cqFac1.create();
+    auto cq2 =
         qs2->newCq(const_cast<char*>(cqName1), cqQueryStatusString1, cqAttr1);
     cq2->execute();
     SLEEP(20000);
@@ -865,16 +861,16 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
     ASSERT(myStatusCq2->getCqsConnectedCount() == 1,
            "incorrect number of CqStatus Connected count.");
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionName);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionName1);
-    CacheablePtr val = nullptr;
+    auto regPtr0 = getHelper()->getRegion(regionName);
+    auto regPtr1 = getHelper()->getRegion(regionName1);
+    std::shared_ptr<Cacheable> val = nullptr;
     char KeyStr[256] = {0};
     char valStr[256] = {0};
     for (int i = 1; i <= 5; i++) {
       ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
       ACE_OS::snprintf(valStr, 256, "val-%d ", i);
-      CacheableKeyPtr keyport = CacheableKey::create(KeyStr);
-      CacheablePtr valport = CacheableString::create(valStr);
+      auto keyport = CacheableKey::create(KeyStr);
+      auto valport = CacheableString::create(valStr);
       regPtr0->put(keyport, valport);
       regPtr1->put(keyport, valport);
       SLEEP(10 * 1000);  // sleep a while to allow server query to complete
@@ -894,12 +890,12 @@ DUNIT_TASK_DEFINITION(CLIENT1, createCQ_Pool)
 END_TASK_DEFINITION
 
 void executeCq(const char* poolName, const char* name) {
-  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
-  QueryServicePtr qs;
-  if (pool != nullptr) {
-    qs = pool->getQueryService();
+ auto pool = getHelper()->getCache()->getPoolManager().find(poolName);
+ std::shared_ptr<QueryService> qs;
+ if (pool != nullptr) {
+   qs = pool->getQueryService();
   }
-  CqQueryPtr cq = qs->getCq(const_cast<char*>(name));
+  auto cq = qs->getCq(const_cast<char*>(name));
   cq->execute();
   SLEEP(20000);
   LOG("executeCq complete");
@@ -914,13 +910,13 @@ END_TASK_DEFINITION
 
 void checkCQStatusOnConnect(const char* poolName, const char* name,
                             int connect) {
-  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
-  QueryServicePtr qs;
-  if (pool != nullptr) {
-    qs = pool->getQueryService();
+ auto pool = getHelper()->getCache()->getPoolManager().find(poolName);
+ std::shared_ptr<QueryService> qs;
+ if (pool != nullptr) {
+   qs = pool->getQueryService();
   }
-  CqQueryPtr cq = qs->getCq(const_cast<char*>(name));
-  CqAttributesPtr cqAttr = cq->getCqAttributes();
+  auto cq = qs->getCq(const_cast<char*>(name));
+  auto cqAttr = cq->getCqAttributes();
   auto vl = cqAttr->getCqListeners();
   MyCqStatusListener* myStatusCq =
       dynamic_cast<MyCqStatusListener*>(vl[0].get());
@@ -957,13 +953,13 @@ END_TASK_DEFINITION
 
 void checkCQStatusOnDisConnect(const char* poolName, const char* cqName,
                                int disconnect) {
-  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
-  QueryServicePtr qs;
-  if (pool != nullptr) {
-    qs = pool->getQueryService();
+ auto pool = getHelper()->getCache()->getPoolManager().find(poolName);
+ std::shared_ptr<QueryService> qs;
+ if (pool != nullptr) {
+   qs = pool->getQueryService();
   }
-  CqQueryPtr cq = qs->getCq(const_cast<char*>(cqName));
-  CqAttributesPtr cqAttr = cq->getCqAttributes();
+  auto cq = qs->getCq(const_cast<char*>(cqName));
+  auto cqAttr = cq->getCqAttributes();
   auto vl = cqAttr->getCqListeners();
   auto myStatusCq = std::dynamic_pointer_cast<MyCqStatusListener>(vl[0]);
   LOGINFO("checkCQStatusOnDisConnect = %d ",
@@ -1007,33 +1003,33 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, putEntries)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionName);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionName1);
-    CacheablePtr val = nullptr;
-    char KeyStr[256] = {0};
-    char valStr[256] = {0};
-    for (int i = 1; i <= 5; i++) {
-      ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
-      ACE_OS::snprintf(valStr, 256, "val-%d ", i);
-      CacheableKeyPtr keyport = CacheableKey::create(KeyStr);
-      CacheablePtr valport = CacheableString::create(valStr);
-      regPtr0->put(keyport, valport);
-      regPtr1->put(keyport, valport);
-      SLEEP(10 * 1000);  // sleep a while to allow server query to complete
-    }
-    LOGINFO("putEntries complete");
+   auto regPtr0 = getHelper()->getRegion(regionName);
+   auto regPtr1 = getHelper()->getRegion(regionName1);
+   std::shared_ptr<Cacheable> val = nullptr;
+   char KeyStr[256] = {0};
+   char valStr[256] = {0};
+   for (int i = 1; i <= 5; i++) {
+     ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
+     ACE_OS::snprintf(valStr, 256, "val-%d ", i);
+     auto keyport = CacheableKey::create(KeyStr);
+     auto valport = CacheableString::create(valStr);
+     regPtr0->put(keyport, valport);
+     regPtr1->put(keyport, valport);
+     SLEEP(10 * 1000);  // sleep a while to allow server query to complete
+   }
+   LOGINFO("putEntries complete");
   }
 END_TASK_DEFINITION
 
 void checkCQStatusOnPutEvent(const char* poolName, const char* cqName,
                              int count) {
-  PoolPtr pool = getHelper()->getCache()->getPoolManager().find(poolName);
-  QueryServicePtr qs;
-  if (pool != nullptr) {
-    qs = pool->getQueryService();
+ auto pool = getHelper()->getCache()->getPoolManager().find(poolName);
+ std::shared_ptr<QueryService> qs;
+ if (pool != nullptr) {
+   qs = pool->getQueryService();
   }
-  CqQueryPtr cq = qs->getCq(const_cast<char*>(cqName));
-  CqAttributesPtr cqAttr = cq->getCqAttributes();
+  auto cq = qs->getCq(const_cast<char*>(cqName));
+  auto cqAttr = cq->getCqAttributes();
   auto vl = cqAttr->getCqListeners();
   MyCqStatusListener* myStatusCq =
       dynamic_cast<MyCqStatusListener*>(vl[0].get());
@@ -1061,115 +1057,114 @@ DUNIT_TASK_DEFINITION(CLIENT1, ProcessCQ)
   {
     SLEEP(10000);
     // Create CqAttributes and Install Listener
-    PoolPtr pool = getHelper()->getCache()->getPoolManager().find(regionName);
-    QueryServicePtr qs = pool->getQueryService();
-    CqAttributesFactory cqFac;
-    auto cqLstner = std::make_shared<MyCqListener>(1);
-    auto cqStatusLstner = std::make_shared<MyCqStatusListener>(100);
-    cqFac.addCqListener(cqLstner);
-    cqFac.addCqListener(cqStatusLstner);
-    CqAttributesPtr cqAttr = cqFac.create();
-
-    CqQueryPtr cq =
-        qs->newCq(const_cast<char*>(cqName), cqQueryStatusString, cqAttr);
-    cq->execute();
-    SLEEP(20000);
-    LOG("ProcessCQ Query executed.");
-
-    RegionPtr regPtr0 = getHelper()->getRegion(regionName);
-    CacheablePtr val = nullptr;
-    char KeyStr[256] = {0};
-    char valStr[256] = {0};
-    for (int i = 1; i <= 5; i++) {
-      ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
-      ACE_OS::snprintf(valStr, 256, "val-%d ", i);
-      CacheableKeyPtr keyport = CacheableKey::create(KeyStr);
-      CacheablePtr valport = CacheableString::create(valStr);
-      regPtr0->put(keyport, valport);
-      SLEEP(10 * 1000);  // sleep a while to allow server query to complete
-    }
-    LOGINFO("putEntries complete");
-
-    cqAttr = cq->getCqAttributes();
-    auto vl = cqAttr->getCqListeners();
-    ASSERT(vl.size() == 2, "incorrect number of CqListeners count.");
-    MyCqStatusListener* myStatusCq =
-        dynamic_cast<MyCqStatusListener*>(vl[1].get());
-    LOGINFO("No of insert events = %d ", myStatusCq->getNumInserts());
-    LOGINFO("No of OnCqConnected events = %d ",
-            myStatusCq->getCqsConnectedCount());
-    ASSERT(myStatusCq->getNumInserts() == 5,
-           "incorrect number of CqStatus Updates count.");
-    ASSERT(myStatusCq->getCqsConnectedCount() == 1,
-           "incorrect number of CqStatus Connected count.");
-
-    MyCqListener* myCq = dynamic_cast<MyCqListener*>(vl[0].get());
-    LOGINFO("No of insert events = %d ", myCq->getNumInserts());
-    ASSERT(myCq->getNumInserts() == 5,
-           "incorrect number of CqStatus Updates count.");
-
-    CqAttributesMutatorPtr cqAttrMtor = cq->getCqAttributesMutator();
-    CqListenerPtr ptr = vl[0];
-    cqAttrMtor->removeCqListener(ptr);
-    vl = cqAttr->getCqListeners();
-    LOGINFO("number of listeners = %d", vl.size());
-
-    ASSERT(vl.size() == 1, "incorrect number of listeners");
-
-    cqAttrMtor->removeCqListener(vl[0]);
-    LOGINFO("removeCqListener again");
-    vl = cqAttr->getCqListeners();
-    LOGINFO("number of listeners = %d", vl.size());
-
-    ASSERT(vl.size() == 0, "incorrect number of listeners");
-
-    std::vector<CqListenerPtr> v2;
-    v2.push_back(cqStatusLstner);
-    v2.push_back(cqLstner);
-    cqAttrMtor->setCqListeners(v2);
-    LOG("ProcessCQ setCqListeneres done.");
-
-    cqAttr = cq->getCqAttributes();
-    auto vl3 = cqAttr->getCqListeners();
-    ASSERT(vl3.size() == 2, "incorrect number of CqListeners count.");
-
-    auto myStatusCq2 = std::dynamic_pointer_cast<MyCqStatusListener>(vl3[0]);
-    myStatusCq2->clear();
-
-    for (int i = 1; i <= 5; i++) {
-      ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
-      ACE_OS::snprintf(valStr, 256, "val-%d ", i);
-      CacheableKeyPtr keyport = CacheableKey::create(KeyStr);
-      CacheablePtr valport = CacheableString::create(valStr);
-      regPtr0->put(keyport, valport);
-      SLEEP(10 * 1000);  // sleep a while to allow server query to complete
-    }
-    LOGINFO("putEntries complete again");
-
-    std::vector<CqListenerPtr> vl21;
-    vl21.push_back(cqStatusLstner);
-    vl21.push_back(cqLstner);
-    cqFac.initCqListeners(vl21);
-    LOGINFO("initCqListeners complete.");
-
-    cqAttr = cq->getCqAttributes();
-    auto vl2 = cqAttr->getCqListeners();
-    ASSERT(vl2.size() == 2, "incorrect number of CqListeners count.");
-    myStatusCq2 = std::dynamic_pointer_cast<MyCqStatusListener>(vl2[0]);
-    LOGINFO("No of insert events = %d ", myStatusCq2->getNumUpdates());
-    LOGINFO("No of OnCqConnected events = %d ",
-            myStatusCq2->getCqsConnectedCount());
-    ASSERT(myStatusCq2->getNumUpdates() == 5,
-           "incorrect number of CqStatus Updates count.");
-    ASSERT(myStatusCq2->getCqsConnectedCount() == 0,
-           "incorrect number of CqStatus Connected count.");
-
-    auto myCq2 = std::dynamic_pointer_cast<MyCqListener>(vl2[1]);
-    LOGINFO("No of insert events = %d ", myCq2->getNumInserts());
-    ASSERT(myCq2->getNumUpdates() == 5,
-           "incorrect number of CqStatus Updates count.");
-
-    LOG("ProcessCQ complete.");
+   auto pool = getHelper()->getCache()->getPoolManager().find(regionName);
+   auto qs = pool->getQueryService();
+   CqAttributesFactory cqFac;
+   auto cqLstner = std::make_shared<MyCqListener>(1);
+   auto cqStatusLstner = std::make_shared<MyCqStatusListener>(100);
+   cqFac.addCqListener(cqLstner);
+   cqFac.addCqListener(cqStatusLstner);
+   auto cqAttr = cqFac.create();
+
+   auto cq = qs->newCq(const_cast<char*>(cqName), cqQueryStatusString, cqAttr);
+   cq->execute();
+   SLEEP(20000);
+   LOG("ProcessCQ Query executed.");
+
+   auto regPtr0 = getHelper()->getRegion(regionName);
+   std::shared_ptr<Cacheable> val = nullptr;
+   char KeyStr[256] = {0};
+   char valStr[256] = {0};
+   for (int i = 1; i <= 5; i++) {
+     ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
+     ACE_OS::snprintf(valStr, 256, "val-%d ", i);
+     auto keyport = CacheableKey::create(KeyStr);
+     auto valport = CacheableString::create(valStr);
+     regPtr0->put(keyport, valport);
+     SLEEP(10 * 1000);  // sleep a while to allow server query to complete
+   }
+   LOGINFO("putEntries complete");
+
+   cqAttr = cq->getCqAttributes();
+   auto vl = cqAttr->getCqListeners();
+   ASSERT(vl.size() == 2, "incorrect number of CqListeners count.");
+   MyCqStatusListener* myStatusCq =
+       dynamic_cast<MyCqStatusListener*>(vl[1].get());
+   LOGINFO("No of insert events = %d ", myStatusCq->getNumInserts());
+   LOGINFO("No of OnCqConnected events = %d ",
+           myStatusCq->getCqsConnectedCount());
+   ASSERT(myStatusCq->getNumInserts() == 5,
+          "incorrect number of CqStatus Updates count.");
+   ASSERT(myStatusCq->getCqsConnectedCount() == 1,
+          "incorrect number of CqStatus Connected count.");
+
+   MyCqListener* myCq = dynamic_cast<MyCqListener*>(vl[0].get());
+   LOGINFO("No of insert events = %d ", myCq->getNumInserts());
+   ASSERT(myCq->getNumInserts() == 5,
+          "incorrect number of CqStatus Updates count.");
+
+   auto cqAttrMtor = cq->getCqAttributesMutator();
+   auto ptr = vl[0];
+   cqAttrMtor->removeCqListener(ptr);
+   vl = cqAttr->getCqListeners();
+   LOGINFO("number of listeners = %d", vl.size());
+
+   ASSERT(vl.size() == 1, "incorrect number of listeners");
+
+   cqAttrMtor->removeCqListener(vl[0]);
+   LOGINFO("removeCqListener again");
+   vl = cqAttr->getCqListeners();
+   LOGINFO("number of listeners = %d", vl.size());
+
+   ASSERT(vl.size() == 0, "incorrect number of listeners");
+
+   std::vector<std::shared_ptr<CqListener>> v2;
+   v2.push_back(cqStatusLstner);
+   v2.push_back(cqLstner);
+   cqAttrMtor->setCqListeners(v2);
+   LOG("ProcessCQ setCqListeneres done.");
+
+   cqAttr = cq->getCqAttributes();
+   auto vl3 = cqAttr->getCqListeners();
+   ASSERT(vl3.size() == 2, "incorrect number of CqListeners count.");
+
+   auto myStatusCq2 = std::dynamic_pointer_cast<MyCqStatusListener>(vl3[0]);
+   myStatusCq2->clear();
+
+   for (int i = 1; i <= 5; i++) {
+     ACE_OS::snprintf(KeyStr, 256, "Key-%d ", i);
+     ACE_OS::snprintf(valStr, 256, "val-%d ", i);
+     auto keyport = CacheableKey::create(KeyStr);
+     auto valport = CacheableString::create(valStr);
+     regPtr0->put(keyport, valport);
+     SLEEP(10 * 1000);  // sleep a while to allow server query to complete
+   }
+   LOGINFO("putEntries complete again");
+
+   std::vector<std::shared_ptr<CqListener>> vl21;
+   vl21.push_back(cqStatusLstner);
+   vl21.push_back(cqLstner);
+   cqFac.initCqListeners(vl21);
+   LOGINFO("initCqListeners complete.");
+
+   cqAttr = cq->getCqAttributes();
+   auto vl2 = cqAttr->getCqListeners();
+   ASSERT(vl2.size() == 2, "incorrect number of CqListeners count.");
+   myStatusCq2 = std::dynamic_pointer_cast<MyCqStatusListener>(vl2[0]);
+   LOGINFO("No of insert events = %d ", myStatusCq2->getNumUpdates());
+   LOGINFO("No of OnCqConnected events = %d ",
+           myStatusCq2->getCqsConnectedCount());
+   ASSERT(myStatusCq2->getNumUpdates() == 5,
+          "incorrect number of CqStatus Updates count.");
+   ASSERT(myStatusCq2->getCqsConnectedCount() == 0,
+          "incorrect number of CqStatus Connected count.");
+
+   auto myCq2 = std::dynamic_pointer_cast<MyCqListener>(vl2[1]);
+   LOGINFO("No of insert events = %d ", myCq2->getNumInserts());
+   ASSERT(myCq2->getNumUpdates() == 5,
+          "incorrect number of CqStatus Updates count.");
+
+   LOG("ProcessCQ complete.");
   }
 END_TASK_DEFINITION
 
diff --git a/cppcache/integration-test/testThinClientCqDelta.cpp b/cppcache/integration-test/testThinClientCqDelta.cpp
index 40a2f8c3..dcba00d2 100644
--- a/cppcache/integration-test/testThinClientCqDelta.cpp
+++ b/cppcache/integration-test/testThinClientCqDelta.cpp
@@ -53,7 +53,7 @@ class CqDeltaListener : public CqListener {
   CqDeltaListener() : m_deltaCount(0), m_valueCount(0) {}
 
   virtual void onEvent(const CqEvent& aCqEvent) {
-    CacheableBytesPtr deltaValue = aCqEvent.getDeltaValue();
+    auto deltaValue = aCqEvent.getDeltaValue();
     DeltaTestImpl newValue;
     auto input = getHelper()->getCache()->createDataInput(
         deltaValue->value(), deltaValue->length());
@@ -61,8 +61,7 @@ class CqDeltaListener : public CqListener {
     if (newValue.getIntVar() == 5) {
       m_deltaCount++;
     }
-    DeltaTestImplPtr dptr =
-        std::static_pointer_cast<DeltaTestImpl>(aCqEvent.getNewValue());
+    auto dptr = std::static_pointer_cast<DeltaTestImpl>(aCqEvent.getNewValue());
     if (dptr->getIntVar() == 5) {
       m_valueCount++;
     }
@@ -75,8 +74,8 @@ class CqDeltaListener : public CqListener {
   int m_deltaCount;
   int m_valueCount;
 };
-typedef std::shared_ptr<CqDeltaListener> CqDeltaListenerPtr;
-CqDeltaListenerPtr g_CqListener;
+
+std::shared_ptr<CqDeltaListener> g_CqListener;
 
 void initClient(const bool isthinClient) {
   if (cacheHelper == nullptr) {
@@ -104,7 +103,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -116,7 +115,7 @@ void createPooledLRURegion(const char* name, bool ackMode, const char* locators,
                            bool clientNotificationEnabled = false,
                            bool cachingEnable = true) {
   LOG(" createPooledLRURegion entered");
-  RegionPtr regPtr = getHelper()->createPooledRegionDiscOverFlow(
+  auto regPtr = getHelper()->createPooledRegionDiscOverFlow(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled, std::chrono::seconds(0),
       std::chrono::seconds(0), std::chrono::seconds(0), std::chrono::seconds(0),
@@ -130,8 +129,8 @@ void createRegion(const char* name, bool ackMode,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -148,7 +147,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
 
@@ -165,7 +164,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2)
     createPooledRegion(regionNames[0], USE_ACK, locatorsG, "__TESTPOOL1_",
                        true);
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
 
@@ -173,18 +172,17 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2)
     } catch (IllegalStateException&) {
       //  ignore exception caused by type reregistration.
     }
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
 
-    PoolPtr pool =
-        getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
-    QueryServicePtr qs;
+    auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
+    std::shared_ptr<QueryService> qs;
     qs = pool->getQueryService();
     CqAttributesFactory cqFac;
     g_CqListener = std::make_shared<CqDeltaListener>();
-    CqListenerPtr cqListener = g_CqListener;
+    auto cqListener = g_CqListener;
     cqFac.addCqListener(cqListener);
-    CqAttributesPtr cqAttr = cqFac.create();
-    CqQueryPtr qry =
+    auto cqAttr = cqFac.create();
+    auto qry =
         qs->newCq("Cq_with_delta",
                   "select * from /DistRegionAck d where d.intVar > 4", cqAttr);
     qs->executeCqs();
@@ -196,7 +194,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1_NoPools)
     initClientNoPools();
     createRegion(regionNames[0], USE_ACK, true);
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
 
@@ -212,7 +210,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2_NoPools)
     initClientNoPools();
     createRegion(regionNames[0], USE_ACK, true);
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
 
@@ -220,16 +218,16 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2_NoPools)
     } catch (IllegalStateException&) {
       //  ignore exception caused by type reregistration.
     }
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
 
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     qs = getHelper()->getQueryService();
     CqAttributesFactory cqFac;
     g_CqListener = std::make_shared<CqDeltaListener>();
-    CqListenerPtr cqListener = g_CqListener;
+    auto cqListener = g_CqListener;
     cqFac.addCqListener(cqListener);
-    CqAttributesPtr cqAttr = cqFac.create();
-    CqQueryPtr qry =
+    auto cqAttr = cqFac.create();
+    auto qry =
         qs->newCq("Cq_with_delta",
                   "select * from /DistRegionAck d where d.intVar > 4", cqAttr);
     qs->executeCqs();
@@ -238,10 +236,10 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
   {
-    CacheableKeyPtr keyPtr = createKey(keys[0]);
+    auto keyPtr = createKey(keys[0]);
     auto dptr = std::make_shared<DeltaTestImpl>();
-    CacheablePtr valPtr(dptr);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    std::shared_ptr<Cacheable> valPtr(dptr);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->put(keyPtr, valPtr);
     dptr->setIntVar(5);
     dptr->setDelta(true);
diff --git a/cppcache/integration-test/testThinClientCqDurable.cpp b/cppcache/integration-test/testThinClientCqDurable.cpp
index 1b2831d7..7f8d0920 100644
--- a/cppcache/integration-test/testThinClientCqDurable.cpp
+++ b/cppcache/integration-test/testThinClientCqDurable.cpp
@@ -16,7 +16,6 @@
  */
 #include "fw_dunit.hpp"
 #include "ThinClientHelper.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <geode/CqAttributesFactory.hpp>
 #include <geode/CqAttributes.hpp>
 #include <geode/CqListener.hpp>
@@ -61,7 +60,7 @@ const char* durableCQNamesClient2[] = {
 static bool m_isPdx = false;
 
 void initClientWithId(int ClientIdx, bool typeRegistered = false) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   pp->insert("durable-client-id", durableIds[ClientIdx]);
   pp->insert("durable-timeout", std::chrono::seconds(60));
   pp->insert("notify-ack-interval", std::chrono::seconds(1));
@@ -70,7 +69,7 @@ void initClientWithId(int ClientIdx, bool typeRegistered = false) {
 
   if (typeRegistered == false) {
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
       serializationRegistry->addType(Position::createDeserializable);
@@ -90,9 +89,9 @@ class MyCqListener1 : public CqListener {
   void onEvent(const CqEvent& cqe) {
     m_cntEvents++;
     char* opStr = (char*)"Default";
-    CacheableInt32Ptr value(
+    std::shared_ptr<CacheableInt32> value(
         std::dynamic_pointer_cast<CacheableInt32>(cqe.getNewValue()));
-    CacheableInt32Ptr key(
+    std::shared_ptr<CacheableInt32> key(
         std::dynamic_pointer_cast<CacheableInt32>(cqe.getKey()));
     switch (cqe.getQueryOperation()) {
       case CqOperation::OP_TYPE_CREATE: {
@@ -177,9 +176,9 @@ END_TASK_DEFINITION
 void stepOne() {
   initClientWithId(0);
   createRegionForCQ(regionNamesCq[0], USE_ACK, true);
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+  auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+  std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+  auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
   LOG("StepOne complete.");
 }
@@ -340,9 +339,9 @@ END_TASK_DEFINITION
 void stepOne2() {
   initClientWithId(1);
   createRegionForCQ(regionNamesCq[0], USE_ACK, true);
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+  auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+  std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+  auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
   LOG("StepOne2 complete.");
 }
@@ -353,8 +352,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, StepTwo)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
     if (!m_isPdx) {
@@ -373,9 +372,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
@@ -384,12 +383,12 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
     CqAttributesFactory cqFac;
     auto cqLstner = std::make_shared<MyCqListener>();
     cqFac.addCqListener(cqLstner);
-    CqAttributesPtr cqAttr = cqFac.create();
+    auto cqAttr = cqFac.create();
 
     const char* qryStr = "select * from /Portfolios p where p.ID < 3";
-    CqQueryPtr qry = qs->newCq(cqName, qryStr, cqAttr);
+    auto qry = qs->newCq(cqName, qryStr, cqAttr);
 
-    SelectResultsPtr results;
+    std::shared_ptr<SelectResults> results;
     try {
       LOG("EXECUTE 1 START");
 
@@ -415,21 +414,21 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, StepTwo2)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
 
     qh->populatePortfolioData(regPtr0, 140, 30, 20);
     qh->populatePositionData(subregPtr0, 140, 30);
-    CacheablePtr port = nullptr;
+    std::shared_ptr<Cacheable> port = nullptr;
     for (int i = 1; i < 140; i++) {
       if (!m_isPdx) {
-        port = CacheablePtr(new Portfolio(i, 20));
+        port = std::shared_ptr<Cacheable>(new Portfolio(i, 20));
       } else {
-        port = CacheablePtr(new PortfolioPdx(i, 20));
+        port = std::shared_ptr<Cacheable>(new PortfolioPdx(i, 20));
       }
-      CacheableKeyPtr keyport = CacheableKey::create("port1-1");
+      auto keyport = CacheableKey::create("port1-1");
       regPtr0->put(keyport, port);
       SLEEP(10);  // sleep a while to allow server query to complete
     }
@@ -462,7 +461,7 @@ void client1Up() {
   LOG("Client1Up complete.");
   QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-  QueryServicePtr qs;
+  std::shared_ptr<QueryService> qs;
 
   qs = getHelper()
            ->getCache()
@@ -472,10 +471,10 @@ void client1Up() {
   CqAttributesFactory cqFac;
   auto cqLstner = std::make_shared<MyCqListener>();
   cqFac.addCqListener(cqLstner);
-  CqAttributesPtr cqAttr = cqFac.create();
+  auto cqAttr = cqFac.create();
 
   const char* qryStr = "select * from /Portfolios p where p.ID < 3";
-  CqQueryPtr qry = qs->newCq(cqName, qryStr, cqAttr);
+  auto qry = qs->newCq(cqName, qryStr, cqAttr);
 
   try {
     LOG("EXECUTE 1 START");
@@ -531,9 +530,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
   {
     QueryHelper* qh ATTR_UNUSED = &QueryHelper::getHelper();
 
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
@@ -545,7 +544,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
       LOGINFO(
           "CLIENT-1 StepFour: verifying getCq() behaviour for the invalid CQ "
           "Name");
-      CqQueryPtr invalidCqptr = qs->getCq("InValidCQ");
+      auto invalidCqptr = qs->getCq("InValidCQ");
       ASSERT(
           invalidCqptr == nullptr,
           "Cqptr must be nullptr, as it getCq() is invoked on invalid CQ name");
@@ -555,10 +554,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepFour)
          LOGINFO("Testing getCq(InvalidName) :: invalidCqptr is NOT nullptr");
       }*/
 
-      CqQueryPtr cqy = qs->getCq(cqName);
+      auto cqy = qs->getCq(cqName);
       cqy->stop();
       SLEEP(1500);  // sleep 0.025 min to allow server stop query to complete
-      CqStatisticsPtr cqStats = cqy->getStatistics();
+      auto cqStats = cqy->getStatistics();
       sprintf(buf,
               "numInserts[%d], numDeletes[%d], numUpdates[%d], numEvents[%d]",
               cqStats->numInserts(), cqStats->numDeletes(),
@@ -679,16 +678,16 @@ void doThinClientCqDurable() {
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterCqs1)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
     CqAttributesFactory cqFac;
-    CqAttributesPtr cqAttr = cqFac.create();
+    auto cqAttr = cqFac.create();
 
     qs->newCq(durableCQNamesClient1[0],
               "select * from /Portfolios p where p.ID < 3", cqAttr, true)
@@ -707,16 +706,16 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterCqsAfterClientup1)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
     CqAttributesFactory cqFac;
-    CqAttributesPtr cqAttr = cqFac.create();
+    auto cqAttr = cqFac.create();
 
     qs->newCq(durableCQNamesClient1[4],
               "select * from /Portfolios p where p.ID < 3", cqAttr, true)
@@ -735,16 +734,16 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterCqs2)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
     CqAttributesFactory cqFac;
-    CqAttributesPtr cqAttr = cqFac.create();
+    auto cqAttr = cqFac.create();
 
     qs->newCq(durableCQNamesClient2[0],
               "select * from /Portfolios p where p.ID < 3", cqAttr, true)
@@ -763,16 +762,16 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterCqsAfterClientup2)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
     CqAttributesFactory cqFac;
-    CqAttributesPtr cqAttr = cqFac.create();
+    auto cqAttr = cqFac.create();
 
     qs->newCq(durableCQNamesClient2[4],
               "select * from /Portfolios p where p.ID < 3", cqAttr, true)
@@ -791,16 +790,16 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyCqs1)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
 
-    CacheableArrayListPtr durableCqListPtr = qs->getAllDurableCqsFromServer();
+    auto durableCqListPtr = qs->getAllDurableCqsFromServer();
 
     ASSERT(durableCqListPtr != nullptr, "Durable CQ List should not be null");
     ASSERT(durableCqListPtr->size() == 2, "Durable CQ List lenght should be 2");
@@ -815,16 +814,16 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, VerifyCqsAfterClientup1)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
 
-    CacheableArrayListPtr durableCqListPtr = qs->getAllDurableCqsFromServer();
+    auto durableCqListPtr = qs->getAllDurableCqsFromServer();
     ASSERT(durableCqListPtr != nullptr, "Durable CQ List should not be null");
     ASSERT(durableCqListPtr->size() == 4, "Durable CQ List length should be 4");
     ASSERT(
@@ -844,15 +843,15 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, VerifyCqs2)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
-    CacheableArrayListPtr durableCqListPtr = qs->getAllDurableCqsFromServer();
+    auto durableCqListPtr = qs->getAllDurableCqsFromServer();
     ASSERT(durableCqListPtr != nullptr, "Durable CQ List should not be null");
     ASSERT(durableCqListPtr->size() == 4, "Durable CQ List lenght should be 4");
     ASSERT(isDurableCQName(durableCqListPtr->at(0)->toString()->asChar(), 2,
@@ -872,15 +871,15 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, VerifyCqsAfterClientup2)
   {
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
-    CacheableArrayListPtr durableCqListPtr = qs->getAllDurableCqsFromServer();
+    auto durableCqListPtr = qs->getAllDurableCqsFromServer();
     ASSERT(durableCqListPtr != nullptr, "Durable CQ List should not be null");
     ASSERT(durableCqListPtr->size() == 8, "Durable CQ List lenght should be 8");
     ASSERT(
@@ -911,16 +910,15 @@ DUNIT_TASK_DEFINITION(CLIENT2, VerifyCqsAfterClientup2)
 END_TASK_DEFINITION
 
 void verifyEmptyDurableCQList() {
-  PoolPtr pool =
-      getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-  QueryServicePtr qs;
+  auto pool = getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
+  std::shared_ptr<QueryService> qs;
   if (pool != nullptr) {
     qs = pool->getQueryService();
   } else {
     qs = getHelper()->cachePtr->getQueryService();
   }
 
-  CacheableArrayListPtr durableCqListPtr = qs->getAllDurableCqsFromServer();
+  auto durableCqListPtr = qs->getAllDurableCqsFromServer();
   ASSERT(durableCqListPtr == nullptr, "Durable CQ List should be null");
 }
 
diff --git a/cppcache/integration-test/testThinClientCqFailover.cpp b/cppcache/integration-test/testThinClientCqFailover.cpp
index b0019855..7faaac9c 100644
--- a/cppcache/integration-test/testThinClientCqFailover.cpp
+++ b/cppcache/integration-test/testThinClientCqFailover.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <geode/CqAttributesFactory.hpp>
 #include <geode/CqAttributes.hpp>
 #include <geode/CqListener.hpp>
@@ -118,7 +117,7 @@ void initClientCq(const bool isthinClient) {
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
 
   try {
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     serializationRegistry->addType(Position::createDeserializable);
@@ -156,9 +155,9 @@ void stepOne() {
 
   createRegionForCQ(regionNamesCq[0], USE_ACK, true);
 
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+  auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+  std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+  auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
   QueryHelper* qh = &QueryHelper::getHelper();
 
@@ -175,9 +174,9 @@ END_TASK_DEFINITION
 void stepOne2() {
   initClientCq(true);
   createRegionForCQ(regionNamesCq[0], USE_ACK, true);
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+  auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+  std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+  auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
   LOG("StepOne2 complete.");
 }
@@ -203,9 +202,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     try {
-      PoolPtr pool =
+      auto pool =
           getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-      QueryServicePtr qs;
+      std::shared_ptr<QueryService> qs;
       if (pool != nullptr) {
         // Using region name as pool name as in ThinClientCq.hpp
         qs = pool->getQueryService();
@@ -215,10 +214,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
       CqAttributesFactory cqFac;
       auto cqLstner = std::make_shared<MyCqListener>();
       cqFac.addCqListener(cqLstner);
-      CqAttributesPtr cqAttr = cqFac.create();
+      auto cqAttr = cqFac.create();
 
       char* qryStr = (char*)"select * from /Portfolios p where p.ID != 2";
-      CqQueryPtr qry = qs->newCq(cqName, qryStr, cqAttr);
+      auto qry = qs->newCq(cqName, qryStr, cqAttr);
       qry->execute();
 
       SLEEP(15000);
@@ -244,8 +243,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepThree2)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
 
@@ -254,7 +253,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepThree2)
     for (int i = 1; i < 150; i++) {
       auto port = std::make_shared<Portfolio>(i, 150);
 
-      CacheableKeyPtr keyport = CacheableKey::create((char*)"port1-1");
+      auto keyport = CacheableKey::create((char*)"port1-1");
       regPtr0->put(keyport, port);
       SLEEP(100);  // sleep a while to allow server query to complete
     }
@@ -268,7 +267,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
   {
     auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
       qs = pool->getQueryService();
@@ -279,7 +278,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
     ASSERT(qry != nullptr, "failed to get CqQuery");
     auto cqAttr = qry->getCqAttributes();
     ASSERT(cqAttr != nullptr, "failed to get CqAttributes");
-    CqListenerPtr cqLstner = nullptr;
+    std::shared_ptr<CqListener> cqLstner = nullptr;
     try {
       auto vl = cqAttr->getCqListeners();
       cqLstner = vl[0];
@@ -306,13 +305,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
     kst->stop();
     myListener->setFailedOver();
     /*
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+   auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
     for(int i=1; i < 1500; i++)
     {
         auto port = std::make_shared<Portfolio>(i, 15);
 
-        CacheableKeyPtr keyport = CacheableKey::create("port1-1");
+       auto keyport = CacheableKey::create("port1-1");
         try {
           regPtr0->put(keyport, port);
         } catch (...)
@@ -355,7 +354,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
   {
     auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       // Using region name as pool name as in ThinClientCq.hpp
       qs = pool->getQueryService();
@@ -366,7 +365,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
     ASSERT(qry != nullptr, "failed to get CqQuery");
     auto cqAttr = qry->getCqAttributes();
     ASSERT(cqAttr != nullptr, "failed to get CqAttributes");
-    CqListenerPtr cqLstner = nullptr;
+    std::shared_ptr<CqListener> cqLstner = nullptr;
     try {
       auto vl = cqAttr->getCqListeners();
       cqLstner = vl[0];
diff --git a/cppcache/integration-test/testThinClientCqHAFailover.cpp b/cppcache/integration-test/testThinClientCqHAFailover.cpp
index b8c3e127..b520bb9a 100644
--- a/cppcache/integration-test/testThinClientCqHAFailover.cpp
+++ b/cppcache/integration-test/testThinClientCqHAFailover.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <geode/CqAttributesFactory.hpp>
 #include <geode/CqAttributes.hpp>
 #include <geode/CqListener.hpp>
@@ -116,7 +115,7 @@ void initClientCq(int redundancyLevel) {
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
 
   try {
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
 
@@ -168,9 +167,9 @@ void stepOne() {
 
   createRegionForCQ(regionNamesCq[0], USE_ACK, true, 1);
 
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+  auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+  std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+  auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
   QueryHelper* qh = &QueryHelper::getHelper();
 
@@ -187,9 +186,9 @@ END_TASK_DEFINITION
 void stepOne2() {
   initClientCq(1);
   createRegionForCQ(regionNamesCq[0], USE_ACK, true, 1);
-  RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-  RegionAttributesPtr lattribPtr = regptr->getAttributes();
-  RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+  auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+  std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+  auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
   LOG("StepOne2 complete.");
 }
@@ -201,9 +200,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
   {
     try {
-      PoolPtr pool =
+      auto pool =
           getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-      QueryServicePtr qs;
+      std::shared_ptr<QueryService> qs;
       if (pool != nullptr) {
         qs = pool->getQueryService();
       } else {
@@ -212,13 +211,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
       CqAttributesFactory cqFac;
       auto cqLstner = std::make_shared<MyCqListener>();
       cqFac.addCqListener(cqLstner);
-      CqAttributesPtr cqAttr = cqFac.create();
+      auto cqAttr = cqFac.create();
 
       char* qryStr = (char*)"select * from /Portfolios p where p.ID != 1";
       // char* qryStr = (char*)"select * from /Portfolios p where p.ID != 2";
       // char* qryStr = (char*)"select * from /Portfolios p where p.ID < 3";
-      CqQueryPtr qry = qs->newCq(cqName, qryStr, cqAttr);
-      SelectResultsPtr results;
+      auto qry = qs->newCq(cqName, qryStr, cqAttr);
+      std::shared_ptr<SelectResults> results;
       results = qry->executeWithInitialResults();
 
       SelectResultsIterator iter = results->getIterator();
@@ -228,9 +227,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree)
       LOG(buf);
       while (iter.hasNext()) {
         count--;
-        SerializablePtr ser = iter.next();
-        PortfolioPtr portfolio(dynamic_cast<Portfolio*>(ser.get()));
-        PositionPtr position(dynamic_cast<Position*>(ser.get()));
+        auto ser = iter.next();
+        std::shared_ptr<Portfolio> portfolio(
+            dynamic_cast<Portfolio*>(ser.get()));
+        std::shared_ptr<Position> position(dynamic_cast<Position*>(ser.get()));
 
         if (portfolio != nullptr) {
           printf("   query pulled portfolio object ID %d, pkid %s\n",
@@ -277,8 +277,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepThree2)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
 
@@ -287,7 +287,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepThree2)
     for (int i = 1; i < 150; i++) {
       auto port = std::make_shared<Portfolio>(i, 20);
 
-      CacheableKeyPtr keyport = CacheableKey::create((char*)"port1-1");
+      auto keyport = CacheableKey::create((char*)"port1-1");
       regPtr0->put(keyport, port);
       SLEEP(100);  // sleep a while to allow server query to complete
     }
@@ -300,19 +300,19 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
   {
     // using region name as pool name
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
-    CqQueryPtr qry = qs->getCq(cqName);
+    auto qry = qs->getCq(cqName);
     ASSERT(qry != nullptr, "failed to get CqQuery");
-    CqAttributesPtr cqAttr = qry->getCqAttributes();
+    auto cqAttr = qry->getCqAttributes();
     ASSERT(cqAttr != nullptr, "failed to get CqAttributes");
-    CqListenerPtr cqLstner = nullptr;
+    std::shared_ptr<CqListener> cqLstner = nullptr;
     try {
       auto vl = cqAttr->getCqListeners();
       cqLstner = vl[0];
@@ -339,13 +339,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepThree3)
     kst->stop();
     myListener->setFailedOver();
     /*
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+   auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+   auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
     for(int i=1; i < 150; i++)
     {
         auto port = std::make_shared<Portfolio>(i, 20);
 
-        CacheableKeyPtr keyport = CacheableKey::create("port1-1");
+       auto keyport = CacheableKey::create("port1-1");
         try {
           regPtr0->put(keyport, port);
         } catch (...)
@@ -364,8 +364,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepThree4)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
 
@@ -374,7 +374,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepThree4)
     for (int i = 1; i < 150; i++) {
       auto port = std::make_shared<Portfolio>(i, 20);
 
-      CacheableKeyPtr keyport = CacheableKey::create("port1-1");
+      auto keyport = CacheableKey::create("port1-1");
       regPtr0->put(keyport, port);
       SLEEP(100);  // sleep a while to allow server query to complete
     }
@@ -387,19 +387,19 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
   {
     // using region name as pool name
-    PoolPtr pool =
+    auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
       qs = getHelper()->cachePtr->getQueryService();
     }
-    CqQueryPtr qry = qs->getCq(cqName);
+    auto qry = qs->getCq(cqName);
     ASSERT(qry != nullptr, "failed to get CqQuery");
-    CqAttributesPtr cqAttr = qry->getCqAttributes();
+    auto cqAttr = qry->getCqAttributes();
     ASSERT(cqAttr != nullptr, "failed to get CqAttributes");
-    CqListenerPtr cqLstner = nullptr;
+    std::shared_ptr<CqListener> cqLstner = nullptr;
     try {
       auto vl = cqAttr->getCqListeners();
       cqLstner = vl[0];
diff --git a/cppcache/integration-test/testThinClientCqIR.cpp b/cppcache/integration-test/testThinClientCqIR.cpp
index c1dabf88..6f794956 100644
--- a/cppcache/integration-test/testThinClientCqIR.cpp
+++ b/cppcache/integration-test/testThinClientCqIR.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <string>
@@ -55,7 +54,7 @@ void initClientCq(const bool isthinClient) {
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
 
   try {
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     serializationRegistry->addType(Position::createDeserializable);
@@ -97,9 +96,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1Regions)
     initClientCq(true);
     createRegionForCQ(regionNamesCq[0], USE_ACK, true);
     createRegionForCQ(regionNamesCq[2], USE_ACK, true);
-    RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-    RegionAttributesPtr lattribPtr = regptr->getAttributes();
-    RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+    auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+    std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+    auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
     LOG("CreateClient1Regions complete.");
   }
@@ -109,9 +108,9 @@ DUNIT_TASK_DEFINITION(CLIENT2, CreateClient2Regions)
   {
     initClientCq(true);
     createRegionForCQ(regionNamesCq[0], USE_ACK, true);
-    RegionPtr regptr = getHelper()->getRegion(regionNamesCq[0]);
-    RegionAttributesPtr lattribPtr = regptr->getAttributes();
-    RegionPtr subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
+    auto regptr = getHelper()->getRegion(regionNamesCq[0]);
+    std::shared_ptr<RegionAttributes> lattribPtr = regptr->getAttributes();
+    auto subregPtr = regptr->createSubregion(regionNamesCq[1], lattribPtr);
 
     LOG("CreateClient2Regions complete.");
   }
@@ -119,9 +118,9 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, PopulateData)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNamesCq[2]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNamesCq[2]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
 
@@ -134,18 +133,18 @@ DUNIT_TASK_DEFINITION(CLIENT1, PopulateData)
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, PutData)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
-    RegionPtr subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+    auto subregPtr0 = regPtr0->getSubregion(regionNamesCq[1]);
 
     QueryHelper* qh = &QueryHelper::getHelper();
     qh->populatePortfolioPdxData(regPtr0, 150, 40, 150);
     qh->populatePositionPdxData(subregPtr0, 150, 40);
 
-    CacheablePtr port = nullptr;
+    std::shared_ptr<Cacheable> port = nullptr;
     for (int i = 1; i < 150; i++) {
-      port = CacheablePtr(new PortfolioPdx(i, 150));
+      port = std::shared_ptr<Cacheable>(new PortfolioPdx(i, 150));
 
-      CacheableKeyPtr keyport = CacheableKey::create((char*)"port1-1");
+      auto keyport = CacheableKey::create((char*)"port1-1");
       regPtr0->put(keyport, port);
       SLEEP(100);  // sleep a while to allow server query to complete
     }
@@ -162,7 +161,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, QueryData)
     // using region name as pool name
     auto pool =
         getHelper()->getCache()->getPoolManager().find(regionNamesCq[0]);
-    QueryServicePtr qs;
+    std::shared_ptr<QueryService> qs;
     if (pool != nullptr) {
       qs = pool->getQueryService();
     } else {
@@ -294,7 +293,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, CheckRegionDestroy)
   {
     LOG("check region destory");
     try {
-      RegionPtr regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
+      auto regPtr0 = getHelper()->getRegion(regionNamesCq[0]);
       if (regPtr0 == nullptr) {
         LOG("regPtr0==nullptr");
       } else {
diff --git a/cppcache/integration-test/testThinClientDeltaWithNotification.cpp b/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
index 9bb59c97..9ba489f5 100644
--- a/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
+++ b/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
@@ -81,7 +81,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  RegionPtr regPtr =
+  auto regPtr =
       getHelper()->createPooledRegion(name, ackMode, locators, poolname,
                                       cachingEnable, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
@@ -91,7 +91,7 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
 void createPooledExpirationRegion(const char* name, const char* poolname) {
   LOG("createPooledExpirationRegion() entered.");
   // Entry time-to-live = 1 second.
-  RegionPtr regPtr = getHelper()->createPooledRegionDiscOverFlow(
+  auto regPtr = getHelper()->createPooledRegionDiscOverFlow(
       name, true, locatorsG, poolname, true, true, std::chrono::seconds(1),
       std::chrono::seconds(0), std::chrono::seconds(0), std::chrono::seconds(0),
       0, nullptr, ExpirationAction::LOCAL_INVALIDATE);
@@ -102,7 +102,7 @@ void createPooledLRURegion(const char* name, bool ackMode, const char* locators,
                            bool clientNotificationEnabled = false,
                            bool cachingEnable = true) {
   LOG(" createPooledLRURegion entered");
-  RegionPtr regPtr = getHelper()->createPooledRegionDiscOverFlow(
+  auto regPtr = getHelper()->createPooledRegionDiscOverFlow(
       name, ackMode, locators, poolname, cachingEnable,
       clientNotificationEnabled, std::chrono::seconds(0),
       std::chrono::seconds(0), std::chrono::seconds(0), std::chrono::seconds(0),
@@ -116,8 +116,8 @@ void createRegion(const char* name, bool ackMode,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -125,7 +125,7 @@ void createRegion(const char* name, bool ackMode,
 void createLRURegion(const char* name, bool clientNotificationEnabled = false,
                      bool cachingEnable = true) {
   LOG(" createPooledLRURegion entered");
-  RegionPtr regPtr = getHelper()->createRegionDiscOverFlow(
+  auto regPtr = getHelper()->createRegionDiscOverFlow(
       name, cachingEnable, clientNotificationEnabled, std::chrono::seconds(0),
       std::chrono::seconds(0), std::chrono::seconds(0), std::chrono::seconds(0),
       3 /*LruLimit = 3*/);
@@ -136,7 +136,7 @@ void createExpirationRegion(const char* name,
                             bool clientNotificationEnabled = false,
                             bool cachingEnable = true) {
   LOG(" createPooledLRURegion entered");
-  RegionPtr regPtr = getHelper()->createRegionDiscOverFlow(
+  auto regPtr = getHelper()->createRegionDiscOverFlow(
       name, cachingEnable, clientNotificationEnabled, std::chrono::seconds(1),
       std::chrono::seconds(0), std::chrono::seconds(0), std::chrono::seconds(0),
       0, ExpirationAction::LOCAL_INVALIDATE);
@@ -194,7 +194,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, Client1_Init)
   {
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
 
@@ -208,7 +208,7 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, Client2_Init)
   {
     try {
-      SerializationRegistryPtr serializationRegistry =
+      auto serializationRegistry =
           CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
               ->getSerializationRegistry();
 
@@ -216,9 +216,9 @@ DUNIT_TASK_DEFINITION(CLIENT2, Client2_Init)
     } catch (IllegalStateException&) {
       //  ignore type reregistration exception.
     }
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
-    RegionPtr regPtr2 = getHelper()->getRegion(regionNames[2]);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr2 = getHelper()->getRegion(regionNames[2]);
     regPtr->registerRegex(".*");
     regPtr1->registerRegex(".*");
     regPtr2->registerRegex(".*");
@@ -234,11 +234,11 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
   {
-    CacheableKeyPtr keyPtr = createKey(keys[0]);
+    auto keyPtr = createKey(keys[0]);
     DeltaEx* ptr = new DeltaEx();
     auto pdxobj = std::make_shared<PdxDeltaEx>();
-    CacheablePtr valPtr(ptr);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
+    std::shared_ptr<Cacheable> valPtr(ptr);
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->put(keyPtr, valPtr);
     // Client 2: fromDataCount = 1, fromDeltaCount = 0;
     ptr->setDelta(true);
@@ -246,8 +246,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
     // Client 2: fromDataCount = 1, fromDeltaCount = 1;
 
     DeltaEx* ptr1 = new DeltaEx();
-    CacheablePtr valPtr1(ptr1);
-    CacheableKeyPtr keyPtr1 = createKey(keys[1]);
+    std::shared_ptr<Cacheable> valPtr1(ptr1);
+    auto keyPtr1 = createKey(keys[1]);
     regPtr->put(keyPtr1, valPtr1);
     // Client 2: fromDataCount = 2, fromDeltaCount = 1;
     ptr1->setDelta(true);
@@ -263,11 +263,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
 
     // For LRU with notification and disc overflow.
     LOG("LRU with notification");
-    CacheableKeyPtr keyPtr2 = createKey(keys[2]);
-    CacheableKeyPtr keyPtr3 = createKey(keys[3]);
-    CacheableKeyPtr keyPtr4 = createKey("LRUKEY4");
-    CacheableKeyPtr keyPtr5 = createKey("LRUKEY5");
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto keyPtr2 = createKey(keys[2]);
+    auto keyPtr3 = createKey(keys[3]);
+    auto keyPtr4 = createKey("LRUKEY4");
+    auto keyPtr5 = createKey("LRUKEY5");
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     regPtr1->put(keyPtr2, valPtr1);
     // Client 2: fromDataCount = 4, fromDeltaCount = 2;
@@ -292,9 +292,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
     // oldValue for listeners, fromData()
     // is invoked, hence fromDataCount increases by 2.
 
-    RegionPtr regPtr2 = getHelper()->getRegion(regionNames[2]);
+    auto regPtr2 = getHelper()->getRegion(regionNames[2]);
     DeltaEx* ptr2 = new DeltaEx();
-    CacheablePtr valPtr2(ptr2);
+    std::shared_ptr<Cacheable> valPtr2(ptr2);
     regPtr2->put(1, valPtr2);
     // Client 2: fromDataCount = 12, fromDeltaCount = 3;
     // Sleep for 5 seconds to allow expiration at client 2.
diff --git a/cppcache/integration-test/testThinClientDisconnectionListioner.cpp b/cppcache/integration-test/testThinClientDisconnectionListioner.cpp
index 7e841e16..b7c0dbc8 100644
--- a/cppcache/integration-test/testThinClientDisconnectionListioner.cpp
+++ b/cppcache/integration-test/testThinClientDisconnectionListioner.cpp
@@ -34,7 +34,7 @@ const char* locatorsG =
 using namespace apache::geode::client;
 using namespace test;
 class DisconnectCacheListioner : public CacheListener {
-  void afterRegionDisconnected(const RegionPtr& region) {
+  void afterRegionDisconnected(const std::shared_ptr<Region>& region) {
     LOG("After Region Disconnected event received");
     isDisconnected = true;
   }
@@ -60,9 +60,9 @@ END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, populateServer)
   {
     SLEEP(10000);
-    RegionPtr regPtr = getHelper()->getRegion(regionNames[0]);
-    CacheableKeyPtr keyPtr = createKey("PXR");
-    CacheableStringPtr valPtr = CacheableString::create("PXR1");
+    auto regPtr = getHelper()->getRegion(regionNames[0]);
+    auto keyPtr = createKey("PXR");
+    auto valPtr = CacheableString::create("PXR1");
     regPtr->create(keyPtr, valPtr);
   }
 END_TASK_DEFINITION
diff --git a/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp b/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
index 221d0e32..c1682085 100644
--- a/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
+++ b/cppcache/integration-test/testThinClientExecuteFunctionPrSHOP.cpp
@@ -20,6 +20,7 @@
 #include "fw_dunit.hpp"
 #include "ThinClientHelper.hpp"
 #include "testobject/VariousPdxTypes.hpp"
+#include <geode/FunctionService.hpp>
 #include <geode/DefaultResultCollector.hpp>
 
 using namespace PdxTests;
@@ -54,12 +55,13 @@ class MyResultCollector : public DefaultResultCollector {
       : m_endResultCount(0), m_addResultCount(0), m_getResultCount(0) {}
   ~MyResultCollector() noexcept {}
 
-  CacheableVectorPtr getResult(std::chrono::milliseconds timeout) override {
+  std::shared_ptr<CacheableVector> getResult(
+      std::chrono::milliseconds timeout) override {
     m_getResultCount++;
     return DefaultResultCollector::getResult(timeout);
   }
 
-  void addResult(const CacheablePtr& resultItem) override {
+  void addResult(const std::shared_ptr<Cacheable>& resultItem) override {
     m_addResultCount++;
     if (resultItem == nullptr) {
       return;
@@ -88,7 +90,6 @@ class MyResultCollector : public DefaultResultCollector {
   uint32_t m_addResultCount;
   uint32_t m_getResultCount;
 };
-typedef std::shared_ptr<MyResultCollector> MyResultCollectorPtr;
 
 class MyResultCollector2 : public DefaultResultCollector {
  public:
@@ -96,12 +97,12 @@ class MyResultCollector2 : public DefaultResultCollector {
       : m_endResultCount(0), m_addResultCount(0), m_getResultCount(0) {}
   ~MyResultCollector2() noexcept {}
 
-  CacheableVectorPtr getResult(std::chrono::milliseconds timeout) override {
+  std::shared_ptr<CacheableVector> getResult(std::chrono::milliseconds timeout) override {
     m_getResultCount++;
     return DefaultResultCollector::getResult(timeout);
   }
 
-  void addResult(const CacheablePtr& resultItem) override {
+  void addResult(const std::shared_ptr<Cacheable>& resultItem) override {
     m_addResultCount++;
     DefaultResultCollector::addResult(resultItem);
   }
@@ -120,7 +121,6 @@ class MyResultCollector2 : public DefaultResultCollector {
   uint32_t m_addResultCount;
   uint32_t m_getResultCount;
 };
-typedef std::shared_ptr<MyResultCollector2> MyResultCollectorPtr2;
 
 DUNIT_TASK_DEFINITION(LOCATOR1, StartLocator1)
   {
@@ -152,8 +152,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StartC1)
                        0, true, -1, -1, 60000, /*singlehop*/ true,
                        /*threadLocal*/ true);
 
-    RegionPtr regPtr0 =
-        createRegionAndAttachPool(poolRegNames[0], USE_ACK, nullptr);
+    auto regPtr0 = createRegionAndAttachPool(poolRegNames[0], USE_ACK, nullptr);
     ;
     regPtr0->registerAllKeys();
 
@@ -163,28 +162,28 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(poolRegNames[0]);
+    auto regPtr0 = getHelper()->getRegion(poolRegNames[0]);
     char buf[128];
 
     for (int i = 0; i < 230; i++) {
       sprintf(buf, "VALUE--%d", i);
-      CacheablePtr value(CacheableString::create(buf));
+      std::shared_ptr<Cacheable> value(CacheableString::create(buf));
       regPtr0->put(i, value);
     }
     LOG("Put done.");
     try {
       for (int k = 0; k < 210; k++) {
-        CacheableVectorPtr routingObj = CacheableVector::create();
+        auto routingObj = CacheableVector::create();
         for (int i = k; i < k + 20; i++) {
           routingObj->push_back(CacheableInt32::create(i));
         }
         LOGINFO("routingObj size = %d ", routingObj->size());
-        ExecutionPtr exe = FunctionService::onRegion(regPtr0);
+        auto exe = FunctionService::onRegion(regPtr0);
         ASSERT(exe != nullptr, "onRegion Returned nullptr");
 
-        CacheableVectorPtr resultList = CacheableVector::create();
+        auto resultList = CacheableVector::create();
         LOG("Executing getFuncName function");
-        CacheableVectorPtr executeFunctionResult =
+        auto executeFunctionResult =
             exe->withFilter(routingObj)
                 ->execute(getFuncName, std::chrono::seconds(15))
                 ->getResult();
@@ -261,7 +260,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
         }
         LOGINFO("getFuncName MyResultCollector done");
 
-        CacheableVectorPtr executeFunctionResult2 =
+        auto executeFunctionResult2 =
             exe->withFilter(routingObj)->execute(FEOnRegionPrSHOP)->getResult();
         if (executeFunctionResult2 == nullptr) {
           ASSERT(false, "executeFunctionResult2 is nullptr");
@@ -283,12 +282,11 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
         ///////////////////////// Now same with ResultCollector
         ////////////////////////////
 
-        MyResultCollectorPtr2 myRC2(new MyResultCollector2());
-        CacheableVectorPtr executeFunctionResult21 =
-            exe->withFilter(routingObj)
-                ->withCollector(myRC2)
-                ->execute(FEOnRegionPrSHOP)
-                ->getResult();
+        std::shared_ptr<MyResultCollector2> myRC2(new MyResultCollector2());
+        auto executeFunctionResult21 = exe->withFilter(routingObj)
+                                           ->withCollector(myRC2)
+                                           ->execute(FEOnRegionPrSHOP)
+                                           ->getResult();
         LOGINFO("add result count = %d", myRC2->getAddResultCount());
         LOGINFO("end result count = %d", myRC2->getEndResultCount());
         LOGINFO("get result count = %d", myRC2->getGetResultCount());
@@ -315,7 +313,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
         /////////////////////// Done with ResultCollector
         ////////////////////////////////
 
-        CacheableVectorPtr executeFunctionResult3 =
+        auto executeFunctionResult3 =
             exe->withFilter(routingObj)
                 ->execute(FEOnRegionPrSHOP_OptimizeForWrite)
                 ->getResult();
@@ -338,8 +336,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
 
         ///////////////////////// Now same with ResultCollector
         ////////////////////////////
-        MyResultCollectorPtr2 myRC3(new MyResultCollector2());
-        CacheableVectorPtr executeFunctionResult31 =
+        std::shared_ptr<MyResultCollector2> myRC3(new MyResultCollector2());
+        auto executeFunctionResult31 =
             exe->withFilter(routingObj)
                 ->withCollector(myRC3)
                 ->execute(FEOnRegionPrSHOP_OptimizeForWrite)
@@ -370,13 +368,12 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
             "withFilter");
       }
 
-      ExecutionPtr exc = FunctionService::onRegion(regPtr0);
-      ASSERT(exc != nullptr, "onRegion Returned nullptr");
-      // Now w/o filter, chk for singlehop
-      CacheableVectorPtr executeFunctionResult2 =
-          exc->execute(FEOnRegionPrSHOP)->getResult();
-      if (executeFunctionResult2 == nullptr) {
-        ASSERT(false, "executeFunctionResult2 is nullptr");
+     auto exc = FunctionService::onRegion(regPtr0);
+     ASSERT(exc != nullptr, "onRegion Returned nullptr");
+     // Now w/o filter, chk for singlehop
+     auto executeFunctionResult2 = exc->execute(FEOnRegionPrSHOP)->getResult();
+     if (executeFunctionResult2 == nullptr) {
+       ASSERT(false, "executeFunctionResult2 is nullptr");
       } else {
         sprintf(buf, "result count = %zd", executeFunctionResult2->size());
         LOG(buf);
@@ -394,11 +391,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
       LOGINFO("FEOnRegionPrSHOP without Filter done");
 
       // Now w/o filter chk single hop
-      MyResultCollectorPtr2 resultCollector(new MyResultCollector2());
-      CacheableVectorPtr executeFunctionResult21 =
-          exc->withCollector(resultCollector)
-              ->execute(FEOnRegionPrSHOP)
-              ->getResult();
+      std::shared_ptr<MyResultCollector2> resultCollector(new MyResultCollector2());
+      auto executeFunctionResult21 = exc->withCollector(resultCollector)
+                                         ->execute(FEOnRegionPrSHOP)
+                                         ->getResult();
       LOGINFO("add result count = %d", resultCollector->getAddResultCount());
       LOGINFO("end result count = %d", resultCollector->getEndResultCount());
       LOGINFO("get result count = %d", resultCollector->getGetResultCount());
@@ -426,8 +422,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
       LOGINFO("FEOnRegionPrSHOP done with ResultCollector without filter");
 
       // Now w/o filter chk for singleHop
-      MyResultCollectorPtr2 rC(new MyResultCollector2());
-      CacheableVectorPtr executeFunctionResult31 =
+      std::shared_ptr<MyResultCollector2> rC(new MyResultCollector2());
+      auto executeFunctionResult31 =
           exc->withCollector(rC)
               ->execute(FEOnRegionPrSHOP_OptimizeForWrite)
               ->getResult();
@@ -457,10 +453,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
           "Filter.");
 
       // Now w/o filter chk for singleHop
-      CacheableVectorPtr functionResult =
+     auto functionResult =
           exc->execute(FEOnRegionPrSHOP_OptimizeForWrite)->getResult();
-      if (functionResult == nullptr) {
-        ASSERT(false, "functionResult is nullptr");
+     if (functionResult == nullptr) {
+       ASSERT(false, "functionResult is nullptr");
       } else {
         sprintf(buf, "result count = %zd", functionResult->size());
         LOG(buf);
@@ -479,12 +475,12 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
 
       char KeyStr[256] = {0};
       char valStr[256] = {0};
-      CacheableVectorPtr fil = CacheableVector::create();
+     auto fil = CacheableVector::create();
       for (int i = 0; i < 500; i++) {
         ACE_OS::snprintf(KeyStr, 256, "KEY--%d ", i);
         ACE_OS::snprintf(valStr, 256, "VALUE--%d ", i);
-        CacheableStringPtr keyport = CacheableString::create(KeyStr);
-        CacheablePtr valport = CacheableString::create(valStr);
+        auto keyport = CacheableString::create(KeyStr);
+        auto valport = CacheableString::create(valStr);
         regPtr0->put(keyport, valport);
         fil->push_back(CacheableString::create(KeyStr));
       }
@@ -510,12 +506,12 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1OpTest2)
       }
 
       // Fire N Forget without filter keys
-      CacheableArrayListPtr arrList = CacheableArrayList::create();
+     auto arrList = CacheableArrayList::create();
       for (int i = 10; i < 200; i++) {
         ACE_OS::snprintf(KeyStr, 256, "KEY--%d ", i);
         arrList->push_back(CacheableString::create(KeyStr));
       }
-      ExecutionPtr ex = FunctionService::onRegion(regPtr0);
+     auto ex = FunctionService::onRegion(regPtr0);
       ex->withArgs(arrList)->execute(putFuncIName);
       LOGINFO(
           "Executing ExecuteFunctionOnRegion on region for execKeys for "
diff --git a/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp b/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp
index 7d46c500..90f53a49 100644
--- a/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp
+++ b/cppcache/integration-test/testThinClientFixedPartitionResolver.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include "BuiltinCacheableWrappers.hpp"
 #include <Utils.hpp>
 #include <geode/FixedPartitionResolver.hpp>
@@ -45,7 +44,7 @@ class CustomFixedPartitionResolver1 : public FixedPartitionResolver {
     return "CustomFixedPartitionResolver1";
   }
 
-  CacheableKeyPtr getRoutingObject(const EntryEvent& opDetails) {
+  std::shared_ptr<CacheableKey> getRoutingObject(const EntryEvent& opDetails) {
     LOG("CustomFixedPartitionResolver1::getRoutingObject()");
     int32_t key = atoi(opDetails.getKey()->toString()->asChar());
     int32_t newKey = key + 5;
@@ -84,7 +83,7 @@ class CustomFixedPartitionResolver2 : public FixedPartitionResolver {
     return "CustomFixedPartitionResolver2";
   }
 
-  CacheableKeyPtr getRoutingObject(const EntryEvent& opDetails) {
+  std::shared_ptr<CacheableKey> getRoutingObject(const EntryEvent& opDetails) {
     LOG("CustomFixedPartitionResolver2::getRoutingObject()");
     int32_t key = atoi(opDetails.getKey()->toString()->asChar());
     int32_t newKey = key + 4;
@@ -123,7 +122,7 @@ class CustomFixedPartitionResolver3 : public FixedPartitionResolver {
     return "CustomFixedPartitionResolver3";
   }
 
-  CacheableKeyPtr getRoutingObject(const EntryEvent& opDetails) {
+  std::shared_ptr<CacheableKey> getRoutingObject(const EntryEvent& opDetails) {
     LOG("CustomFixedPartitionResolver3::getRoutingObject()");
     int32_t key = atoi(opDetails.getKey()->toString()->asChar());
     int32_t newKey = key % 5;
@@ -228,7 +227,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask_REGION)
 
     LOGDEBUG("CheckPrSingleHopForIntKeysTask_REGION create region  = %s ",
              partitionRegionName);
-    RegionPtr dataReg = getHelper()->getRegion(partitionRegionName);
+    auto dataReg = getHelper()->getRegion(partitionRegionName);
 
     for (int i = 0; i < 3000; i++) {
       auto keyPtr =
@@ -321,7 +320,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForIntKeysTask_REGION)
     LOG("CheckPrSingleHopForIntKeysTask_REGION get completed.");
 
     for (int i = 1000; i < 2000; i++) {
-      VectorOfCacheableKey keys;
+      std::vector<std::shared_ptr<CacheableKey>> keys;
       for (int j = i; j < i + 5; j++) {
         keys.push_back(CacheableInt32::create(j));
       }
diff --git a/cppcache/integration-test/testThinClientGetInterests.cpp b/cppcache/integration-test/testThinClientGetInterests.cpp
index aaa3102a..abe4c3cf 100644
--- a/cppcache/integration-test/testThinClientGetInterests.cpp
+++ b/cppcache/integration-test/testThinClientGetInterests.cpp
@@ -42,7 +42,7 @@ END_TASK(StartServer)
 
 DUNIT_TASK(CLIENT1, SetupClient1)
   {
-    PropertiesPtr pp = Properties::create();
+    auto pp = Properties::create();
     pp->insert("durable-client-id", durableIds[0]);
     pp->insert("durable-timeout", std::chrono::seconds(300));
     pp->insert("notify-ack-interval", std::chrono::seconds(1));
@@ -50,19 +50,19 @@ DUNIT_TASK(CLIENT1, SetupClient1)
     initClientWithPool(true, "__TEST_POOL1__", locatorsG, nullptr, pp, 0, true);
     getHelper()->createPooledRegion(regionNames[0], false, locatorsG,
                                     "__TEST_POOL1__", true, true);
-    CacheableKeyPtr keyPtr0 = CacheableString::create(keys[0]);
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    VectorOfCacheableKey keys0;
+    auto keyPtr0 = CacheableString::create(keys[0]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    std::vector<std::shared_ptr<CacheableKey>> keys0;
     keys0.push_back(keyPtr0);
     regPtr0->registerKeys(keys0);
-    CacheableKeyPtr keyPtr1 = CacheableString::create(keys[1]);
-    VectorOfCacheableKey keys1;
+    auto keyPtr1 = CacheableString::create(keys[1]);
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyPtr1);
     regPtr0->registerKeys(keys1);
     regPtr0->registerRegex(testregex[0]);
     regPtr0->registerRegex(testregex[1]);
-    CacheableKeyPtr keyPtr2 = CacheableString::create(keys[2]);
-    VectorOfCacheableKey keys2;
+    auto keyPtr2 = CacheableString::create(keys[2]);
+    std::vector<std::shared_ptr<CacheableKey>> keys2;
     keys2.push_back(keyPtr2);
     keyPtr2 = CacheableString::create(keys[3]);
     keys2.push_back(keyPtr2);
@@ -90,7 +90,7 @@ DUNIT_TASK(CLIENT1, SetupClient1)
     }
     for (int32_t i = 0; i < vreg.size(); i++) {
       char buf[1024];
-      CacheableStringPtr ptr = vreg[i];
+      auto ptr = vreg[i];
       const char* reg = ptr->asChar();
       sprintf(buf, "regex[%d]=%s", i, reg);
       LOG(buf);
@@ -108,7 +108,7 @@ DUNIT_TASK(CLIENT1, SetupClient1)
     auto vreg1 = regPtr0->getInterestListRegex();
     for (int32_t i = 0; i < vreg1.size(); i++) {
       char buf[1024];
-      CacheableStringPtr ptr = vreg1[i];
+      auto ptr = vreg1[i];
       sprintf(buf, "regex[%d]=%s", i, ptr->asChar());
       LOG(buf);
     }
diff --git a/cppcache/integration-test/testThinClientHADistOps.cpp b/cppcache/integration-test/testThinClientHADistOps.cpp
index 50600792..7719408d 100644
--- a/cppcache/integration-test/testThinClientHADistOps.cpp
+++ b/cppcache/integration-test/testThinClientHADistOps.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 
@@ -44,7 +43,7 @@ const char* locatorsG =
 static int clientWithRedundancy = 0;
 void initClient(int redundancyLevel) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (clientWithRedundancy > 0) config->insert("grid-client", "true");
     clientWithRedundancy += 1;
     cacheHelper = new CacheHelper(redundancyLevel, config);
@@ -55,7 +54,7 @@ void initClient(int redundancyLevel) {
 static int clientWithNothing = 0;
 void initClient() {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (clientWithNothing > 1) config->insert("grid-client", "true");
     clientWithNothing += 1;
     cacheHelper = new CacheHelper(true, config);
@@ -66,7 +65,7 @@ void initClient() {
 static int clientWithXml = 0;
 void initClient(const char* clientXmlFile) {
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (clientWithXml > 2) config->insert("grid-client", "true");
     clientWithXml += 1;
     cacheHelper = new CacheHelper(nullptr, clientXmlFile, config);
@@ -105,10 +104,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   LOG(buf);
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (noKey == false) {  // need to find the key!
@@ -199,9 +198,9 @@ void destroyEntry(const char* name, const char* key) {
   fprintf(stdout, "Destroying entry -- key: %s  in region %s\n", key, name);
   fflush(stdout);
   // Destroy entry, verify entry is destroyed
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -219,8 +218,8 @@ void createRegion(const char* name, bool ackMode,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   char* endpoints = nullptr;
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -232,10 +231,10 @@ void createPooledRegion(const char* name, bool ackMode, const char* locators,
   LOG("createRegion_Pool() entered.");
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
-  PoolPtr poolPtr = getHelper()->createPool(
+  auto poolPtr = getHelper()->createPool(
       poolname, locators, nullptr, reduendency, clientNotificationEnabled);
-  RegionPtr regPtr = getHelper()->createRegionAndAttachPool(
-      name, ackMode, poolname, cachingEnable);
+  auto regPtr = getHelper()->createRegionAndAttachPool(name, ackMode, poolname,
+                                                       cachingEnable);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Pooled Region created.");
 }
@@ -245,10 +244,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -270,10 +269,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -294,9 +293,9 @@ void doGetAgain(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "get  region name%s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -326,9 +325,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
   fflush(stdout);
   static int count = 0;
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -417,8 +416,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT1, RegisterClient1Keys)
   {
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     auto vec0 = reg0->serverKeys();
     auto vec1 = reg1->serverKeys();
     ASSERT(vec0.size() == 2, "Should have 2 keys in first region.");
@@ -443,13 +442,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, RegisterClient1Keys)
     doNetsearch(regionNames[0], keys[1], vals[1]);
     doNetsearch(regionNames[1], keys[3], vals[3]);
 
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr1);
     keys1.push_back(keyPtr3);
     regPtr0->registerKeys(keys0);
@@ -463,13 +462,13 @@ DUNIT_TASK_DEFINITION(CLIENT2, RegisterClient2Keys)
     doNetsearch(regionNames[0], keys[0], vals[0]);
     doNetsearch(regionNames[1], keys[2], vals[2]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr0);
     keys1.push_back(keyPtr2);
     regPtr0->registerKeys(keys0);
diff --git a/cppcache/integration-test/testThinClientHAEventIDMap.cpp b/cppcache/integration-test/testThinClientHAEventIDMap.cpp
index b0e264d6..ed941695 100644
--- a/cppcache/integration-test/testThinClientHAEventIDMap.cpp
+++ b/cppcache/integration-test/testThinClientHAEventIDMap.cpp
@@ -15,14 +15,17 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
-#include <ace/High_Res_Timer.h>
 
-#include <ace/OS.h>
 #include <string>
 #include <thread>
 #include <chrono>
 
+#include <ace/High_Res_Timer.h>
+#include <ace/OS.h>
+
+#include <geode/EntryEvent.hpp>
+
+
 #define ROOT_NAME "testThinClientHAEventIDMap"
 #define ROOT_SCOPE DISTRIBUTED_ACK
 
@@ -38,7 +41,7 @@ class DupChecker : public CacheListener {
   void check(const EntryEvent& event) {
     m_ops++;
 
-    CacheableKeyPtr key = event.getKey();
+    auto key = event.getKey();
     auto value = std::dynamic_pointer_cast<CacheableInt32>(event.getNewValue());
 
     const auto& item = m_map.find(key);
@@ -76,8 +79,6 @@ class DupChecker : public CacheListener {
   virtual void afterRegionDestroy(const RegionEvent& event){};
 };
 
-typedef std::shared_ptr<DupChecker> DupCheckerPtr;
-
 ///////////////////////////////////////////////////////
 
 #define CLIENT1 s1p1
@@ -95,7 +96,7 @@ const char* locatorsG =
 int g_redundancyLevel = 0;
 
 void initClient() {
-  PropertiesPtr props = Properties::create();
+  auto props = Properties::create();
   props->insert("notify-ack-interval", std::chrono::hours(1));  // set to 1 hr.
   props->insert("notify-dupcheck-life", std::chrono::hours(1));
 
@@ -138,10 +139,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -229,10 +230,10 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -340,8 +341,8 @@ void createRegion(const char* name, bool ackMode,
   fflush(stdout);
   char* endpoints = nullptr;
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -352,10 +353,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -377,10 +378,10 @@ void createIntEntry(const char* name, const char* key, const int value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableInt32Ptr valPtr = CacheableInt32::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableInt32::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   // ASSERT( !regPtr->containsKey( keyPtr ), "Key should not have been found in
@@ -396,9 +397,10 @@ void createIntEntry(const char* name, const char* key, const int value) {
   LOG("Entry created.");
 }
 
-void setCacheListener(const char* regName, DupCheckerPtr checker) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName,
+                      std::shared_ptr<DupChecker> checker) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(checker);
 }
 
@@ -411,13 +413,12 @@ const char* regionNames[] = {"DistRegionAck", "DistRegionNoAck"};
 
 const bool USE_ACK = true;
 const bool NO_ACK = false;
-
-DupCheckerPtr checker1;
-DupCheckerPtr checker2;
+std::shared_ptr<DupChecker> checker1;
+std::shared_ptr<DupChecker> checker2;
 
 void initClientAndRegion(int redundancy,
                          bool clientNotificationEnabled = true) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   getHelper()->createPoolWithLocators("__TESTPOOL1_", locatorsG,
                                       clientNotificationEnabled, redundancy);
 
diff --git a/cppcache/integration-test/testThinClientHAFailover.cpp b/cppcache/integration-test/testThinClientHAFailover.cpp
index 58b10fdf..583bfd6d 100644
--- a/cppcache/integration-test/testThinClientHAFailover.cpp
+++ b/cppcache/integration-test/testThinClientHAFailover.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/High_Res_Timer.h>
 
 #include <ace/OS.h>
@@ -49,7 +48,7 @@ void initClient(int redundancyLevel) {
 
   s_isGridClient = !s_isGridClient;
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (s_isGridClient) {
       config->insert("grid-client", "true");
     }
@@ -64,7 +63,7 @@ void initClient()  // For POOL API redendency will be set at POOL level.
   static bool s_isGridClient = true;
   s_isGridClient = !s_isGridClient;
   if (cacheHelper == nullptr) {
-    PropertiesPtr config = Properties::create();
+    auto config = Properties::create();
     if (s_isGridClient) {
       config->insert("grid-client", "true");
     }
@@ -106,10 +105,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -205,8 +204,8 @@ void createRegion(const char* name, bool ackMode,
   fflush(stdout);
   char* endpoints = nullptr;
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -216,10 +215,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -241,10 +240,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -266,9 +265,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -303,7 +302,7 @@ const char* regionNames[] = {"DistRegionAck", "DistRegionNoAck"};
 
 const bool USE_ACK = true;
 void initClientAndRegion(int redundancy) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   g_redundancyLevel = redundancy;
   getHelper()->createPoolWithLocators("__TESTPOOL1_", locatorsG, true,
                                       redundancy);
@@ -385,13 +384,13 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterKeys)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr0);
     keys1.push_back(keyPtr2);
     if (g_redundancyLevel > 1) {
@@ -503,11 +502,11 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepEight)
     verifyEntry(regionNames[1], keys[2], vals[2]);
     verifyEntry(regionNames[1], keys[3], vals[3]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
 
-    VectorOfCacheableKey keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys1;
     keys1.push_back(keyPtr2);
     regPtr1->unregisterKeys(keys1);
     LOG("StepEight complete.");
diff --git a/cppcache/integration-test/testThinClientHAFailoverRegex.cpp b/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
index 93e19c75..f662ad8f 100644
--- a/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
+++ b/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/High_Res_Timer.h>
 
 #include <ace/OS.h>
@@ -84,10 +83,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -182,8 +181,8 @@ void createRegion(const char* name, bool ackMode,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
-                                               clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -194,10 +193,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -219,10 +218,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -244,9 +243,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -283,7 +282,7 @@ const char* regionNames[] = {"DistRegionAck", "DistRegionNoAck"};
 const bool USE_ACK = true;
 void initClientAndRegion(int redundancy) {
   g_redundancyLevel = redundancy;
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   getHelper()->createPoolWithLocators("__TESTPOOL1_", locatorsG, true,
                                       redundancy);
   getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
@@ -363,8 +362,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, RegisterRegexes)
   {
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
     if (g_redundancyLevel > 1) {
       regPtr0->registerRegex(testregex[0]);
@@ -421,8 +420,8 @@ END_TASK_DEFINITION
 
 DUNIT_TASK_DEFINITION(CLIENT2, StepSix)
   {
-    RegionPtr reg0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr reg1 = getHelper()->getRegion(regionNames[1]);
+    auto reg0 = getHelper()->getRegion(regionNames[0]);
+    auto reg1 = getHelper()->getRegion(regionNames[1]);
     auto vec0 = reg0->serverKeys();
     auto vec1 = reg1->serverKeys();
     ASSERT(vec0.size() == 2, "Should have 2 keys in first region.");
@@ -502,7 +501,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepEight)
     verifyEntry(regionNames[1], keys[2], vals[2]);
     verifyEntry(regionNames[1], keys[3], vals[3]);
 
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->unregisterRegex(testregex[2]);
 
     LOG("StepEight complete.");
diff --git a/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp b/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
index 7fd15ee1..a2323329 100644
--- a/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
+++ b/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/High_Res_Timer.h>
 
 #include <ace/OS.h>
@@ -89,10 +88,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -188,8 +187,8 @@ void createRegion(const char* name, bool ackMode,
   fflush(stdout);
   char* endpoints = nullptr;
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -200,10 +199,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -225,10 +224,10 @@ void updateEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Update entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
@@ -250,9 +249,9 @@ void doNetsearch(const char* name, const char* key, const char* value) {
       key, value, name);
   fflush(stdout);
   // Get entry created in Process A, verify entry is correct
-  CacheableKeyPtr keyPtr = CacheableKey::create(key);
+  auto keyPtr = CacheableKey::create(key);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   fprintf(stdout, "netsearch  region %s\n", regPtr->getName());
   fflush(stdout);
   ASSERT(regPtr != nullptr, "Region not found.");
@@ -288,7 +287,7 @@ const char* regionNames[] = {"DistRegionAck", "DistRegionNoAck"};
 const bool USE_ACK = true;
 #include "ThinClientTasks_C2S2.hpp"
 void createCommRegions(int redundancy) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   getHelper()->createPoolWithLocators("__TESTPOOL1_", locatorsG, true,
                                       redundancy);
   getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
@@ -343,13 +342,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepOne)
     SLEEP(1000);
     createEntry(regionNames[1], keys[3], vals[3]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr2 = CacheableKey::create(keys[2]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr2 = CacheableKey::create(keys[2]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr0);
     keys1.push_back(keyPtr2);
     regPtr0->registerKeys(keys0);
@@ -373,13 +372,13 @@ DUNIT_TASK_DEFINITION(CLIENT2, StepTwo)
     doNetsearch(regionNames[1], keys[2], vals[2]);
     doNetsearch(regionNames[1], keys[3], vals[3]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr1 = CacheableKey::create(keys[1]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto keyPtr1 = CacheableKey::create(keys[1]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr1);
     keys1.push_back(keyPtr3);
     regPtr0->registerKeys(keys0);
@@ -403,13 +402,13 @@ DUNIT_TASK_DEFINITION(CLIENT3, StepThree)
     doNetsearch(regionNames[1], keys[2], vals[2]);
     doNetsearch(regionNames[1], keys[3], vals[3]);
 
-    RegionPtr regPtr0 = getHelper()->getRegion(regionNames[0]);
-    RegionPtr regPtr1 = getHelper()->getRegion(regionNames[1]);
+    auto regPtr0 = getHelper()->getRegion(regionNames[0]);
+    auto regPtr1 = getHelper()->getRegion(regionNames[1]);
 
-    CacheableKeyPtr keyPtr0 = CacheableKey::create(keys[0]);
-    CacheableKeyPtr keyPtr3 = CacheableKey::create(keys[3]);
+    auto keyPtr0 = CacheableKey::create(keys[0]);
+    auto keyPtr3 = CacheableKey::create(keys[3]);
 
-    VectorOfCacheableKey keys0, keys1;
+    std::vector<std::shared_ptr<CacheableKey>> keys0, keys1;
     keys0.push_back(keyPtr0);
     keys1.push_back(keyPtr3);
     regPtr0->registerKeys(keys0);
diff --git a/cppcache/integration-test/testThinClientHAPeriodicAck.cpp b/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
index dae1da78..38ec5c01 100644
--- a/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
+++ b/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
@@ -15,14 +15,17 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
-#include <ace/High_Res_Timer.h>
 
-#include <ace/OS.h>
 #include <string>
 #include <thread>
 #include <chrono>
 
+#include <ace/High_Res_Timer.h>
+#include <ace/OS.h>
+
+#include <geode/EntryEvent.hpp>
+
+
 #define ROOT_NAME "testThinClientHAPeriodicAck"
 #define ROOT_SCOPE DISTRIBUTED_ACK
 
@@ -38,7 +41,7 @@ class DupChecker : public CacheListener {
   void check(const EntryEvent& event) {
     m_ops++;
 
-    CacheableKeyPtr key = event.getKey();
+    auto key = event.getKey();
     auto value = std::dynamic_pointer_cast<CacheableInt32>(event.getNewValue());
 
     const auto& item = m_map.find(key);
@@ -76,8 +79,6 @@ class DupChecker : public CacheListener {
   virtual void afterRegionDestroy(const RegionEvent& event){};
 };
 
-typedef std::shared_ptr<DupChecker> DupCheckerPtr;
-
 ///////////////////////////////////////////////////////
 
 #define CLIENT1 s1p1
@@ -96,7 +97,7 @@ bool g_poolConfig = false;
 bool g_poolLocators = false;
 
 void initClient(int redundancyLevel) {
-  PropertiesPtr props = Properties::create();
+  auto props = Properties::create();
   props->insert("notify-ack-interval", std::chrono::seconds(1));
   props->insert("notify-dupcheck-life", std::chrono::seconds(30));
 
@@ -108,7 +109,7 @@ void initClient(int redundancyLevel) {
 }
 
 void initClient() {
-  PropertiesPtr props = Properties::create();
+  auto props = Properties::create();
   props->insert("notify-ack-interval", std::chrono::seconds(1));
   props->insert("notify-dupcheck-life", std::chrono::seconds(30));
 
@@ -151,10 +152,10 @@ void _verifyEntry(const char* name, const char* key, const char* val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -242,10 +243,10 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
   }
   free(buf);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
-  CacheableKeyPtr keyPtr = createKey(key);
+  auto keyPtr = createKey(key);
 
   // if the region is no ack, then we may need to wait...
   if (!isCreated) {
@@ -353,8 +354,8 @@ void createRegion(const char* name, bool ackMode,
   fflush(stdout);
   char* endpoints = nullptr;
   // ack, caching
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, true, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, true, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(regPtr != nullptr, "Failed to create region.");
   LOG("Region created.");
 }
@@ -365,10 +366,10 @@ void createEntry(const char* name, const char* key, const char* value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableStringPtr valPtr = CacheableString::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableString::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   ASSERT(!regPtr->containsKey(keyPtr),
@@ -390,10 +391,10 @@ void createIntEntry(const char* name, const char* key, const int value) {
           value, name);
   fflush(stdout);
   // Create entry, verify entry is correct
-  CacheableKeyPtr keyPtr = createKey(key);
-  CacheableInt32Ptr valPtr = CacheableInt32::create(value);
+  auto keyPtr = createKey(key);
+  auto valPtr = CacheableInt32::create(value);
 
-  RegionPtr regPtr = getHelper()->getRegion(name);
+  auto regPtr = getHelper()->getRegion(name);
   ASSERT(regPtr != nullptr, "Region not found.");
 
   // ASSERT( !regPtr->containsKey( keyPtr ), "Key should not have been found in
@@ -409,9 +410,10 @@ void createIntEntry(const char* name, const char* key, const int value) {
   LOG("Entry created.");
 }
 
-void setCacheListener(const char* regName, DupCheckerPtr checker) {
-  RegionPtr reg = getHelper()->getRegion(regName);
-  AttributesMutatorPtr attrMutator = reg->getAttributesMutator();
+void setCacheListener(const char* regName,
+                      std::shared_ptr<DupChecker> checker) {
+  auto reg = getHelper()->getRegion(regName);
+  auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(checker);
 }
 
@@ -424,12 +426,11 @@ const char* regionNames[] = {"DistRegionAck", "DistRegionNoAck"};
 
 const bool USE_ACK = true;
 const bool NO_ACK = false;
-
-DupCheckerPtr checker1;
-DupCheckerPtr checker2;
+std::shared_ptr<DupChecker> checker1;
+std::shared_ptr<DupChecker> checker2;
 
 void initClientAndRegion(int redundancy) {
-  PropertiesPtr pp = Properties::create();
+  auto pp = Properties::create();
   getHelper()->createPoolWithLocators("__TESTPOOL1_", locatorsG, true,
                                       redundancy);
   getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
diff --git a/cppcache/integration-test/testThinClientHAQueryFailover.cpp b/cppcache/integration-test/testThinClientHAQueryFailover.cpp
index 18299df7..178ae630 100644
--- a/cppcache/integration-test/testThinClientHAQueryFailover.cpp
+++ b/cppcache/integration-test/testThinClientHAQueryFailover.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 #include "fw_dunit.hpp"
-#include <geode/GeodeCppCache.hpp>
 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include <ace/Task.h>
@@ -85,7 +84,7 @@ void initClient() {
   }
   ASSERT(cacheHelper, "Failed to create a CacheHelper client instance.");
   try {
-    SerializationRegistryPtr serializationRegistry =
+    auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
 
@@ -127,8 +126,8 @@ void createRegion(const char* name, bool ackMode,
   fprintf(stdout, "Creating region --  %s  ackMode is %d\n", name, ackMode);
   fflush(stdout);
   char* endpoints = nullptr;
-  RegionPtr regPtr = getHelper()->createRegion(
-      name, ackMode, false, nullptr, endpoints, clientNotificationEnabled);
+  auto regPtr = getHelper()->createRegion(name, ackMode, false, nullptr,
+                                          endpoints, clientNotificationEnabled);
   ASSERT(re