You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2017/09/08 04:56:09 UTC
[geode-native] branch develop updated: GEODE-3577: Remove redundant UserData typedef and header

This is an automated email from the ASF dual-hosted git repository.

jbarrett pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git


The following commit(s) were added to refs/heads/develop by this push:
     new b27203a  GEODE-3577: Remove redundant UserData typedef and header
b27203a is described below

commit b27203a3a9aad00b32d2283c2f916f76c373b67f
Author: Mark Hanson <mh...@pivotal.io>
AuthorDate: Thu Sep 7 15:12:10 2017 -0700

    GEODE-3577: Remove redundant UserData typedef and header
---
 clicache/src/EntryEvent.cpp                        |   2 +-
 clicache/src/LocalRegion.cpp                       |  14 +--
 clicache/src/Region.cpp                            |  24 ++--
 clicache/src/RegionEvent.cpp                       |   2 +-
 clicache/src/impl/CacheLoader.hpp                  |   4 +-
 clicache/src/impl/ManagedCacheLoader.cpp           |   2 +-
 clicache/src/impl/ManagedCacheLoader.hpp           |   2 +-
 cppcache/include/geode/CacheLoader.hpp             |   3 +-
 cppcache/include/geode/EntryEvent.hpp              |   7 +-
 cppcache/include/geode/GeodeCppCache.hpp           |   1 -
 cppcache/include/geode/Region.hpp                  |  95 ++++++++--------
 cppcache/include/geode/RegionEvent.hpp             |   7 +-
 cppcache/include/geode/UserData.hpp                |  40 -------
 cppcache/integration-test/TallyLoader.hpp          |   2 +-
 cppcache/integration-test/ThinClientHelper.hpp     |   8 +-
 .../integration-test/ThinClientListenerInit.hpp    |   2 +-
 .../ThinClientLocalCacheLoader.hpp                 |   2 +-
 cppcache/integration-test/testLinkage.cpp          |   2 +-
 cppcache/src/ClientMetadataService.cpp             |   6 +-
 cppcache/src/ClientMetadataService.hpp             |   8 +-
 cppcache/src/EntryEvent.cpp                        |   2 +-
 cppcache/src/FarSideEntryOp.hpp                    |   3 +-
 cppcache/src/LocalRegion.cpp                       | 122 ++++++++++-----------
 cppcache/src/LocalRegion.hpp                       | 113 ++++++++++---------
 cppcache/src/ProxyRegion.hpp                       |  95 ++++++++--------
 cppcache/src/RegionEvent.cpp                       |   2 +-
 cppcache/src/RegionInternal.cpp                    |   6 +-
 cppcache/src/RegionInternal.hpp                    |  24 ++--
 cppcache/src/TcrMessage.cpp                        |  24 ++--
 cppcache/src/TcrMessage.hpp                        |  25 ++---
 cppcache/src/ThinClientPoolDM.cpp                  |   4 +-
 cppcache/src/ThinClientRegion.cpp                  |  50 ++++-----
 cppcache/src/ThinClientRegion.hpp                  |  40 +++----
 cppcache/test/TcrMessage_unittest.cpp              |  16 +--
 quickstart/cpp/Exceptions.cpp                      |   2 +-
 quickstart/cpp/plugins/SimpleCacheLoader.cpp       |   2 +-
 quickstart/cpp/plugins/SimpleCacheLoader.hpp       |   2 +-
 37 files changed, 358 insertions(+), 407 deletions(-)

diff --git a/clicache/src/EntryEvent.cpp b/clicache/src/EntryEvent.cpp
index 51a0ef5..47218c6 100644
--- a/clicache/src/EntryEvent.cpp
+++ b/clicache/src/EntryEvent.cpp
@@ -59,7 +59,7 @@ namespace Apache
       generic<class TKey, class TValue>
       Object^ EntryEvent<TKey, TValue>::CallbackArgument::get()
       {
-        apache::geode::client::UserDataPtr& valptr(m_nativeptr->getCallbackArgument());
+        apache::geode::client::SerializablePtr& valptr(m_nativeptr->getCallbackArgument());
         return Serializable::GetManagedValueGeneric<Object^>( valptr );
       }
 
diff --git a/clicache/src/LocalRegion.cpp b/clicache/src/LocalRegion.cpp
index 1313558..ae80b27 100644
--- a/clicache/src/LocalRegion.cpp
+++ b/clicache/src/LocalRegion.cpp
@@ -79,7 +79,7 @@ namespace Apache
         {
           native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key, m_nativeptr->get()->getCache().get() );
           native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value, m_nativeptr->get()->getCache().get() );        
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
           m_nativeptr->get()->localPut( keyptr, valueptr, callbackptr );
         }
         finally
@@ -365,7 +365,7 @@ namespace Apache
           {
             native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key, m_nativeptr->get()->getCache().get() );
             native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>( value, m_nativeptr->get()->getCache().get() );          
-            native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
+            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
             m_nativeptr->get()->localCreate( keyptr, valueptr, callbackptr );
           }
           finally
@@ -407,7 +407,7 @@ namespace Apache
            try
            {
              native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
-             native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+             native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
              m_nativeptr->get()->localDestroy(keyptr, callbackptr);
              return true;
            }
@@ -450,7 +450,7 @@ namespace Apache
           {
             native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
             native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value, m_nativeptr->get()->getCache().get());
-            native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
             return m_nativeptr->get()->localRemove(keyptr, valueptr, callbackptr);
           }
           finally
@@ -478,7 +478,7 @@ namespace Apache
                     
           try
           {
-            native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
+            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
             m_nativeptr->get()->localInvalidateRegion( callbackptr );
           }
           finally
@@ -505,7 +505,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */          
           try
           {
-            native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
+            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
             m_nativeptr->get()->localDestroyRegion( callbackptr );
           }
           finally
@@ -534,7 +534,7 @@ namespace Apache
           try
           {
             native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>( key, m_nativeptr->get()->getCache().get() );          
-            native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );            
+            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg, m_nativeptr->get()->getCache().get() );
             m_nativeptr->get()->localInvalidate( keyptr, callbackptr );
           }
           finally
diff --git a/clicache/src/Region.cpp b/clicache/src/Region.cpp
index 17e9a62..ca8ec95 100644
--- a/clicache/src/Region.cpp
+++ b/clicache/src/Region.cpp
@@ -51,7 +51,7 @@ namespace Apache
       TValue Region<TKey, TValue>::Get(TKey key, Object^ callbackArg)
       {
         native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
-        native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+        native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
         GC::KeepAlive(m_nativeptr);
         auto nativeptr = this->get(keyptr, callbackptr);
         if (nativeptr == nullptr)
@@ -118,7 +118,7 @@ namespace Apache
           {
             native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
             native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value, m_nativeptr->get()->getCache().get());
-            native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+            native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
             m_nativeptr->get()->put(keyptr, valueptr, callbackptr);
           }
           finally
@@ -410,7 +410,7 @@ namespace Apache
         {
           native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
           native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value, m_nativeptr->get()->getCache().get());
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           m_nativeptr->get()->create(keyptr, valueptr, callbackptr);
         }
         finally
@@ -448,7 +448,7 @@ namespace Apache
         try
         {
           native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           return m_nativeptr->get()->removeEx(keyptr, callbackptr);
         }
         finally
@@ -487,7 +487,7 @@ namespace Apache
         {
           native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
           native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(value, m_nativeptr->get()->getCache().get());
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           GC::KeepAlive(m_nativeptr);
           return m_nativeptr->get()->remove(keyptr, valueptr, callbackptr);
         }
@@ -516,7 +516,7 @@ namespace Apache
 
         try
         {
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           m_nativeptr->get()->invalidateRegion(callbackptr);
         }
         finally
@@ -544,7 +544,7 @@ namespace Apache
 
         try
         {
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           m_nativeptr->get()->destroyRegion(callbackptr);
         }
         finally
@@ -574,7 +574,7 @@ namespace Apache
         try
         {
           native::CacheableKeyPtr keyptr = Serializable::GetUnmanagedValueGeneric<TKey>(key, m_nativeptr->get()->getCache().get());
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           m_nativeptr->get()->invalidate(keyptr, callbackptr);
         }
         finally
@@ -633,7 +633,7 @@ namespace Apache
           native::CacheablePtr valueptr = Serializable::GetUnmanagedValueGeneric<TValue>(keyValPair.Value, m_nativeptr->get()->getCache().get());
           nativeMap.emplace(keyptr, valueptr);
         }
-        native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+        native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
         try
         {
           m_nativeptr->get()->putAll(nativeMap, timeout, callbackptr);
@@ -741,7 +741,7 @@ namespace Apache
             exceptionsPtr = std::make_shared<native::HashMapOfException>();
           }
 
-         native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+         native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
 
           try
           {
@@ -794,7 +794,7 @@ namespace Apache
         for each(TKey item in keys)
           vecKeys.push_back(Serializable::GetUnmanagedValueGeneric<TKey>(item, m_nativeptr->get()->getCache().get()));
 
-        native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+        native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
 
         try
         {
@@ -1092,7 +1092,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
         try
         {
-          native::UserDataPtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
+          native::SerializablePtr callbackptr = Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg, m_nativeptr->get()->getCache().get());
           m_nativeptr->get()->clear(callbackptr);
         }
         finally
diff --git a/clicache/src/RegionEvent.cpp b/clicache/src/RegionEvent.cpp
index 3ee64d2..059e130 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::UserDataPtr& valptr(m_nativeptr->getCallbackArgument());
+        apache::geode::client::SerializablePtr& valptr(m_nativeptr->getCallbackArgument());
         return Serializable::GetManagedValueGeneric<Object^>( valptr );
       }
 
diff --git a/clicache/src/impl/CacheLoader.hpp b/clicache/src/impl/CacheLoader.hpp
index c785338..cc47cc3 100644
--- a/clicache/src/impl/CacheLoader.hpp
+++ b/clicache/src/impl/CacheLoader.hpp
@@ -41,7 +41,7 @@ namespace Apache
       {
       public:
         apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region,
-          const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::UserDataPtr& helper );
+          const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::SerializablePtr& helper );
 
         void close( const apache::geode::client::RegionPtr& region );
       };
@@ -61,7 +61,7 @@ namespace Apache
           }
 
           virtual apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region,
-            const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::UserDataPtr& helper )
+            const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::SerializablePtr& helper )
           {
             IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region);
 
diff --git a/clicache/src/impl/ManagedCacheLoader.cpp b/clicache/src/impl/ManagedCacheLoader.cpp
index 21e9657..c40de7d 100644
--- a/clicache/src/impl/ManagedCacheLoader.cpp
+++ b/clicache/src/impl/ManagedCacheLoader.cpp
@@ -215,7 +215,7 @@ namespace apache
       }
 
       CacheablePtr ManagedCacheLoaderGeneric::load(const RegionPtr& region,
-                                                   const CacheableKeyPtr& key, const UserDataPtr& aCallbackArgument)
+                                                   const CacheableKeyPtr& key, const SerializablePtr& aCallbackArgument)
       {
         try {
           return m_managedptr->load(region, key, aCallbackArgument);
diff --git a/clicache/src/impl/ManagedCacheLoader.hpp b/clicache/src/impl/ManagedCacheLoader.hpp
index 4d09d49..8b717ef 100644
--- a/clicache/src/impl/ManagedCacheLoader.hpp
+++ b/clicache/src/impl/ManagedCacheLoader.hpp
@@ -97,7 +97,7 @@ namespace apache
         /// </returns>
         /// <seealso cref="Apache.Geode.Client.Region.Get" />
         virtual CacheablePtr load(const RegionPtr& region,
-          const CacheableKeyPtr& key, const UserDataPtr& aCallbackArgument);
+          const CacheableKeyPtr& key, const SerializablePtr& aCallbackArgument);
 
         /// <summary>
         /// Called when the region containing this callback is destroyed, when
diff --git a/cppcache/include/geode/CacheLoader.hpp b/cppcache/include/geode/CacheLoader.hpp
index 5a1f898..425ed4a 100644
--- a/cppcache/include/geode/CacheLoader.hpp
+++ b/cppcache/include/geode/CacheLoader.hpp
@@ -28,7 +28,6 @@
 #include "geode_types.hpp"
 #include "CacheableKey.hpp"
 #include "Cacheable.hpp"
-#include "UserData.hpp"
 
 namespace apache {
 namespace geode {
@@ -69,7 +68,7 @@ class CPPCACHE_EXPORT CacheLoader  {
    *@see Region::get .
    */
   virtual CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                            const UserDataPtr& aCallbackArgument) = 0;
+                            const SerializablePtr& aCallbackArgument) = 0;
 
   /** Called when the region containing this callback is destroyed, when
    * the cache is closed.
diff --git a/cppcache/include/geode/EntryEvent.hpp b/cppcache/include/geode/EntryEvent.hpp
index 43cd355..b38edc3 100644
--- a/cppcache/include/geode/EntryEvent.hpp
+++ b/cppcache/include/geode/EntryEvent.hpp
@@ -23,7 +23,6 @@
 #include "geode_types.hpp"
 #include "Region.hpp"
 #include "CacheableKey.hpp"
-#include "UserData.hpp"
 
 /** @file
 */
@@ -40,7 +39,7 @@ class CPPCACHE_EXPORT EntryEvent {
   CacheableKeyPtr m_key;   /**< Cacheable key */
   CacheablePtr m_oldValue; /**< Old value */
   CacheablePtr m_newValue; /**< New value */
-  UserDataPtr
+  SerializablePtr
       m_callbackArgument; /**< Callback argument for this event, if any. */
   bool m_remoteOrigin;    /**< True if from a remote (non-local) process */
 
@@ -48,7 +47,7 @@ class CPPCACHE_EXPORT EntryEvent {
   /** Constructor, given all values. */
   EntryEvent(const RegionPtr& region, const CacheableKeyPtr& key,
              const CacheablePtr& oldValue, const CacheablePtr& newValue,
-             const UserDataPtr& aCallbackArgument, const bool remoteOrigin);
+             const SerializablePtr& aCallbackArgument, const bool remoteOrigin);
 
   /** Destructor. */
   virtual ~EntryEvent();
@@ -79,7 +78,7 @@ class CPPCACHE_EXPORT EntryEvent {
    * this event. See the {@link Region} interface methods that take
    * a callbackArgument parameter.
    */
-  inline UserDataPtr getCallbackArgument() const { return m_callbackArgument; }
+  inline SerializablePtr 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/GeodeCppCache.hpp b/cppcache/include/geode/GeodeCppCache.hpp
index 5a3ff56..606c5ac 100644
--- a/cppcache/include/geode/GeodeCppCache.hpp
+++ b/cppcache/include/geode/GeodeCppCache.hpp
@@ -69,7 +69,6 @@
 #include "Serializable.hpp"
 #include <memory>
 #include "StructSet.hpp"
-#include "UserData.hpp"
 #include "VectorT.hpp"
 #include "TransactionId.hpp"
 #include "UserFunctionExecutionException.hpp"
diff --git a/cppcache/include/geode/Region.hpp b/cppcache/include/geode/Region.hpp
index 15e2da1..4b51332 100644
--- a/cppcache/include/geode/Region.hpp
+++ b/cppcache/include/geode/Region.hpp
@@ -29,7 +29,6 @@
 #include "CacheStatistics.hpp"
 #include "ExceptionTypes.hpp"
 #include "CacheableString.hpp"
-#include "UserData.hpp"
 #include "CacheableBuiltins.hpp"
 
 /**
@@ -133,7 +132,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * This operation is not distributed.
    */
   virtual void invalidateRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Invalidates this region. The invalidation will cascade to
   * all the subregions and cached entries. After
@@ -155,7 +154,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
 
   */
   virtual void localInvalidateRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Destroys the whole region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> invoked in the process.
@@ -194,7 +193,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see  invalidateRegion
    */
   virtual void destroyRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+      const SerializablePtr& 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>
@@ -202,7 +201,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void clear(const UserDataPtr& aCallbackArgument = nullptr) = 0;
+  virtual void clear(const SerializablePtr& 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>
@@ -210,7 +209,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void localClear(const UserDataPtr& aCallbackArgument = nullptr) = 0;
+  virtual void localClear(const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Destroys the whole region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> invoked in the process.
@@ -232,7 +231,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see  localInvalidateRegion
    */
   virtual void localDestroyRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Returns the subregion identified by the path, nullptr if no such subregion
    */
@@ -305,12 +304,12 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    *region
    **/
   virtual CacheablePtr get(const CacheableKeyPtr& key,
-                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                           const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline CacheablePtr get(const KEYTYPE& key,
-                          const UserDataPtr& callbackArg = nullptr) {
+                          const SerializablePtr& callbackArg = nullptr) {
     return get(createKey(key), callbackArg);
   }
 
@@ -360,26 +359,26 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws OutOfMemoryException if  not enoough memory for the value
    */
   virtual void put(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                   const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void put(const KEYTYPE& key, const VALUETYPE& value,
-                  const UserDataPtr& arg = nullptr) {
+                  const SerializablePtr& arg = nullptr) {
     put(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void put(const KEYTYPE& key, const CacheablePtr& value,
-                  const UserDataPtr& arg = nullptr) {
+                  const SerializablePtr& arg = nullptr) {
     put(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void put(const CacheableKeyPtr& key, const VALUETYPE& value,
-                  const UserDataPtr& arg = nullptr) {
+                  const SerializablePtr& arg = nullptr) {
     put(key, createValue(value), arg);
   }
 
@@ -406,7 +405,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    */
   virtual void putAll(const HashMapOfCacheable& map,
                       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /**
    * Places a new value into an entry in this region with the specified key
@@ -433,26 +432,26 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws OutOfMemoryException if not enoough memory for the value
    */
   virtual void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                        const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                        const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
-                       const UserDataPtr& arg = nullptr) {
+                       const SerializablePtr& arg = nullptr) {
     localPut(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localPut(const KEYTYPE& key, const CacheablePtr& value,
-                       const UserDataPtr& arg = nullptr) {
+                       const SerializablePtr& arg = nullptr) {
     localPut(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void localPut(const CacheableKeyPtr& key, const VALUETYPE& value,
-                       const UserDataPtr& arg = nullptr) {
+                       const SerializablePtr& arg = nullptr) {
     localPut(key, createValue(value), arg);
   }
 
@@ -503,26 +502,26 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @throws EntryExistsException if an entry with this key already exists
    */
   virtual void create(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void create(const KEYTYPE& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     create(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void create(const KEYTYPE& key, const CacheablePtr& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     create(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void create(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     create(key, createValue(value), arg);
   }
 
@@ -553,26 +552,26 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    */
   virtual void localCreate(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                           const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     localCreate(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localCreate(const KEYTYPE& key, const CacheablePtr& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     localCreate(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void localCreate(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     localCreate(key, createValue(value), arg);
   }
 
@@ -599,11 +598,11 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheListener::afterInvalidate
    */
   virtual void invalidate(const CacheableKeyPtr& key,
-                          const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                          const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void invalidate(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
+  inline void invalidate(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
     invalidate(createKey(key), arg);
   }
 
@@ -629,12 +628,12 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    */
   virtual void localInvalidate(
       const CacheableKeyPtr& key,
-      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localInvalidate(const KEYTYPE& key,
-                              const UserDataPtr& arg = nullptr) {
+                              const SerializablePtr& arg = nullptr) {
     localInvalidate(createKey(key), arg);
   }
 
@@ -683,11 +682,11 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheWriter::beforeDestroy
    */
   virtual void destroy(const CacheableKeyPtr& key,
-                       const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                       const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void destroy(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
+  inline void destroy(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
     destroy(createKey(key), arg);
   }
 
@@ -716,12 +715,12 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheWriter::beforeDestroy
    */
   virtual void localDestroy(const CacheableKeyPtr& key,
-                            const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                            const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localDestroy(const KEYTYPE& key,
-                           const UserDataPtr& arg = nullptr) {
+                           const SerializablePtr& arg = nullptr) {
     localDestroy(createKey(key), arg);
   }
 
@@ -774,26 +773,26 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheWriter::beforeDestroy
    */
   virtual bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     return remove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool remove(const KEYTYPE& key, const CacheablePtr& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     return remove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline bool remove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     return remove(key, createValue(value), arg);
   }
 
@@ -852,11 +851,11 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see CacheWriter::beforeDestroy
    */
   virtual bool removeEx(const CacheableKeyPtr& key,
-                        const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                        const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool removeEx(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
+  inline bool removeEx(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
     return removeEx(createKey(key), arg);
   }
 
@@ -889,26 +888,26 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    */
   virtual bool localRemove(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                           const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     return localRemove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool localRemove(const KEYTYPE& key, const CacheablePtr& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     return localRemove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline bool localRemove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     return localRemove(key, createValue(value), arg);
   }
 
@@ -940,12 +939,12 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
 
   virtual bool localRemoveEx(
       const CacheableKeyPtr& key,
-      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool localRemoveEx(const KEYTYPE& key,
-                            const UserDataPtr& arg = nullptr) {
+                            const SerializablePtr& arg = nullptr) {
     return localRemoveEx(createKey(key), arg);
   }
 
@@ -1310,7 +1309,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
                       HashMapOfCacheablePtr values,
                       HashMapOfExceptionPtr exceptions,
                       bool addToLocalCache = false,
-                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                      const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /**
    * Executes the query on the server based on the predicate.
@@ -1427,7 +1426,7 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
    * @see destroy
    */
   virtual void removeAll(const VectorOfCacheableKey& keys,
-                         const UserDataPtr& aCallbackArgument = nullptr) = 0;
+                         const SerializablePtr& aCallbackArgument = nullptr) = 0;
 
   /**
    * Get the size of region. For native client regions, this will give the
diff --git a/cppcache/include/geode/RegionEvent.hpp b/cppcache/include/geode/RegionEvent.hpp
index 05671ae..70013ee 100644
--- a/cppcache/include/geode/RegionEvent.hpp
+++ b/cppcache/include/geode/RegionEvent.hpp
@@ -23,7 +23,6 @@
 #include "geode_types.hpp"
 #include "Region.hpp"
 #include "CacheableKey.hpp"
-#include "UserData.hpp"
 
 /** @file
 */
@@ -38,7 +37,7 @@ namespace client {
 class CPPCACHE_EXPORT RegionEvent {
  protected:
   const RegionPtr m_region; /**< Region for this event. */
-  const UserDataPtr
+  const SerializablePtr
       m_callbackArgument;    /**< Callback argument for this event, if any. */
   const bool m_remoteOrigin; /**< True if from a remote process. */
 
@@ -46,7 +45,7 @@ class CPPCACHE_EXPORT RegionEvent {
   /** Constructor. */
   RegionEvent();
   /** Constructor, given the values. */
-  RegionEvent(const RegionPtr& region, const UserDataPtr& aCallbackArgument,
+  RegionEvent(const RegionPtr& region, const SerializablePtr& aCallbackArgument,
               const bool remoteOrigin);
 
   /** Destructor. */
@@ -60,7 +59,7 @@ class CPPCACHE_EXPORT RegionEvent {
    * this event. See the {@link Region} interface methods that take
    * a callbackArgument parameter.
    */
-  inline UserDataPtr getCallbackArgument() const { return m_callbackArgument; }
+  inline SerializablePtr 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/UserData.hpp b/cppcache/include/geode/UserData.hpp
deleted file mode 100644
index c722d4b..0000000
--- a/cppcache/include/geode/UserData.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-#ifndef GEODE_USERDATA_H_
-#define GEODE_USERDATA_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 "Serializable.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-
-typedef Serializable UserData;
-typedef std::shared_ptr<UserData> UserDataPtr;
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif  // GEODE_USERDATA_H_
diff --git a/cppcache/integration-test/TallyLoader.hpp b/cppcache/integration-test/TallyLoader.hpp
index 6b72ab1..e7184aa 100644
--- a/cppcache/integration-test/TallyLoader.hpp
+++ b/cppcache/integration-test/TallyLoader.hpp
@@ -42,7 +42,7 @@ class TallyLoader : virtual public CacheLoader {
   virtual ~TallyLoader() {}
 
   CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                    const UserDataPtr& aCallbackArgument) {
+                    const SerializablePtr& aCallbackArgument) {
     LOGDEBUG("TallyLoader::load invoked for %d.", m_loads);
     char buf[1024];
     sprintf(buf, "TallyLoader state: (loads = %d)", m_loads);
diff --git a/cppcache/integration-test/ThinClientHelper.hpp b/cppcache/integration-test/ThinClientHelper.hpp
index 34f2452..a52b50a 100644
--- a/cppcache/integration-test/ThinClientHelper.hpp
+++ b/cppcache/integration-test/ThinClientHelper.hpp
@@ -662,7 +662,7 @@ class RegionOperations {
   RegionOperations(const char* name)
       : m_regionPtr(getHelper()->getRegion(name)) {}
 
-  void putOp(int keys = 1, const UserDataPtr& aCallbackArgument = nullptr) {
+  void putOp(int keys = 1, const SerializablePtr& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
@@ -673,7 +673,7 @@ class RegionOperations {
     }
   }
   void invalidateOp(int keys = 1,
-                    const UserDataPtr& aCallbackArgument = nullptr) {
+                    const SerializablePtr& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
@@ -682,7 +682,7 @@ class RegionOperations {
       m_regionPtr->localInvalidate(keybuf, aCallbackArgument);
     }
   }
-  void destroyOp(int keys = 1, const UserDataPtr& aCallbackArgument = nullptr) {
+  void destroyOp(int keys = 1, const SerializablePtr& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
@@ -691,7 +691,7 @@ class RegionOperations {
       m_regionPtr->destroy(keybuf, aCallbackArgument);
     }
   }
-  void removeOp(int keys = 1, const UserDataPtr& aCallbackArgument = nullptr) {
+  void removeOp(int keys = 1, const SerializablePtr& aCallbackArgument = nullptr) {
     char keybuf[100];
     char valbuf[100];
     for (int i = 1; i <= keys; i++) {
diff --git a/cppcache/integration-test/ThinClientListenerInit.hpp b/cppcache/integration-test/ThinClientListenerInit.hpp
index 4b803b7..8082ab9 100644
--- a/cppcache/integration-test/ThinClientListenerInit.hpp
+++ b/cppcache/integration-test/ThinClientListenerInit.hpp
@@ -55,7 +55,7 @@ class ThinClientTallyLoader : public TallyLoader {
   virtual ~ThinClientTallyLoader() {}
 
   CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                    const UserDataPtr& aCallbackArgument) {
+                    const SerializablePtr& aCallbackArgument) {
     int32_t loadValue = std::dynamic_pointer_cast<CacheableInt32>(
                             TallyLoader::load(rp, key, aCallbackArgument))
                             ->value();
diff --git a/cppcache/integration-test/ThinClientLocalCacheLoader.hpp b/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
index 6b9a3c7..0ee53ea 100644
--- a/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
+++ b/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
@@ -43,7 +43,7 @@ class ThinClientTallyLoader : public TallyLoader {
   virtual ~ThinClientTallyLoader() {}
 
   CacheablePtr load(const RegionPtr& rp, const CacheableKeyPtr& key,
-                    const UserDataPtr& aCallbackArgument) {
+                    const SerializablePtr& aCallbackArgument) {
     int32_t loadValue = std::dynamic_pointer_cast<CacheableInt32>(
                             TallyLoader::load(rp, key, aCallbackArgument))
                             ->value();
diff --git a/cppcache/integration-test/testLinkage.cpp b/cppcache/integration-test/testLinkage.cpp
index 9db8f98..5a7b7fc 100644
--- a/cppcache/integration-test/testLinkage.cpp
+++ b/cppcache/integration-test/testLinkage.cpp
@@ -83,7 +83,7 @@ BEGIN_TEST(LinkageTest)
   // Cache cache;
   ASSERT((!cachePtr->isClosed()), "cache shouldn't be closed.");
   RegionPtr rptr;
-  UserDataPtr callback;
+  SerializablePtr callback;
   //    CacheListener cl;
   CacheListenerPtr clPtr;
   //    CacheLoader cacheloader;
diff --git a/cppcache/src/ClientMetadataService.cpp b/cppcache/src/ClientMetadataService.cpp
index 20b611f..3fc7ef4 100644
--- a/cppcache/src/ClientMetadataService.cpp
+++ b/cppcache/src/ClientMetadataService.cpp
@@ -231,7 +231,7 @@ ClientMetadataPtr ClientMetadataService::SendClientPRMetadata(
 
 void ClientMetadataService::getBucketServerLocation(
     const RegionPtr& region, const CacheableKeyPtr& key,
-    const CacheablePtr& value, const UserDataPtr& aCallbackArgument,
+    const CacheablePtr& value, const SerializablePtr& aCallbackArgument,
     bool isPrimary, BucketServerLocationPtr& serverLocation, int8_t& version) {
   // ACE_Guard< ACE_Recursive_Thread_Mutex > guard( m_regionMetadataLock );
   if (region != nullptr) {
@@ -461,7 +461,7 @@ ClientMetadataService::getServerToFilterMap(const VectorOfCacheableKey& keys,
 
 void ClientMetadataService::markPrimaryBucketForTimeout(
     const RegionPtr& region, const CacheableKeyPtr& key,
-    const CacheablePtr& value, const UserDataPtr& aCallbackArgument,
+    const CacheablePtr& value, const SerializablePtr& aCallbackArgument,
     bool isPrimary, BucketServerLocationPtr& serverLocation, int8_t& version) {
   if (m_bucketWaitTimeout == 0) return;
 
@@ -808,7 +808,7 @@ ClientMetadataService::groupByServerToBuckets(const ClientMetadataPtr& metadata,
 
 void ClientMetadataService::markPrimaryBucketForTimeoutButLookSecondaryBucket(
     const RegionPtr& region, const CacheableKeyPtr& key,
-    const CacheablePtr& value, const UserDataPtr& aCallbackArgument,
+    const CacheablePtr& value, const SerializablePtr& aCallbackArgument,
     bool isPrimary, BucketServerLocationPtr& serverLocation, int8_t& version) {
   if (m_bucketWaitTimeout == 0) return;
 
diff --git a/cppcache/src/ClientMetadataService.hpp b/cppcache/src/ClientMetadataService.hpp
index 77da244..0bc0af1 100644
--- a/cppcache/src/ClientMetadataService.hpp
+++ b/cppcache/src/ClientMetadataService.hpp
@@ -130,7 +130,7 @@ class ClientMetadataService : public ACE_Task_Base,
 
   void getBucketServerLocation(
       const RegionPtr& region, const CacheableKeyPtr& key,
-      const CacheablePtr& value, const UserDataPtr& aCallbackArgument,
+      const CacheablePtr& value, const SerializablePtr& aCallbackArgument,
       bool isPrimary, BucketServerLocationPtr& serverLocation, int8_t& version);
 
   void removeBucketServerLocation(BucketServerLocation serverLocation);
@@ -154,12 +154,12 @@ class ClientMetadataService : public ACE_Task_Base,
 
   void markPrimaryBucketForTimeout(
       const RegionPtr& region, const CacheableKeyPtr& key,
-      const CacheablePtr& value, const UserDataPtr& aCallbackArgument,
+      const CacheablePtr& value, const SerializablePtr& aCallbackArgument,
       bool isPrimary, BucketServerLocationPtr& serverLocation, int8_t& version);
 
   void markPrimaryBucketForTimeoutButLookSecondaryBucket(
       const RegionPtr& region, const CacheableKeyPtr& key,
-      const CacheablePtr& value, const UserDataPtr& aCallbackArgument,
+      const CacheablePtr& value, const SerializablePtr& aCallbackArgument,
       bool isPrimary, BucketServerLocationPtr& serverLocation, int8_t& version);
 
   bool isBucketMarkedForTimeout(const char* regionFullPath, int32_t bucketid);
@@ -206,7 +206,7 @@ class ClientMetadataService : public ACE_Task_Base,
  private:
   // const PartitionResolverPtr& getResolver(const RegionPtr& region, const
   // CacheableKeyPtr& key,
-  // const UserDataPtr& aCallbackArgument);
+  // const SerializablePtr& aCallbackArgument);
 
   // BucketServerLocation getServerLocation(ClientMetadataPtr cptr, int
   // bucketId, bool isPrimary);
diff --git a/cppcache/src/EntryEvent.cpp b/cppcache/src/EntryEvent.cpp
index 3136591..6f0e54e 100644
--- a/cppcache/src/EntryEvent.cpp
+++ b/cppcache/src/EntryEvent.cpp
@@ -23,7 +23,7 @@ namespace client {
 EntryEvent::EntryEvent(const RegionPtr& region, const CacheableKeyPtr& key,
                        const CacheablePtr& oldValue,
                        const CacheablePtr& newValue,
-                       const UserDataPtr& aCallbackArgument,
+                       const SerializablePtr& aCallbackArgument,
                        const bool remoteOrigin)
     : m_region(region),
       m_key(key),
diff --git a/cppcache/src/FarSideEntryOp.hpp b/cppcache/src/FarSideEntryOp.hpp
index ab4063a..7455833 100644
--- a/cppcache/src/FarSideEntryOp.hpp
+++ b/cppcache/src/FarSideEntryOp.hpp
@@ -31,7 +31,6 @@
 #include <geode/Cacheable.hpp>
 #include <geode/DataOutput.hpp>
 #include <geode/DataInput.hpp>
-#include <geode/UserData.hpp>
 #include "LocalRegion.hpp"
 
 namespace apache {
@@ -114,7 +113,7 @@ class FarSideEntryOp {
   CacheableKeyPtr m_key;
   CacheablePtr m_value;
   bool m_didDestroy;
-  UserDataPtr m_callbackArg;
+  SerializablePtr m_callbackArg;
   VersionTagPtr m_versionTag;
   MemberListForVersionStamp& m_memberListForVersionStamp;
   // FilterRoutingInfo filterRoutingInfo;
diff --git a/cppcache/src/LocalRegion.cpp b/cppcache/src/LocalRegion.cpp
index 1f31cad..fdd1be3 100644
--- a/cppcache/src/LocalRegion.cpp
+++ b/cppcache/src/LocalRegion.cpp
@@ -138,25 +138,25 @@ CacheStatisticsPtr LocalRegion::getStatistics() const {
   return m_cacheStatistics;
 }
 
-void LocalRegion::invalidateRegion(const UserDataPtr& aCallbackArgument) {
+void LocalRegion::invalidateRegion(const SerializablePtr& aCallbackArgument) {
   GfErrType err =
       invalidateRegionNoThrow(aCallbackArgument, CacheEventFlags::NORMAL);
   GfErrTypeToException("Region::invalidateRegion", err);
 }
 
-void LocalRegion::localInvalidateRegion(const UserDataPtr& aCallbackArgument) {
+void LocalRegion::localInvalidateRegion(const SerializablePtr& aCallbackArgument) {
   GfErrType err =
       invalidateRegionNoThrow(aCallbackArgument, CacheEventFlags::LOCAL);
   GfErrTypeToException("Region::localInvalidateRegion", err);
 }
 
-void LocalRegion::destroyRegion(const UserDataPtr& aCallbackArgument) {
+void LocalRegion::destroyRegion(const SerializablePtr& aCallbackArgument) {
   GfErrType err =
       destroyRegionNoThrow(aCallbackArgument, true, CacheEventFlags::NORMAL);
   GfErrTypeToException("Region::destroyRegion", err);
 }
 
-void LocalRegion::localDestroyRegion(const UserDataPtr& aCallbackArgument) {
+void LocalRegion::localDestroyRegion(const SerializablePtr& aCallbackArgument) {
   GfErrType err =
       destroyRegionNoThrow(aCallbackArgument, true, CacheEventFlags::LOCAL);
   GfErrTypeToException("Region::localDestroyRegion", err);
@@ -309,7 +309,7 @@ void LocalRegion::getEntry(const CacheableKeyPtr& key, CacheablePtr& valuePtr) {
 }
 
 CacheablePtr LocalRegion::get(const CacheableKeyPtr& key,
-                              const UserDataPtr& aCallbackArgument) {
+                              const SerializablePtr& aCallbackArgument) {
   CacheablePtr rptr;
   int64_t sampleStartNanos = startStatOpTime();
   GfErrType err = getNoThrow(key, rptr, aCallbackArgument);
@@ -324,7 +324,7 @@ CacheablePtr LocalRegion::get(const CacheableKeyPtr& key,
 }
 
 void LocalRegion::put(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument) {
+                      const SerializablePtr& aCallbackArgument) {
   CacheablePtr oldValue;
   int64_t sampleStartNanos = startStatOpTime();
   VersionTagPtr versionTag;
@@ -338,7 +338,7 @@ void LocalRegion::put(const CacheableKeyPtr& key, const CacheablePtr& value,
 
 void LocalRegion::localPut(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument) {
+                           const SerializablePtr& aCallbackArgument) {
   CacheablePtr oldValue;
   VersionTagPtr versionTag;
   GfErrType err = putNoThrow(key, value, aCallbackArgument, oldValue, -1,
@@ -347,7 +347,7 @@ void LocalRegion::localPut(const CacheableKeyPtr& key,
 }
 
 void LocalRegion::putAll(const HashMapOfCacheable& map, uint32_t timeout,
-                         const UserDataPtr& aCallbackArgument) {
+                         const SerializablePtr& aCallbackArgument) {
   if ((timeout * 1000) >= 0x7fffffff) {
     throw IllegalArgumentException(
         "Region::putAll: timeout parameter "
@@ -362,7 +362,7 @@ void LocalRegion::putAll(const HashMapOfCacheable& map, uint32_t timeout,
 }
 
 void LocalRegion::removeAll(const VectorOfCacheableKey& keys,
-                            const UserDataPtr& aCallbackArgument) {
+                            const SerializablePtr& aCallbackArgument) {
   if (keys.size() == 0) {
     throw IllegalArgumentException("Region::removeAll: zero keys provided");
   }
@@ -374,7 +374,7 @@ void LocalRegion::removeAll(const VectorOfCacheableKey& keys,
 }
 
 void LocalRegion::create(const CacheableKeyPtr& key, const CacheablePtr& value,
-                         const UserDataPtr& aCallbackArgument) {
+                         const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = createNoThrow(key, value, aCallbackArgument, -1,
                                 CacheEventFlags::NORMAL, versionTag);
@@ -384,7 +384,7 @@ void LocalRegion::create(const CacheableKeyPtr& key, const CacheablePtr& value,
 
 void LocalRegion::localCreate(const CacheableKeyPtr& key,
                               const CacheablePtr& value,
-                              const UserDataPtr& aCallbackArgument) {
+                              const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = createNoThrow(key, value, aCallbackArgument, -1,
                                 CacheEventFlags::LOCAL, versionTag);
@@ -392,7 +392,7 @@ void LocalRegion::localCreate(const CacheableKeyPtr& key,
 }
 
 void LocalRegion::invalidate(const CacheableKeyPtr& key,
-                             const UserDataPtr& aCallbackArgument) {
+                             const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = invalidateNoThrow(key, aCallbackArgument, -1,
                                     CacheEventFlags::NORMAL, versionTag);
@@ -401,7 +401,7 @@ void LocalRegion::invalidate(const CacheableKeyPtr& key,
 }
 
 void LocalRegion::localInvalidate(const CacheableKeyPtr& keyPtr,
-                                  const UserDataPtr& aCallbackArgument) {
+                                  const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = invalidateNoThrow(keyPtr, aCallbackArgument, -1,
                                     CacheEventFlags::LOCAL, versionTag);
@@ -409,7 +409,7 @@ void LocalRegion::localInvalidate(const CacheableKeyPtr& keyPtr,
 }
 
 void LocalRegion::destroy(const CacheableKeyPtr& key,
-                          const UserDataPtr& aCallbackArgument) {
+                          const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
 
   GfErrType err = destroyNoThrow(key, aCallbackArgument, -1,
@@ -419,7 +419,7 @@ void LocalRegion::destroy(const CacheableKeyPtr& key,
 }
 
 void LocalRegion::localDestroy(const CacheableKeyPtr& key,
-                               const UserDataPtr& aCallbackArgument) {
+                               const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = destroyNoThrow(key, aCallbackArgument, -1,
                                  CacheEventFlags::LOCAL, versionTag);
@@ -427,7 +427,7 @@ void LocalRegion::localDestroy(const CacheableKeyPtr& key,
 }
 
 bool LocalRegion::remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                         const UserDataPtr& aCallbackArgument) {
+                         const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = removeNoThrow(key, value, aCallbackArgument, -1,
                                 CacheEventFlags::NORMAL, versionTag);
@@ -444,7 +444,7 @@ bool LocalRegion::remove(const CacheableKeyPtr& key, const CacheablePtr& value,
 }
 
 bool LocalRegion::removeEx(const CacheableKeyPtr& key,
-                           const UserDataPtr& aCallbackArgument) {
+                           const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = removeNoThrowEx(key, aCallbackArgument, -1,
                                   CacheEventFlags::NORMAL, versionTag);
@@ -461,7 +461,7 @@ bool LocalRegion::removeEx(const CacheableKeyPtr& key,
 
 bool LocalRegion::localRemove(const CacheableKeyPtr& key,
                               const CacheablePtr& value,
-                              const UserDataPtr& aCallbackArgument) {
+                              const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = removeNoThrow(key, value, aCallbackArgument, -1,
                                 CacheEventFlags::LOCAL, versionTag);
@@ -478,7 +478,7 @@ bool LocalRegion::localRemove(const CacheableKeyPtr& key,
 }
 
 bool LocalRegion::localRemoveEx(const CacheableKeyPtr& key,
-                                const UserDataPtr& aCallbackArgument) {
+                                const SerializablePtr& aCallbackArgument) {
   VersionTagPtr versionTag;
   GfErrType err = removeNoThrowEx(key, aCallbackArgument, -1,
                                   CacheEventFlags::LOCAL, versionTag);
@@ -528,7 +528,7 @@ void LocalRegion::entries(VectorOfRegionEntry& me, bool recursive) {
 void LocalRegion::getAll(const VectorOfCacheableKey& keys,
                          HashMapOfCacheablePtr values,
                          HashMapOfExceptionPtr exceptions, bool addToLocalCache,
-                         const UserDataPtr& aCallbackArgument) {
+                         const SerializablePtr& aCallbackArgument) {
   if (keys.size() == 0) {
     throw IllegalArgumentException("Region::getAll: zero keys provided");
   }
@@ -787,7 +787,7 @@ void LocalRegion::subregions_internal(const bool recursive,
 
 GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
                                   CacheablePtr& value,
-                                  const UserDataPtr& aCallbackArgument) {
+                                  const SerializablePtr& aCallbackArgument) {
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
   GfErrType err = GF_NOERR;
 
@@ -967,7 +967,7 @@ GfErrType LocalRegion::getAllNoThrow(const VectorOfCacheableKey& keys,
                                      const HashMapOfCacheablePtr& values,
                                      const HashMapOfExceptionPtr& exceptions,
                                      bool addToLocalCache,
-                                     const UserDataPtr& aCallbackArgument) {
+                                     const SerializablePtr& aCallbackArgument) {
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
   GfErrType err = GF_NOERR;
   CacheablePtr value;
@@ -1087,7 +1087,7 @@ class PutActions {
 
   inline GfErrType remoteUpdate(const CacheableKeyPtr& key,
                                 const CacheablePtr& value,
-                                const UserDataPtr& aCallbackArgument,
+                                const SerializablePtr& aCallbackArgument,
                                 VersionTagPtr& versionTag) {
     //    	if(m_txState != nullptr && !m_txState->isReplay())
     //    	{
@@ -1172,7 +1172,7 @@ class CreateActions {
 
   inline GfErrType remoteUpdate(const CacheableKeyPtr& key,
                                 const CacheablePtr& value,
-                                const UserDataPtr& aCallbackArgument,
+                                const SerializablePtr& aCallbackArgument,
                                 VersionTagPtr& versionTag) {
     // propagate the create to remote server, if any
     //  	  if(m_txState != nullptr && !m_txState->isReplay())
@@ -1244,7 +1244,7 @@ class DestroyActions {
 
   inline GfErrType remoteUpdate(const CacheableKeyPtr& key,
                                 const CacheablePtr& value,
-                                const UserDataPtr& aCallbackArgument,
+                                const SerializablePtr& aCallbackArgument,
                                 VersionTagPtr& versionTag) {
     // propagate the destroy to remote server, if any
     //    	if(m_txState != nullptr && !m_txState->isReplay())
@@ -1364,7 +1364,7 @@ class RemoveActions {
 
   inline GfErrType remoteUpdate(const CacheableKeyPtr& key,
                                 const CacheablePtr& value,
-                                const UserDataPtr& aCallbackArgument,
+                                const SerializablePtr& aCallbackArgument,
                                 VersionTagPtr& versionTag) {
     // propagate the remove to remote server, if any
     CacheablePtr valuePtr;
@@ -1590,7 +1590,7 @@ class InvalidateActions {
 
   inline GfErrType remoteUpdate(const CacheableKeyPtr& key,
                                 const CacheablePtr& value,
-                                const UserDataPtr& aCallbackArgument,
+                                const SerializablePtr& aCallbackArgument,
                                 VersionTagPtr& versionTag) {
     //    	if(m_txState != nullptr && !m_txState->isReplay())
     //    	{
@@ -1622,7 +1622,7 @@ class InvalidateActions {
 template <typename TAction>
 GfErrType LocalRegion::updateNoThrow(const CacheableKeyPtr& key,
                                      const CacheablePtr& value,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      CacheablePtr& oldValue, int updateCount,
                                      const CacheEventFlags eventFlags,
                                      VersionTagPtr versionTag, DataInput* delta,
@@ -1764,7 +1764,7 @@ GfErrType LocalRegion::updateNoThrow(const CacheableKeyPtr& key,
 template <typename TAction>
 GfErrType LocalRegion::updateNoThrowTX(const CacheableKeyPtr& key,
                                        const CacheablePtr& value,
-                                       const UserDataPtr& aCallbackArgument,
+                                       const SerializablePtr& aCallbackArgument,
                                        CacheablePtr& oldValue, int updateCount,
                                        const CacheEventFlags eventFlags,
                                        VersionTagPtr versionTag,
@@ -1820,7 +1820,7 @@ GfErrType LocalRegion::updateNoThrowTX(const CacheableKeyPtr& key,
 
 GfErrType LocalRegion::putNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
-                                  const UserDataPtr& aCallbackArgument,
+                                  const SerializablePtr& aCallbackArgument,
                                   CacheablePtr& oldValue, int updateCount,
                                   const CacheEventFlags eventFlags,
                                   VersionTagPtr versionTag, DataInput* delta,
@@ -1832,7 +1832,7 @@ GfErrType LocalRegion::putNoThrow(const CacheableKeyPtr& key,
 
 GfErrType LocalRegion::putNoThrowTX(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
-                                    const UserDataPtr& aCallbackArgument,
+                                    const SerializablePtr& aCallbackArgument,
                                     CacheablePtr& oldValue, int updateCount,
                                     const CacheEventFlags eventFlags,
                                     VersionTagPtr versionTag, DataInput* delta,
@@ -1844,7 +1844,7 @@ GfErrType LocalRegion::putNoThrowTX(const CacheableKeyPtr& key,
 
 GfErrType LocalRegion::createNoThrow(const CacheableKeyPtr& key,
                                      const CacheablePtr& value,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      int updateCount,
                                      const CacheEventFlags eventFlags,
                                      VersionTagPtr versionTag) {
@@ -1854,7 +1854,7 @@ GfErrType LocalRegion::createNoThrow(const CacheableKeyPtr& key,
 }
 
 GfErrType LocalRegion::destroyNoThrow(const CacheableKeyPtr& key,
-                                      const UserDataPtr& aCallbackArgument,
+                                      const SerializablePtr& aCallbackArgument,
                                       int updateCount,
                                       const CacheEventFlags eventFlags,
                                       VersionTagPtr versionTag) {
@@ -1865,7 +1865,7 @@ GfErrType LocalRegion::destroyNoThrow(const CacheableKeyPtr& key,
 }
 
 GfErrType LocalRegion::destroyNoThrowTX(const CacheableKeyPtr& key,
-                                        const UserDataPtr& aCallbackArgument,
+                                        const SerializablePtr& aCallbackArgument,
                                         int updateCount,
                                         const CacheEventFlags eventFlags,
                                         VersionTagPtr versionTag) {
@@ -1877,7 +1877,7 @@ GfErrType LocalRegion::destroyNoThrowTX(const CacheableKeyPtr& key,
 
 GfErrType LocalRegion::removeNoThrow(const CacheableKeyPtr& key,
                                      const CacheablePtr& value,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      int updateCount,
                                      const CacheEventFlags eventFlags,
                                      VersionTagPtr versionTag) {
@@ -1887,7 +1887,7 @@ GfErrType LocalRegion::removeNoThrow(const CacheableKeyPtr& key,
 }
 
 GfErrType LocalRegion::removeNoThrowEx(const CacheableKeyPtr& key,
-                                       const UserDataPtr& aCallbackArgument,
+                                       const SerializablePtr& aCallbackArgument,
                                        int updateCount,
                                        const CacheEventFlags eventFlags,
                                        VersionTagPtr versionTag) {
@@ -1898,7 +1898,7 @@ GfErrType LocalRegion::removeNoThrowEx(const CacheableKeyPtr& key,
 }
 
 GfErrType LocalRegion::invalidateNoThrow(const CacheableKeyPtr& key,
-                                         const UserDataPtr& aCallbackArgument,
+                                         const SerializablePtr& aCallbackArgument,
                                          int updateCount,
                                          const CacheEventFlags eventFlags,
                                          VersionTagPtr versionTag) {
@@ -1909,7 +1909,7 @@ GfErrType LocalRegion::invalidateNoThrow(const CacheableKeyPtr& key,
 }
 
 GfErrType LocalRegion::invalidateNoThrowTX(const CacheableKeyPtr& key,
-                                           const UserDataPtr& aCallbackArgument,
+                                           const SerializablePtr& aCallbackArgument,
                                            int updateCount,
                                            const CacheEventFlags eventFlags,
                                            VersionTagPtr versionTag) {
@@ -1921,7 +1921,7 @@ GfErrType LocalRegion::invalidateNoThrowTX(const CacheableKeyPtr& key,
 
 GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
                                      uint32_t timeout,
-                                     const UserDataPtr& aCallbackArgument) {
+                                     const SerializablePtr& aCallbackArgument) {
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
   GfErrType err = GF_NOERR;
   // VersionTagPtr versionTag;
@@ -2097,7 +2097,7 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
 }
 
 GfErrType LocalRegion::removeAllNoThrow(const VectorOfCacheableKey& keys,
-                                        const UserDataPtr& aCallbackArgument) {
+                                        const SerializablePtr& aCallbackArgument) {
   // 1. check destroy pending
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
   GfErrType err = GF_NOERR;
@@ -2179,18 +2179,18 @@ GfErrType LocalRegion::removeAllNoThrow(const VectorOfCacheableKey& keys,
   return err;
 }
 
-void LocalRegion::clear(const UserDataPtr& aCallbackArgument) {
+void LocalRegion::clear(const SerializablePtr& aCallbackArgument) {
   /*update the stats */
   int64_t sampleStartNanos = startStatOpTime();
   localClear(aCallbackArgument);
   updateStatOpTime(m_regionStats->getStat(), m_regionStats->getClearsId(),
                    sampleStartNanos);
 }
-void LocalRegion::localClear(const UserDataPtr& aCallbackArgument) {
+void LocalRegion::localClear(const SerializablePtr& aCallbackArgument) {
   GfErrType err = localClearNoThrow(aCallbackArgument, CacheEventFlags::LOCAL);
   if (err != GF_NOERR) GfErrTypeToException("LocalRegion::localClear", err);
 }
-GfErrType LocalRegion::localClearNoThrow(const UserDataPtr& aCallbackArgument,
+GfErrType LocalRegion::localClearNoThrow(const SerializablePtr& aCallbackArgument,
                                          const CacheEventFlags eventFlags) {
   bool cachingEnabled = m_regionAttributes->getCachingEnabled();
   /*Update the stats for clear*/
@@ -2278,7 +2278,7 @@ GfErrType LocalRegion::invalidateLocal(const char* name,
 }
 
 GfErrType LocalRegion::invalidateRegionNoThrow(
-    const UserDataPtr& aCallbackArgument, const CacheEventFlags eventFlags) {
+    const SerializablePtr& aCallbackArgument, const CacheEventFlags eventFlags) {
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
   GfErrType err = GF_NOERR;
 
@@ -2330,7 +2330,7 @@ GfErrType LocalRegion::invalidateRegionNoThrow(
 }
 
 GfErrType LocalRegion::destroyRegionNoThrow(
-    const UserDataPtr& aCallbackArgument, bool removeFromParent,
+    const SerializablePtr& aCallbackArgument, bool removeFromParent,
     const CacheEventFlags eventFlags) {
   // Get global locks to synchronize with failover thread.
   // TODO:  This should go into RegionGlobalLocks
@@ -2553,7 +2553,7 @@ int LocalRegion::removeRegion(const std::string& name) {
 
 bool LocalRegion::invokeCacheWriterForEntryEvent(
     const CacheableKeyPtr& key, CacheablePtr& oldValue,
-    const CacheablePtr& newValue, const UserDataPtr& aCallbackArgument,
+    const CacheablePtr& newValue, const SerializablePtr& aCallbackArgument,
     CacheEventFlags eventFlags, EntryEventType type) {
   // Check if we have a local cache writer. If so, invoke and return.
   bool bCacheWriterReturn = true;
@@ -2613,7 +2613,7 @@ bool LocalRegion::invokeCacheWriterForEntryEvent(
 }
 
 bool LocalRegion::invokeCacheWriterForRegionEvent(
-    const UserDataPtr& aCallbackArgument, CacheEventFlags eventFlags,
+    const SerializablePtr& aCallbackArgument, CacheEventFlags eventFlags,
     RegionEventType type) {
   // Check if we have a local cache writer. If so, invoke and return.
   bool bCacheWriterReturn = true;
@@ -2661,7 +2661,7 @@ bool LocalRegion::invokeCacheWriterForRegionEvent(
 
 GfErrType LocalRegion::invokeCacheListenerForEntryEvent(
     const CacheableKeyPtr& key, CacheablePtr& oldValue,
-    const CacheablePtr& newValue, const UserDataPtr& aCallbackArgument,
+    const CacheablePtr& newValue, const SerializablePtr& aCallbackArgument,
     CacheEventFlags eventFlags, EntryEventType type, bool isLocal) {
   GfErrType err = GF_NOERR;
 
@@ -2731,7 +2731,7 @@ GfErrType LocalRegion::invokeCacheListenerForEntryEvent(
 }
 
 GfErrType LocalRegion::invokeCacheListenerForRegionEvent(
-    const UserDataPtr& aCallbackArgument, CacheEventFlags eventFlags,
+    const SerializablePtr& aCallbackArgument, CacheEventFlags eventFlags,
     RegionEventType type) {
   GfErrType err = GF_NOERR;
 
@@ -2995,14 +2995,14 @@ GfErrType LocalRegion::unregisterKeysBeforeDestroyRegion() { return GF_NOERR; }
 
 GfErrType LocalRegion::getNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                          CacheablePtr& valPtr,
-                                         const UserDataPtr& aCallbackArgument,
+                                         const SerializablePtr& aCallbackArgument,
                                          VersionTagPtr& versionTag) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::putNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                          const CacheablePtr& cvalue,
-                                         const UserDataPtr& aCallbackArgument,
+                                         const SerializablePtr& aCallbackArgument,
                                          VersionTagPtr& versionTag,
                                          bool checkDelta) {
   return GF_NOERR;
@@ -3011,43 +3011,43 @@ GfErrType LocalRegion::putNoThrow_remote(const CacheableKeyPtr& keyPtr,
 GfErrType LocalRegion::putAllNoThrow_remote(
     const HashMapOfCacheable& map,
     VersionedCacheableObjectPartListPtr& putAllResponse, uint32_t timeout,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::removeAllNoThrow_remote(
     const VectorOfCacheableKey& keys,
     VersionedCacheableObjectPartListPtr& versionedObjPartList,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::createNoThrow_remote(
     const CacheableKeyPtr& keyPtr, const CacheablePtr& cvalue,
-    const UserDataPtr& aCallbackArgument, VersionTagPtr& versionTag) {
+    const SerializablePtr& aCallbackArgument, VersionTagPtr& versionTag) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::destroyNoThrow_remote(
-    const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
     VersionTagPtr& versionTag) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::removeNoThrow_remote(
     const CacheableKeyPtr& keyPtr, const CacheablePtr& cvalue,
-    const UserDataPtr& aCallbackArgument, VersionTagPtr& versionTag) {
+    const SerializablePtr& aCallbackArgument, VersionTagPtr& versionTag) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::removeNoThrowEX_remote(
-    const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
     VersionTagPtr& versionTag) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::invalidateNoThrow_remote(
-    const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
     VersionTagPtr& versionTag) {
   return GF_NOERR;
 }
@@ -3056,17 +3056,17 @@ GfErrType LocalRegion::getAllNoThrow_remote(
     const VectorOfCacheableKey* keys, const HashMapOfCacheablePtr& values,
     const HashMapOfExceptionPtr& exceptions,
     const VectorOfCacheableKeyPtr& resultKeys, bool addToLocalCache,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::invalidateRegionNoThrow_remote(
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   return GF_NOERR;
 }
 
 GfErrType LocalRegion::destroyRegionNoThrow_remote(
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   return GF_NOERR;
 }
 
diff --git a/cppcache/src/LocalRegion.hpp b/cppcache/src/LocalRegion.hpp
index fee2518..b37d977 100644
--- a/cppcache/src/LocalRegion.hpp
+++ b/cppcache/src/LocalRegion.hpp
@@ -29,7 +29,6 @@
 #include <geode/ExceptionTypes.hpp>
 #include <geode/CacheableKey.hpp>
 #include <geode/Cacheable.hpp>
-#include <geode/UserData.hpp>
 #include <geode/Cache.hpp>
 #include <geode/EntryEvent.hpp>
 #include <geode/RegionEvent.hpp>
@@ -146,15 +145,15 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   }
   void updateAccessAndModifiedTime(bool modified);
   CacheStatisticsPtr getStatistics() const;
-  virtual void clear(const UserDataPtr& aCallbackArgument = nullptr);
-  virtual void localClear(const UserDataPtr& aCallbackArgument = nullptr);
+  virtual void clear(const SerializablePtr& aCallbackArgument = nullptr);
+  virtual void localClear(const SerializablePtr& aCallbackArgument = nullptr);
   GfErrType localClearNoThrow(
-      const UserDataPtr& aCallbackArgument = nullptr,
+      const SerializablePtr& aCallbackArgument = nullptr,
       const CacheEventFlags eventFlags = CacheEventFlags::NORMAL);
-  void invalidateRegion(const UserDataPtr& aCallbackArgument = nullptr);
-  void localInvalidateRegion(const UserDataPtr& aCallbackArgument = nullptr);
-  void destroyRegion(const UserDataPtr& aCallbackArgument = nullptr);
-  void localDestroyRegion(const UserDataPtr& aCallbackArgument = nullptr);
+  void invalidateRegion(const SerializablePtr& aCallbackArgument = nullptr);
+  void localInvalidateRegion(const SerializablePtr& aCallbackArgument = nullptr);
+  void destroyRegion(const SerializablePtr& aCallbackArgument = nullptr);
+  void localDestroyRegion(const SerializablePtr& aCallbackArgument = nullptr);
   RegionPtr getSubregion(const char* path);
   RegionPtr createSubregion(const char* subregionName,
                             const RegionAttributesPtr& aRegionAttributes);
@@ -162,43 +161,43 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   RegionEntryPtr getEntry(const CacheableKeyPtr& key);
   void getEntry(const CacheableKeyPtr& key, CacheablePtr& valuePtr);
   CacheablePtr get(const CacheableKeyPtr& key,
-                   const UserDataPtr& aCallbackArgument);
+                   const SerializablePtr& aCallbackArgument);
   void put(const CacheableKeyPtr& key, const CacheablePtr& value,
-           const UserDataPtr& aCallbackArgument = nullptr);
+           const SerializablePtr& aCallbackArgument = nullptr);
   void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                const UserDataPtr& aCallbackArgument = nullptr);
+                const SerializablePtr& aCallbackArgument = nullptr);
   void create(const CacheableKeyPtr& key, const CacheablePtr& value,
-              const UserDataPtr& aCallbackArgument = nullptr);
+              const SerializablePtr& aCallbackArgument = nullptr);
   void localCreate(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = nullptr);
+                   const SerializablePtr& aCallbackArgument = nullptr);
   void invalidate(const CacheableKeyPtr& key,
-                  const UserDataPtr& aCallbackArgument = nullptr);
+                  const SerializablePtr& aCallbackArgument = nullptr);
   void localInvalidate(const CacheableKeyPtr& key,
-                       const UserDataPtr& aCallbackArgument = nullptr);
+                       const SerializablePtr& aCallbackArgument = nullptr);
   void destroy(const CacheableKeyPtr& key,
-               const UserDataPtr& aCallbackArgument = nullptr);
+               const SerializablePtr& aCallbackArgument = nullptr);
   void localDestroy(const CacheableKeyPtr& key,
-                    const UserDataPtr& aCallbackArgument = nullptr);
+                    const SerializablePtr& aCallbackArgument = nullptr);
   bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-              const UserDataPtr& aCallbackArgument = nullptr);
+              const SerializablePtr& aCallbackArgument = nullptr);
   bool removeEx(const CacheableKeyPtr& key,
-                const UserDataPtr& aCallbackArgument = nullptr);
+                const SerializablePtr& aCallbackArgument = nullptr);
   bool localRemove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = nullptr);
+                   const SerializablePtr& aCallbackArgument = nullptr);
   bool localRemoveEx(const CacheableKeyPtr& key,
-                     const UserDataPtr& aCallbackArgument = nullptr);
+                     const SerializablePtr& aCallbackArgument = nullptr);
   void keys(VectorOfCacheableKey& v);
   void serverKeys(VectorOfCacheableKey& v);
   void values(VectorOfCacheable& vc);
   void entries(VectorOfRegionEntry& me, bool recursive);
   void getAll(const VectorOfCacheableKey& keys, HashMapOfCacheablePtr values,
               HashMapOfExceptionPtr exceptions, bool addToLocalCache,
-              const UserDataPtr& aCallbackArgument = nullptr);
+              const SerializablePtr& aCallbackArgument = nullptr);
   void putAll(const HashMapOfCacheable& map,
               uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-              const UserDataPtr& aCallbackArgument = nullptr);
+              const SerializablePtr& aCallbackArgument = nullptr);
   void removeAll(const VectorOfCacheableKey& keys,
-                 const UserDataPtr& aCallbackArgument = nullptr);
+                 const SerializablePtr& aCallbackArgument = nullptr);
   uint32_t size();
   virtual uint32_t size_remote();
   RegionServicePtr getRegionService() const;
@@ -216,14 +215,14 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   void setPersistenceManager(PersistenceManagerPtr& pmPtr);
 
   virtual GfErrType getNoThrow(const CacheableKeyPtr& key, CacheablePtr& value,
-                               const UserDataPtr& aCallbackArgument);
+                               const SerializablePtr& aCallbackArgument);
   virtual GfErrType getAllNoThrow(
       const VectorOfCacheableKey& keys, const HashMapOfCacheablePtr& values,
       const HashMapOfExceptionPtr& exceptions, bool addToLocalCache,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   virtual GfErrType putNoThrow(const CacheableKeyPtr& key,
                                const CacheablePtr& value,
-                               const UserDataPtr& aCallbackArgument,
+                               const SerializablePtr& aCallbackArgument,
                                CacheablePtr& oldValue, int updateCount,
                                const CacheEventFlags eventFlags,
                                VersionTagPtr versionTag,
@@ -231,7 +230,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                                EventIdPtr eventId = nullptr);
   virtual GfErrType putNoThrowTX(const CacheableKeyPtr& key,
                                  const CacheablePtr& value,
-                                 const UserDataPtr& aCallbackArgument,
+                                 const SerializablePtr& aCallbackArgument,
                                  CacheablePtr& oldValue, int updateCount,
                                  const CacheEventFlags eventFlags,
                                  VersionTagPtr versionTag,
@@ -239,51 +238,51 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                                  EventIdPtr eventId = nullptr);
   virtual GfErrType createNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
-                                  const UserDataPtr& aCallbackArgument,
+                                  const SerializablePtr& aCallbackArgument,
                                   int updateCount,
                                   const CacheEventFlags eventFlags,
                                   VersionTagPtr versionTag);
   virtual GfErrType destroyNoThrow(const CacheableKeyPtr& key,
-                                   const UserDataPtr& aCallbackArgument,
+                                   const SerializablePtr& aCallbackArgument,
                                    int updateCount,
                                    const CacheEventFlags eventFlags,
                                    VersionTagPtr versionTag);
   virtual GfErrType destroyNoThrowTX(const CacheableKeyPtr& key,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      int updateCount,
                                      const CacheEventFlags eventFlags,
                                      VersionTagPtr versionTag);
   virtual GfErrType removeNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
-                                  const UserDataPtr& aCallbackArgument,
+                                  const SerializablePtr& aCallbackArgument,
                                   int updateCount,
                                   const CacheEventFlags eventFlags,
                                   VersionTagPtr versionTag);
   virtual GfErrType removeNoThrowEx(const CacheableKeyPtr& key,
-                                    const UserDataPtr& aCallbackArgument,
+                                    const SerializablePtr& aCallbackArgument,
                                     int updateCount,
                                     const CacheEventFlags eventFlags,
                                     VersionTagPtr versionTag);
   virtual GfErrType putAllNoThrow(
       const HashMapOfCacheable& map,
       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   virtual GfErrType removeAllNoThrow(
       const VectorOfCacheableKey& keys,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   virtual GfErrType invalidateNoThrow(const CacheableKeyPtr& keyPtr,
-                                      const UserDataPtr& aCallbackArgument,
+                                      const SerializablePtr& aCallbackArgument,
                                       int updateCount,
                                       const CacheEventFlags eventFlags,
                                       VersionTagPtr versionTag);
   virtual GfErrType invalidateNoThrowTX(const CacheableKeyPtr& keyPtr,
-                                        const UserDataPtr& aCallbackArgument,
+                                        const SerializablePtr& aCallbackArgument,
                                         int updateCount,
                                         const CacheEventFlags eventFlags,
                                         VersionTagPtr versionTag);
-  GfErrType invalidateRegionNoThrow(const UserDataPtr& aCallbackArgument,
+  GfErrType invalidateRegionNoThrow(const SerializablePtr& aCallbackArgument,
                                     const CacheEventFlags eventFlags);
-  GfErrType destroyRegionNoThrow(const UserDataPtr& aCallbackArgument,
+  GfErrType destroyRegionNoThrow(const SerializablePtr& aCallbackArgument,
                                  bool removeFromParent,
                                  const CacheEventFlags eventFlags);
   void tombstoneOperationNoThrow(const CacheableHashMapPtr& tombstoneVersions,
@@ -349,47 +348,47 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   virtual void release(bool invokeCallbacks = true);
   virtual GfErrType getNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                       CacheablePtr& valPtr,
-                                      const UserDataPtr& aCallbackArgument,
+                                      const SerializablePtr& aCallbackArgument,
                                       VersionTagPtr& versionTag);
   virtual GfErrType putNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                       const CacheablePtr& cvalue,
-                                      const UserDataPtr& aCallbackArgument,
+                                      const SerializablePtr& aCallbackArgument,
                                       VersionTagPtr& versionTag,
                                       bool checkDelta = true);
   virtual GfErrType putAllNoThrow_remote(
       const HashMapOfCacheable& map,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
-      uint32_t timeout, const UserDataPtr& aCallbackArgument);
+      uint32_t timeout, const SerializablePtr& aCallbackArgument);
   virtual GfErrType removeAllNoThrow_remote(
       const VectorOfCacheableKey& keys,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
-      const UserDataPtr& aCallbackArgument);
+      const SerializablePtr& aCallbackArgument);
   virtual GfErrType createNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                          const CacheablePtr& cvalue,
-                                         const UserDataPtr& aCallbackArgument,
+                                         const SerializablePtr& aCallbackArgument,
                                          VersionTagPtr& versionTag);
   virtual GfErrType destroyNoThrow_remote(const CacheableKeyPtr& keyPtr,
-                                          const UserDataPtr& aCallbackArgument,
+                                          const SerializablePtr& aCallbackArgument,
                                           VersionTagPtr& versionTag);
   virtual GfErrType removeNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                          const CacheablePtr& cvalue,
-                                         const UserDataPtr& aCallbackArgument,
+                                         const SerializablePtr& aCallbackArgument,
                                          VersionTagPtr& versionTag);
   virtual GfErrType removeNoThrowEX_remote(const CacheableKeyPtr& keyPtr,
-                                           const UserDataPtr& aCallbackArgument,
+                                           const SerializablePtr& aCallbackArgument,
                                            VersionTagPtr& versionTag);
   virtual GfErrType invalidateNoThrow_remote(
-      const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+      const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
       VersionTagPtr& versionTag);
   virtual GfErrType getAllNoThrow_remote(
       const VectorOfCacheableKey* keys, const HashMapOfCacheablePtr& values,
       const HashMapOfExceptionPtr& exceptions,
       const VectorOfCacheableKeyPtr& resultKeys, bool addToLocalCache,
-      const UserDataPtr& aCallbackArgument);
+      const SerializablePtr& aCallbackArgument);
   virtual GfErrType invalidateRegionNoThrow_remote(
-      const UserDataPtr& aCallbackArgument);
+      const SerializablePtr& aCallbackArgument);
   virtual GfErrType destroyRegionNoThrow_remote(
-      const UserDataPtr& aCallbackArgument);
+      const SerializablePtr& aCallbackArgument);
   virtual GfErrType unregisterKeysBeforeDestroyRegion();
   virtual const PoolPtr& getPool() { return m_attachedPool; }
 
@@ -409,7 +408,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   // template method for put and create
   template <typename TAction>
   GfErrType updateNoThrow(const CacheableKeyPtr& key, const CacheablePtr& value,
-                          const UserDataPtr& aCallbackArgument,
+                          const SerializablePtr& aCallbackArgument,
                           CacheablePtr& oldValue, int updateCount,
                           const CacheEventFlags eventFlags,
                           VersionTagPtr versionTag, DataInput* delta = nullptr,
@@ -418,7 +417,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   template <typename TAction>
   GfErrType updateNoThrowTX(const CacheableKeyPtr& key,
                             const CacheablePtr& value,
-                            const UserDataPtr& aCallbackArgument,
+                            const SerializablePtr& aCallbackArgument,
                             CacheablePtr& oldValue, int updateCount,
                             const CacheEventFlags eventFlags,
                             VersionTagPtr versionTag,
@@ -457,18 +456,18 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   bool invokeCacheWriterForEntryEvent(const CacheableKeyPtr& key,
                                       CacheablePtr& oldValue,
                                       const CacheablePtr& newValue,
-                                      const UserDataPtr& aCallbackArgument,
+                                      const SerializablePtr& aCallbackArgument,
                                       CacheEventFlags eventFlags,
                                       EntryEventType type);
-  bool invokeCacheWriterForRegionEvent(const UserDataPtr& aCallbackArgument,
+  bool invokeCacheWriterForRegionEvent(const SerializablePtr& aCallbackArgument,
                                        CacheEventFlags eventFlags,
                                        RegionEventType type);
   GfErrType invokeCacheListenerForEntryEvent(
       const CacheableKeyPtr& key, CacheablePtr& oldValue,
-      const CacheablePtr& newValue, const UserDataPtr& aCallbackArgument,
+      const CacheablePtr& newValue, const SerializablePtr& aCallbackArgument,
       CacheEventFlags eventFlags, EntryEventType type, bool isLocal = false);
   GfErrType invokeCacheListenerForRegionEvent(
-      const UserDataPtr& aCallbackArgument, CacheEventFlags eventFlags,
+      const SerializablePtr& aCallbackArgument, CacheEventFlags eventFlags,
       RegionEventType type);
   // functions related to expirations.
   void updateAccessAndModifiedTimeForEntry(MapEntryImplPtr& ptr, bool modified);
diff --git a/cppcache/src/ProxyRegion.hpp b/cppcache/src/ProxyRegion.hpp
index d4d5940..4361765 100644
--- a/cppcache/src/ProxyRegion.hpp
+++ b/cppcache/src/ProxyRegion.hpp
@@ -27,7 +27,6 @@
 #include <geode/CacheStatistics.hpp>
 #include <geode/ExceptionTypes.hpp>
 #include <geode/CacheableString.hpp>
-#include <geode/UserData.hpp>
 #include <geode/CacheableBuiltins.hpp>
 
 /**
@@ -113,7 +112,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * This operation is not distributed.
    */
   virtual void invalidateRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) {
+      const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.invalidateRegion()");
   }
 
@@ -137,7 +136,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
 
   */
   virtual void localInvalidateRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) {
+      const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localInvalidateRegion()");
   }
 
@@ -174,7 +173,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @throws TimeoutException if operation timed out
    * @see  invalidateRegion
    */
-  virtual void destroyRegion(const UserDataPtr& aCallbackArgument = nullptr) {
+  virtual void destroyRegion(const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->destroyRegion(aCallbackArgument);
   }
@@ -187,7 +186,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void clear(const UserDataPtr& aCallbackArgument = nullptr) {
+  virtual void clear(const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->clear(aCallbackArgument);
   }
@@ -199,7 +198,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void localClear(const UserDataPtr& aCallbackArgument = nullptr) {
+  virtual void localClear(const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("localClear()");
   }
 
@@ -223,7 +222,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see  localInvalidateRegion
    */
   virtual void localDestroyRegion(
-      const UserDataPtr& aCallbackArgument = nullptr) {
+      const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localDestroyRegion()");
   }
 
@@ -326,7 +325,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    *region
    **/
   virtual CacheablePtr get(const CacheableKeyPtr& key,
-                           const UserDataPtr& aCallbackArgument = nullptr) {
+                           const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     return m_realRegion->get(key, aCallbackArgument);
   }
@@ -334,7 +333,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline CacheablePtr get(const KEYTYPE& key,
-                          const UserDataPtr& callbackArg = nullptr) {
+                          const SerializablePtr& callbackArg = nullptr) {
     return get(createKey(key), callbackArg);
   }
 
@@ -381,7 +380,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @throws OutOfMemoryException if  not enoough memory for the value
    */
   virtual void put(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = nullptr) {
+                   const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     return m_realRegion->put(key, value, aCallbackArgument);
   }
@@ -389,21 +388,21 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void put(const KEYTYPE& key, const VALUETYPE& value,
-                  const UserDataPtr& arg = nullptr) {
+                  const SerializablePtr& arg = nullptr) {
     put(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void put(const KEYTYPE& key, const CacheablePtr& value,
-                  const UserDataPtr& arg = nullptr) {
+                  const SerializablePtr& arg = nullptr) {
     put(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void put(const CacheableKeyPtr& key, const VALUETYPE& value,
-                  const UserDataPtr& arg = nullptr) {
+                  const SerializablePtr& arg = nullptr) {
     put(key, createValue(value), arg);
   }
 
@@ -430,7 +429,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    */
   virtual void putAll(const HashMapOfCacheable& map,
                       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-                      const UserDataPtr& aCallbackArgument = nullptr) {
+                      const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     return m_realRegion->putAll(map, timeout, aCallbackArgument);
   }
@@ -460,28 +459,28 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @throws OutOfMemoryException if not enoough memory for the value
    */
   virtual void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                        const UserDataPtr& aCallbackArgument = nullptr) {
+                        const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localPut()");
   }
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
-                       const UserDataPtr& arg = nullptr) {
+                       const SerializablePtr& arg = nullptr) {
     localPut(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localPut(const KEYTYPE& key, const CacheablePtr& value,
-                       const UserDataPtr& arg = nullptr) {
+                       const SerializablePtr& arg = nullptr) {
     localPut(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void localPut(const CacheableKeyPtr& key, const VALUETYPE& value,
-                       const UserDataPtr& arg = nullptr) {
+                       const SerializablePtr& arg = nullptr) {
     localPut(key, createValue(value), arg);
   }
 
@@ -529,7 +528,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @throws EntryExistsException if an entry with this key already exists
    */
   virtual void create(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument = nullptr) {
+                      const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->create(key, value, aCallbackArgument);
   }
@@ -537,21 +536,21 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void create(const KEYTYPE& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     create(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void create(const KEYTYPE& key, const CacheablePtr& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     create(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void create(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     create(key, createValue(value), arg);
   }
 
@@ -582,28 +581,28 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    */
   virtual void localCreate(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument = nullptr) {
+                           const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localCreate()");
   }
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     localCreate(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localCreate(const KEYTYPE& key, const CacheablePtr& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     localCreate(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void localCreate(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     localCreate(key, createValue(value), arg);
   }
 
@@ -630,14 +629,14 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheListener::afterInvalidate
    */
   virtual void invalidate(const CacheableKeyPtr& key,
-                          const UserDataPtr& aCallbackArgument = nullptr) {
+                          const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->invalidate(key, aCallbackArgument);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void invalidate(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
+  inline void invalidate(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
     invalidate(createKey(key), arg);
   }
 
@@ -662,14 +661,14 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheListener::afterInvalidate
    */
   virtual void localInvalidate(const CacheableKeyPtr& key,
-                               const UserDataPtr& aCallbackArgument = nullptr) {
+                               const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localInvalidate()");
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localInvalidate(const KEYTYPE& key,
-                              const UserDataPtr& arg = nullptr) {
+                              const SerializablePtr& arg = nullptr) {
     localInvalidate(createKey(key), arg);
   }
 
@@ -716,14 +715,14 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheWriter::beforeDestroy
    */
   virtual void destroy(const CacheableKeyPtr& key,
-                       const UserDataPtr& aCallbackArgument = nullptr) {
+                       const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->destroy(key, aCallbackArgument);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void destroy(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
+  inline void destroy(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
     destroy(createKey(key), arg);
   }
 
@@ -752,14 +751,14 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheWriter::beforeDestroy
    */
   virtual void localDestroy(const CacheableKeyPtr& key,
-                            const UserDataPtr& aCallbackArgument = nullptr) {
+                            const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localDestroy()");
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localDestroy(const KEYTYPE& key,
-                           const UserDataPtr& arg = nullptr) {
+                           const SerializablePtr& arg = nullptr) {
     localDestroy(createKey(key), arg);
   }
 
@@ -812,7 +811,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheWriter::beforeDestroy
    */
   virtual bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument = nullptr) {
+                      const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     return m_realRegion->remove(key, value, aCallbackArgument);
   }
@@ -820,21 +819,21 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     return remove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool remove(const KEYTYPE& key, const CacheablePtr& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     return remove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline bool remove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = nullptr) {
+                     const SerializablePtr& arg = nullptr) {
     return remove(key, createValue(value), arg);
   }
 
@@ -886,14 +885,14 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    */
 
   virtual bool removeEx(const CacheableKeyPtr& key,
-                        const UserDataPtr& aCallbackArgument = nullptr) {
+                        const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     return m_realRegion->removeEx(key, aCallbackArgument);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool removeEx(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
+  inline bool removeEx(const KEYTYPE& key, const SerializablePtr& arg = nullptr) {
     return removeEx(createKey(key), arg);
   }
 
@@ -926,7 +925,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    */
   virtual bool localRemove(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument = nullptr) {
+                           const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localRemove()");
     return false;
   }
@@ -934,21 +933,21 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     return localRemove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool localRemove(const KEYTYPE& key, const CacheablePtr& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     return localRemove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline bool localRemove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = nullptr) {
+                          const SerializablePtr& arg = nullptr) {
     return localRemove(key, createValue(value), arg);
   }
 
@@ -978,7 +977,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see CacheWriter::beforeDestroy
    */
   virtual bool localRemoveEx(const CacheableKeyPtr& key,
-                             const UserDataPtr& aCallbackArgument = nullptr) {
+                             const SerializablePtr& aCallbackArgument = nullptr) {
     unSupportedOperation("Region.localRemoveEx()");
     return false;
   }
@@ -986,7 +985,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool localRemoveEx(const KEYTYPE& key,
-                            const UserDataPtr& arg = nullptr) {
+                            const SerializablePtr& arg = nullptr) {
     return localRemoveEx(createKey(key), arg);
   }
 
@@ -1362,7 +1361,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
                       HashMapOfCacheablePtr values,
                       HashMapOfExceptionPtr exceptions,
                       bool addToLocalCache = false,
-                      const UserDataPtr& aCallbackArgument = nullptr) {
+                      const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->getAll(keys, values, exceptions, false /*TODO:*/,
                          aCallbackArgument);
@@ -1482,7 +1481,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
    * @see destroy
    */
   virtual void removeAll(const VectorOfCacheableKey& keys,
-                         const UserDataPtr& aCallbackArgument = nullptr) {
+                         const SerializablePtr& aCallbackArgument = nullptr) {
     GuardUserAttribures gua(m_proxyCache);
     m_realRegion->removeAll(keys, aCallbackArgument);
   }
diff --git a/cppcache/src/RegionEvent.cpp b/cppcache/src/RegionEvent.cpp
index 73400a3..e872728 100644
--- a/cppcache/src/RegionEvent.cpp
+++ b/cppcache/src/RegionEvent.cpp
@@ -21,7 +21,7 @@ namespace geode {
 namespace client {
 
 RegionEvent::RegionEvent(const RegionPtr& region,
-                         const UserDataPtr& aCallbackArgument,
+                         const SerializablePtr& aCallbackArgument,
                          const bool remoteOrigin)
     : m_region(region),
       m_callbackArgument(aCallbackArgument),
diff --git a/cppcache/src/RegionInternal.cpp b/cppcache/src/RegionInternal.cpp
index 860acfe..5914c51 100644
--- a/cppcache/src/RegionInternal.cpp
+++ b/cppcache/src/RegionInternal.cpp
@@ -234,14 +234,14 @@ void RegionInternal::setClientNotificationEnabled(
 }
 
 void RegionInternal::txDestroy(const CacheableKeyPtr& key,
-                               const UserDataPtr& callBack,
+                               const SerializablePtr& callBack,
                                VersionTagPtr versionTag) {
   throw UnsupportedOperationException(
       "txDestroy only supported by Thin Client Region.");
 }
 
 void RegionInternal::txInvalidate(const CacheableKeyPtr& key,
-                                  const UserDataPtr& callBack,
+                                  const SerializablePtr& callBack,
                                   VersionTagPtr versionTag) {
   throw UnsupportedOperationException(
       "txInvalidate only supported by Thin Client Region.");
@@ -249,7 +249,7 @@ void RegionInternal::txInvalidate(const CacheableKeyPtr& key,
 
 void RegionInternal::txPut(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& callBack,
+                           const SerializablePtr& callBack,
                            VersionTagPtr versionTag) {
   throw UnsupportedOperationException(
       "txPut only supported by Thin Client Region.");
diff --git a/cppcache/src/RegionInternal.hpp b/cppcache/src/RegionInternal.hpp
index 4b30bca..5e8022f 100644
--- a/cppcache/src/RegionInternal.hpp
+++ b/cppcache/src/RegionInternal.hpp
@@ -173,15 +173,15 @@ class RegionInternal : public Region {
   virtual void setPersistenceManager(PersistenceManagerPtr& pmPtr) = 0;
 
   virtual GfErrType getNoThrow(const CacheableKeyPtr& key, CacheablePtr& value,
-                               const UserDataPtr& aCallbackArgument) = 0;
+                               const SerializablePtr& aCallbackArgument) = 0;
   virtual GfErrType getAllNoThrow(const VectorOfCacheableKey& keys,
                                   const HashMapOfCacheablePtr& values,
                                   const HashMapOfExceptionPtr& exceptions,
                                   bool addToLocalCache,
-                                  const UserDataPtr& aCallbackArgument) = 0;
+                                  const SerializablePtr& aCallbackArgument) = 0;
   virtual GfErrType putNoThrow(const CacheableKeyPtr& key,
                                const CacheablePtr& value,
-                               const UserDataPtr& aCallbackArgument,
+                               const SerializablePtr& aCallbackArgument,
                                CacheablePtr& oldValue, int updateCount,
                                const CacheEventFlags eventFlags,
                                VersionTagPtr versionTag,
@@ -189,30 +189,30 @@ class RegionInternal : public Region {
                                EventIdPtr eventId = nullptr) = 0;
   virtual GfErrType createNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
-                                  const UserDataPtr& aCallbackArgument,
+                                  const SerializablePtr& aCallbackArgument,
                                   int updateCount,
                                   const CacheEventFlags eventFlags,
                                   VersionTagPtr versionTag) = 0;
   virtual GfErrType destroyNoThrow(const CacheableKeyPtr& key,
-                                   const UserDataPtr& aCallbackArgument,
+                                   const SerializablePtr& aCallbackArgument,
                                    int updateCount,
                                    const CacheEventFlags eventFlags,
                                    VersionTagPtr versionTag) = 0;
   virtual GfErrType removeNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
-                                  const UserDataPtr& aCallbackArgument,
+                                  const SerializablePtr& aCallbackArgument,
                                   int updateCount,
                                   const CacheEventFlags eventFlags,
                                   VersionTagPtr versionTag) = 0;
   virtual GfErrType invalidateNoThrow(const CacheableKeyPtr& keyPtr,
-                                      const UserDataPtr& aCallbackArgument,
+                                      const SerializablePtr& aCallbackArgument,
                                       int updateCount,
                                       const CacheEventFlags eventFlags,
                                       VersionTagPtr versionTag) = 0;
   virtual GfErrType invalidateRegionNoThrow(
-      const UserDataPtr& aCallbackArgument,
+      const SerializablePtr& aCallbackArgument,
       const CacheEventFlags eventFlags) = 0;
-  virtual GfErrType destroyRegionNoThrow(const UserDataPtr& aCallbackArgument,
+  virtual GfErrType destroyRegionNoThrow(const SerializablePtr& aCallbackArgument,
                                          bool removeFromParent,
                                          const CacheEventFlags eventFlags) = 0;
 
@@ -253,12 +253,12 @@ class RegionInternal : public Region {
   virtual void addDisMessToQueue(){};
 
   virtual void txDestroy(const CacheableKeyPtr& key,
-                         const UserDataPtr& callBack, VersionTagPtr versionTag);
+                         const SerializablePtr& callBack, VersionTagPtr versionTag);
   virtual void txInvalidate(const CacheableKeyPtr& key,
-                            const UserDataPtr& callBack,
+                            const SerializablePtr& callBack,
                             VersionTagPtr versionTag);
   virtual void txPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                     const UserDataPtr& callBack, VersionTagPtr versionTag);
+                     const SerializablePtr& callBack, VersionTagPtr versionTag);
   inline bool isConcurrencyCheckEnabled() const {
     return m_regionAttributes->getConcurrencyChecksEnabled();
   }
diff --git a/cppcache/src/TcrMessage.cpp b/cppcache/src/TcrMessage.cpp
index 10f4986..6a3a330 100644
--- a/cppcache/src/TcrMessage.cpp
+++ b/cppcache/src/TcrMessage.cpp
@@ -1484,7 +1484,7 @@ void TcrMessage::handleByteArrayResponse(
 
 TcrMessageDestroyRegion::TcrMessageDestroyRegion(
     std::unique_ptr<DataOutput> dataOutput, const Region* region,
-    const UserDataPtr& aCallbackArgument, int messageResponsetimeout,
+    const SerializablePtr& aCallbackArgument, int messageResponsetimeout,
     ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::DESTROY_REGION;
@@ -1518,7 +1518,7 @@ TcrMessageDestroyRegion::TcrMessageDestroyRegion(
 
 TcrMessageClearRegion::TcrMessageClearRegion(
     std::unique_ptr<DataOutput> dataOutput, const Region* region,
-    const UserDataPtr& aCallbackArgument, int messageResponsetimeout,
+    const SerializablePtr& aCallbackArgument, int messageResponsetimeout,
     ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::CLEAR_REGION;
@@ -1633,7 +1633,7 @@ TcrMessageCloseCQ::TcrMessageCloseCQ(std::unique_ptr<DataOutput> dataOutput,
 
 TcrMessageQueryWithParameters::TcrMessageQueryWithParameters(
     std::unique_ptr<DataOutput> dataOutput, const std::string& regionName,
-    const UserDataPtr& aCallbackArgument, CacheableVectorPtr paramList,
+    const SerializablePtr& aCallbackArgument, CacheableVectorPtr paramList,
     int messageResponsetimeout, ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::QUERY_WITH_PARAMETERS;
@@ -1671,7 +1671,7 @@ TcrMessageQueryWithParameters::TcrMessageQueryWithParameters(
 
 TcrMessageContainsKey::TcrMessageContainsKey(
     std::unique_ptr<DataOutput> dataOutput, const Region* region,
-    const CacheableKeyPtr& key, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& key, const SerializablePtr& aCallbackArgument,
     bool isContainsKey, ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::CONTAINS_KEY;
@@ -1721,7 +1721,7 @@ TcrMessageGetDurableCqs::TcrMessageGetDurableCqs(
 TcrMessageRequest::TcrMessageRequest(std::unique_ptr<DataOutput> dataOutput,
                                      const Region* region,
                                      const CacheableKeyPtr& key,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::REQUEST;
@@ -1758,7 +1758,7 @@ TcrMessageRequest::TcrMessageRequest(std::unique_ptr<DataOutput> dataOutput,
 
 TcrMessageInvalidate::TcrMessageInvalidate(
     std::unique_ptr<DataOutput> dataOutput, const Region* region,
-    const CacheableKeyPtr& key, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& key, const SerializablePtr& aCallbackArgument,
     ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::INVALIDATE;
@@ -1797,7 +1797,7 @@ TcrMessageDestroy::TcrMessageDestroy(std::unique_ptr<DataOutput> dataOutput,
                                      const Region* region,
                                      const CacheableKeyPtr& key,
                                      const CacheablePtr& value,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      ThinClientBaseDM* connectionDM) {
   m_request = std::move(dataOutput);
   m_msgType = TcrMessage::DESTROY;
@@ -1851,7 +1851,7 @@ TcrMessageDestroy::TcrMessageDestroy(std::unique_ptr<DataOutput> dataOutput,
 TcrMessagePut::TcrMessagePut(std::unique_ptr<DataOutput> dataOutput,
                              const Region* region, const CacheableKeyPtr& key,
                              const CacheablePtr& value,
-                             const UserDataPtr& aCallbackArgument, bool isDelta,
+                             const SerializablePtr& aCallbackArgument, bool isDelta,
                              ThinClientBaseDM* connectionDM, bool isMetaRegion,
                              bool fullValueAfterDeltaFail,
                              const char* regionName) {
@@ -2216,7 +2216,7 @@ TcrMessagePutAll::TcrMessagePutAll(std::unique_ptr<DataOutput> dataOutput,
                                    const HashMapOfCacheable& map,
                                    int messageResponsetimeout,
                                    ThinClientBaseDM* connectionDM,
-                                   const UserDataPtr& aCallbackArgument) {
+                                   const SerializablePtr& aCallbackArgument) {
   m_tcdm = connectionDM;
   m_regionName = region->getFullPath();
   m_region = region;
@@ -2283,7 +2283,7 @@ TcrMessagePutAll::TcrMessagePutAll(std::unique_ptr<DataOutput> dataOutput,
 TcrMessageRemoveAll::TcrMessageRemoveAll(std::unique_ptr<DataOutput> dataOutput,
                                          const Region* region,
                                          const VectorOfCacheableKey& keys,
-                                         const UserDataPtr& aCallbackArgument,
+                                         const SerializablePtr& aCallbackArgument,
                                          ThinClientBaseDM* connectionDM) {
   m_msgType = TcrMessage::REMOVE_ALL;
   m_tcdm = connectionDM;
@@ -2338,7 +2338,7 @@ TcrMessageGetAll::TcrMessageGetAll(std::unique_ptr<DataOutput> dataOutput,
                                    const Region* region,
                                    const VectorOfCacheableKey* keys,
                                    ThinClientBaseDM* connectionDM,
-                                   const UserDataPtr& aCallbackArgument) {
+                                   const SerializablePtr& aCallbackArgument) {
   m_msgType = TcrMessage::GET_ALL_70;
   m_tcdm = connectionDM;
   m_keyList = keys;
@@ -2368,7 +2368,7 @@ TcrMessageGetAll::TcrMessageGetAll(std::unique_ptr<DataOutput> dataOutput,
   writeMessageLength();*/
 }
 
-void TcrMessage::InitializeGetallMsg(const UserDataPtr& aCallbackArgument) {
+void TcrMessage::InitializeGetallMsg(const SerializablePtr& aCallbackArgument) {
   /*CacheableObjectArrayPtr keyArr = nullptr;
   if (m_keyList != nullptr) {
     keyArr = CacheableObjectArray::create();
diff --git a/cppcache/src/TcrMessage.hpp b/cppcache/src/TcrMessage.hpp
index 60dd5a6..c82cf01 100644
--- a/cppcache/src/TcrMessage.hpp
+++ b/cppcache/src/TcrMessage.hpp
@@ -27,7 +27,6 @@
 #include <geode/Cacheable.hpp>
 #include <geode/CacheableKey.hpp>
 #include <geode/CacheableString.hpp>
-#include <geode/UserData.hpp>
 #include <geode/DataOutput.hpp>
 #include <geode/DataInput.hpp>
 #include <geode/ExceptionTypes.hpp>
@@ -231,7 +230,7 @@ class CPPCACHE_EXPORT TcrMessage {
   //  = false, bool receiveValues = true, ThinClientBaseDM *connectionDM =
   //  nullptr);
 
-  void InitializeGetallMsg(const UserDataPtr& aCallbackArgument);
+  void InitializeGetallMsg(const SerializablePtr& aCallbackArgument);
   // for multiuser cache close
 
   // Updates the early ack byte of the message to reflect that it is a retry op
@@ -646,7 +645,7 @@ class TcrMessageDestroyRegion : public TcrMessage {
  public:
   TcrMessageDestroyRegion(std::unique_ptr<DataOutput> dataOutput,
                           const Region* region,
-                          const UserDataPtr& aCallbackArgument,
+                          const SerializablePtr& aCallbackArgument,
                           int messageResponsetimeout,
                           ThinClientBaseDM* connectionDM);
 
@@ -659,7 +658,7 @@ class TcrMessageClearRegion : public TcrMessage {
  public:
   TcrMessageClearRegion(std::unique_ptr<DataOutput> dataOutput,
                         const Region* region,
-                        const UserDataPtr& aCallbackArgument,
+                        const SerializablePtr& aCallbackArgument,
                         int messageResponsetimeout,
                         ThinClientBaseDM* connectionDM);
 
@@ -705,7 +704,7 @@ class TcrMessageQueryWithParameters : public TcrMessage {
  public:
   TcrMessageQueryWithParameters(std::unique_ptr<DataOutput> dataOutput,
                                 const std::string& regionName,
-                                const UserDataPtr& aCallbackArgument,
+                                const SerializablePtr& aCallbackArgument,
                                 CacheableVectorPtr paramList,
                                 int messageResponsetimeout,
                                 ThinClientBaseDM* connectionDM);
@@ -719,7 +718,7 @@ class TcrMessageContainsKey : public TcrMessage {
  public:
   TcrMessageContainsKey(std::unique_ptr<DataOutput> dataOutput,
                         const Region* region, const CacheableKeyPtr& key,
-                        const UserDataPtr& aCallbackArgument,
+                        const SerializablePtr& aCallbackArgument,
                         bool isContainsKey, ThinClientBaseDM* connectionDM);
 
   virtual ~TcrMessageContainsKey() {}
@@ -741,7 +740,7 @@ class TcrMessageRequest : public TcrMessage {
  public:
   TcrMessageRequest(std::unique_ptr<DataOutput> dataOutput,
                     const Region* region, const CacheableKeyPtr& key,
-                    const UserDataPtr& aCallbackArgument,
+                    const SerializablePtr& aCallbackArgument,
                     ThinClientBaseDM* connectionDM = nullptr);
 
   virtual ~TcrMessageRequest() {}
@@ -753,7 +752,7 @@ class TcrMessageInvalidate : public TcrMessage {
  public:
   TcrMessageInvalidate(std::unique_ptr<DataOutput> dataOutput,
                        const Region* region, const CacheableKeyPtr& key,
-                       const UserDataPtr& aCallbackArgument,
+                       const SerializablePtr& aCallbackArgument,
                        ThinClientBaseDM* connectionDM = nullptr);
 
  private:
@@ -764,7 +763,7 @@ class TcrMessageDestroy : public TcrMessage {
   TcrMessageDestroy(std::unique_ptr<DataOutput> dataOutput,
                     const Region* region, const CacheableKeyPtr& key,
                     const CacheablePtr& value,
-                    const UserDataPtr& aCallbackArgument,
+                    const SerializablePtr& aCallbackArgument,
                     ThinClientBaseDM* connectionDM = nullptr);
 
  private:
@@ -802,7 +801,7 @@ class TcrMessagePut : public TcrMessage {
  public:
   TcrMessagePut(std::unique_ptr<DataOutput> dataOutput, const Region* region,
                 const CacheableKeyPtr& key, const CacheablePtr& value,
-                const UserDataPtr& aCallbackArgument, bool isDelta = false,
+                const SerializablePtr& aCallbackArgument, bool isDelta = false,
                 ThinClientBaseDM* connectionDM = nullptr,
                 bool isMetaRegion = false, bool fullValueAfterDeltaFail = false,
                 const char* regionName = nullptr);
@@ -915,7 +914,7 @@ class TcrMessagePutAll : public TcrMessage {
   TcrMessagePutAll(std::unique_ptr<DataOutput> dataOutput, const Region* region,
                    const HashMapOfCacheable& map, int messageResponsetimeout,
                    ThinClientBaseDM* connectionDM,
-                   const UserDataPtr& aCallbackArgument);
+                   const SerializablePtr& aCallbackArgument);
 
   virtual ~TcrMessagePutAll() {}
 
@@ -926,7 +925,7 @@ class TcrMessageRemoveAll : public TcrMessage {
  public:
   TcrMessageRemoveAll(std::unique_ptr<DataOutput> dataOutput,
                       const Region* region, const VectorOfCacheableKey& keys,
-                      const UserDataPtr& aCallbackArgument,
+                      const SerializablePtr& aCallbackArgument,
                       ThinClientBaseDM* connectionDM = nullptr);
 
   virtual ~TcrMessageRemoveAll() {}
@@ -1160,7 +1159,7 @@ class TcrMessageGetAll : public TcrMessage {
   TcrMessageGetAll(std::unique_ptr<DataOutput> dataOutput, const Region* region,
                    const VectorOfCacheableKey* keys,
                    ThinClientBaseDM* connectionDM = nullptr,
-                   const UserDataPtr& aCallbackArgument = nullptr);
+                   const SerializablePtr& aCallbackArgument = nullptr);
 
   virtual ~TcrMessageGetAll() {}
 
diff --git a/cppcache/src/ThinClientPoolDM.cpp b/cppcache/src/ThinClientPoolDM.cpp
index 3950e5c..8b3f249 100644
--- a/cppcache/src/ThinClientPoolDM.cpp
+++ b/cppcache/src/ThinClientPoolDM.cpp
@@ -58,7 +58,7 @@ class GetAllWork : public PooledWork<GfErrType>,
   const VectorOfCacheableKeyPtr m_keys;
   const RegionPtr m_region;
   TcrChunkedResult* m_resultCollector;
-  const UserDataPtr& m_aCallbackArgument;
+  const SerializablePtr& m_aCallbackArgument;
 
  public:
   GetAllWork(ThinClientPoolDM* poolDM, const RegionPtr& region,
@@ -66,7 +66,7 @@ class GetAllWork : public PooledWork<GfErrType>,
              const VectorOfCacheableKeyPtr& keys, bool attemptFailover,
              bool isBGThread, bool addToLocalCache,
              ChunkedGetAllResponse* responseHandler,
-             const UserDataPtr& aCallbackArgument)
+             const SerializablePtr& aCallbackArgument)
       : m_poolDM(poolDM),
         m_serverLocation(serverLocation),
         m_attemptFailover(attemptFailover),
diff --git a/cppcache/src/ThinClientRegion.cpp b/cppcache/src/ThinClientRegion.cpp
index 8c7ddf3..da7edb3 100644
--- a/cppcache/src/ThinClientRegion.cpp
+++ b/cppcache/src/ThinClientRegion.cpp
@@ -68,7 +68,7 @@ class PutAllWork : public PooledWork<GfErrType>,
   PutAllPartialResultServerExceptionPtr m_papException;
   bool m_isPapeReceived;
   ChunkedPutAllResponse* m_resultCollector;
-  // UNUSED const UserDataPtr& m_aCallbackArgument;
+  // UNUSED const SerializablePtr& m_aCallbackArgument;
 
  public:
   PutAllWork(ThinClientPoolDM* poolDM,
@@ -76,7 +76,7 @@ class PutAllWork : public PooledWork<GfErrType>,
              const RegionPtr& region, bool attemptFailover, bool isBGThread,
              const HashMapOfCacheablePtr map,
              const VectorOfCacheableKeyPtr keys, uint32_t timeout,
-             const UserDataPtr& aCallbackArgument)
+             const SerializablePtr& aCallbackArgument)
       : m_poolDM(poolDM),
         m_serverLocation(serverLocation),
         m_attemptFailover(attemptFailover),
@@ -207,7 +207,7 @@ class RemoveAllWork : public PooledWork<GfErrType>,
   bool m_isBGThread;
   UserAttributesPtr m_userAttribute;
   const RegionPtr m_region;
-  const UserDataPtr& m_aCallbackArgument;
+  const SerializablePtr& m_aCallbackArgument;
   VectorOfCacheableKeyPtr m_keys;
   VersionedCacheableObjectPartListPtr m_verObjPartListPtr;
   PutAllPartialResultServerExceptionPtr m_papException;
@@ -219,7 +219,7 @@ class RemoveAllWork : public PooledWork<GfErrType>,
                 const BucketServerLocationPtr& serverLocation,
                 const RegionPtr& region, bool attemptFailover, bool isBGThread,
                 const VectorOfCacheableKeyPtr keys,
-                const UserDataPtr& aCallbackArgument)
+                const SerializablePtr& aCallbackArgument)
       : m_poolDM(poolDM),
         m_serverLocation(serverLocation),
         m_attemptFailover(attemptFailover),
@@ -829,7 +829,7 @@ bool ThinClientRegion::containsKeyOnServer(
   /** @brief Create message and send to bridge server */
 
   TcrMessageContainsKey request(m_cache->createDataOutput(), this, keyPtr,
-                                static_cast<UserDataPtr>(nullptr), true,
+                                static_cast<SerializablePtr>(nullptr), true,
                                 m_tcrdm);
   TcrMessageReply reply(true, m_tcrdm);
   reply.setMessageTypeRequest(TcrMessage::CONTAINS_KEY);
@@ -884,7 +884,7 @@ bool ThinClientRegion::containsValueForKey_remote(
   /** @brief Create message and send to bridge server */
 
   TcrMessageContainsKey request(m_cache->createDataOutput(), this, keyPtr,
-                                static_cast<UserDataPtr>(nullptr), false,
+                                static_cast<SerializablePtr>(nullptr), false,
                                 m_tcrdm);
   TcrMessageReply reply(true, m_tcrdm);
   reply.setMessageTypeRequest(TcrMessage::CONTAINS_KEY);
@@ -923,7 +923,7 @@ bool ThinClientRegion::containsValueForKey_remote(
   return rptr->value();
 }
 
-void ThinClientRegion::clear(const UserDataPtr& aCallbackArgument) {
+void ThinClientRegion::clear(const SerializablePtr& aCallbackArgument) {
   GfErrType err = GF_NOERR;
   err = localClearNoThrow(aCallbackArgument, CacheEventFlags::NORMAL);
   if (err != GF_NOERR) GfErrTypeToException("Region::clear", err);
@@ -966,7 +966,7 @@ void ThinClientRegion::clear(const UserDataPtr& aCallbackArgument) {
 
 GfErrType ThinClientRegion::getNoThrow_remote(
     const CacheableKeyPtr& keyPtr, CacheablePtr& valPtr,
-    const UserDataPtr& aCallbackArgument, VersionTagPtr& versionTag) {
+    const SerializablePtr& aCallbackArgument, VersionTagPtr& versionTag) {
   GfErrType err = GF_NOERR;
 
   /** @brief Create message and send to bridge server */
@@ -1005,7 +1005,7 @@ GfErrType ThinClientRegion::getNoThrow_remote(
 }
 
 GfErrType ThinClientRegion::invalidateNoThrow_remote(
-    const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
     VersionTagPtr& versionTag) {
   GfErrType err = GF_NOERR;
 
@@ -1045,7 +1045,7 @@ GfErrType ThinClientRegion::invalidateNoThrow_remote(
 
 GfErrType ThinClientRegion::putNoThrow_remote(
     const CacheableKeyPtr& keyPtr, const CacheablePtr& valuePtr,
-    const UserDataPtr& aCallbackArgument, VersionTagPtr& versionTag,
+    const SerializablePtr& aCallbackArgument, VersionTagPtr& versionTag,
     bool checkDelta) {
   GfErrType err = GF_NOERR;
   // do TCR put
@@ -1108,13 +1108,13 @@ GfErrType ThinClientRegion::putNoThrow_remote(
 
 GfErrType ThinClientRegion::createNoThrow_remote(
     const CacheableKeyPtr& keyPtr, const CacheablePtr& valuePtr,
-    const UserDataPtr& aCallbackArgument, VersionTagPtr& versionTag) {
+    const SerializablePtr& aCallbackArgument, VersionTagPtr& versionTag) {
   return putNoThrow_remote(keyPtr, valuePtr, aCallbackArgument, versionTag,
                            false);
 }
 
 GfErrType ThinClientRegion::destroyNoThrow_remote(
-    const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
     VersionTagPtr& versionTag) {
   GfErrType err = GF_NOERR;
 
@@ -1157,7 +1157,7 @@ GfErrType ThinClientRegion::destroyNoThrow_remote(
 
 GfErrType ThinClientRegion::removeNoThrow_remote(
     const CacheableKeyPtr& keyPtr, const CacheablePtr& cvalue,
-    const UserDataPtr& aCallbackArgument, VersionTagPtr& versionTag) {
+    const SerializablePtr& aCallbackArgument, VersionTagPtr& versionTag) {
   GfErrType err = GF_NOERR;
 
   // do TCR remove
@@ -1198,7 +1198,7 @@ GfErrType ThinClientRegion::removeNoThrow_remote(
 }
 
 GfErrType ThinClientRegion::removeNoThrowEX_remote(
-    const CacheableKeyPtr& keyPtr, const UserDataPtr& aCallbackArgument,
+    const CacheableKeyPtr& keyPtr, const SerializablePtr& aCallbackArgument,
     VersionTagPtr& versionTag) {
   GfErrType err = GF_NOERR;
 
@@ -1243,7 +1243,7 @@ GfErrType ThinClientRegion::getAllNoThrow_remote(
     const VectorOfCacheableKey* keys, const HashMapOfCacheablePtr& values,
     const HashMapOfExceptionPtr& exceptions,
     const VectorOfCacheableKeyPtr& resultKeys, bool addToLocalCache,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   GfErrType err = GF_NOERR;
   MapOfUpdateCounters updateCountMap;
   int32_t destroyTracker = 0;
@@ -1326,7 +1326,7 @@ GfErrType ThinClientRegion::getAllNoThrow_remote(
 GfErrType ThinClientRegion::singleHopPutAllNoThrow_remote(
     ThinClientPoolDM* tcrdm, const HashMapOfCacheable& map,
     VersionedCacheableObjectPartListPtr& versionedObjPartList, uint32_t timeout,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   LOGDEBUG(" ThinClientRegion::singleHopPutAllNoThrow_remote map size = %d",
            map.size());
   RegionPtr region = shared_from_this();
@@ -1637,7 +1637,7 @@ GfErrType ThinClientRegion::singleHopPutAllNoThrow_remote(
 GfErrType ThinClientRegion::multiHopPutAllNoThrow_remote(
     const HashMapOfCacheable& map,
     VersionedCacheableObjectPartListPtr& versionedObjPartList, uint32_t timeout,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   // Multiple hop implementation
   LOGDEBUG("ThinClientRegion::multiHopPutAllNoThrow_remote ");
   GfErrType err = GF_NOERR;
@@ -1702,7 +1702,7 @@ GfErrType ThinClientRegion::multiHopPutAllNoThrow_remote(
 GfErrType ThinClientRegion::putAllNoThrow_remote(
     const HashMapOfCacheable& map,
     VersionedCacheableObjectPartListPtr& versionedObjPartList, uint32_t timeout,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   LOGDEBUG("ThinClientRegion::putAllNoThrow_remote");
 
   ThinClientPoolDM* poolDM = dynamic_cast<ThinClientPoolDM*>(m_tcrdm);
@@ -1727,7 +1727,7 @@ GfErrType ThinClientRegion::putAllNoThrow_remote(
 GfErrType ThinClientRegion::singleHopRemoveAllNoThrow_remote(
     ThinClientPoolDM* tcrdm, const VectorOfCacheableKey& keys,
     VersionedCacheableObjectPartListPtr& versionedObjPartList,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   LOGDEBUG(" ThinClientRegion::singleHopRemoveAllNoThrow_remote keys size = %d",
            keys.size());
   RegionPtr region = shared_from_this();
@@ -1970,7 +1970,7 @@ GfErrType ThinClientRegion::singleHopRemoveAllNoThrow_remote(
 GfErrType ThinClientRegion::multiHopRemoveAllNoThrow_remote(
     const VectorOfCacheableKey& keys,
     VersionedCacheableObjectPartListPtr& versionedObjPartList,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   // Multiple hop implementation
   LOGDEBUG("ThinClientRegion::multiHopRemoveAllNoThrow_remote ");
   GfErrType err = GF_NOERR;
@@ -2025,7 +2025,7 @@ GfErrType ThinClientRegion::multiHopRemoveAllNoThrow_remote(
 GfErrType ThinClientRegion::removeAllNoThrow_remote(
     const VectorOfCacheableKey& keys,
     VersionedCacheableObjectPartListPtr& versionedObjPartList,
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   LOGDEBUG("ThinClientRegion::removeAllNoThrow_remote");
 
   ThinClientPoolDM* poolDM = dynamic_cast<ThinClientPoolDM*>(m_tcrdm);
@@ -2254,7 +2254,7 @@ GfErrType ThinClientRegion::unregisterKeys() {
 }
 
 GfErrType ThinClientRegion::destroyRegionNoThrow_remote(
-    const UserDataPtr& aCallbackArgument) {
+    const SerializablePtr& aCallbackArgument) {
   GfErrType err = GF_NOERR;
 
   // do TCR destroyRegion
@@ -3395,7 +3395,7 @@ GfErrType ThinClientRegion::getNoThrow_FullObject(EventIdPtr eventId,
 }
 
 void ThinClientRegion::txDestroy(const CacheableKeyPtr& key,
-                                 const UserDataPtr& aCallbackArgument,
+                                 const SerializablePtr& aCallbackArgument,
                                  VersionTagPtr versionTag) {
   GfErrType err = destroyNoThrowTX(key, aCallbackArgument, -1,
                                    CacheEventFlags::NORMAL, versionTag);
@@ -3403,7 +3403,7 @@ void ThinClientRegion::txDestroy(const CacheableKeyPtr& key,
 }
 
 void ThinClientRegion::txInvalidate(const CacheableKeyPtr& key,
-                                    const UserDataPtr& aCallbackArgument,
+                                    const SerializablePtr& aCallbackArgument,
                                     VersionTagPtr versionTag) {
   GfErrType err = invalidateNoThrowTX(key, aCallbackArgument, -1,
                                       CacheEventFlags::NORMAL, versionTag);
@@ -3412,7 +3412,7 @@ void ThinClientRegion::txInvalidate(const CacheableKeyPtr& key,
 
 void ThinClientRegion::txPut(const CacheableKeyPtr& key,
                              const CacheablePtr& value,
-                             const UserDataPtr& aCallbackArgument,
+                             const SerializablePtr& aCallbackArgument,
                              VersionTagPtr versionTag) {
   CacheablePtr oldValue;
   int64_t sampleStartNanos = startStatOpTime();
diff --git a/cppcache/src/ThinClientRegion.hpp b/cppcache/src/ThinClientRegion.hpp
index 0ed8d9d..131a109 100644
--- a/cppcache/src/ThinClientRegion.hpp
+++ b/cppcache/src/ThinClientRegion.hpp
@@ -86,7 +86,7 @@ class CPPCACHE_EXPORT ThinClientRegion : public LocalRegion {
                              bool receiveValues = true);
   virtual void unregisterRegex(const char* regex);
   virtual void serverKeys(VectorOfCacheableKey& v);
-  virtual void clear(const UserDataPtr& aCallbackArgument = nullptr);
+  virtual void clear(const SerializablePtr& aCallbackArgument = nullptr);
 
   virtual SelectResultsPtr query(
       const char* predicate, uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT);
@@ -102,11 +102,11 @@ class CPPCACHE_EXPORT ThinClientRegion : public LocalRegion {
       const HashMapOfCacheable& map,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   GfErrType removeAllNoThrow_remote(
       const VectorOfCacheableKey& keys,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   GfErrType registerKeys(TcrEndpoint* endpoint = nullptr,
                          const TcrMessage* request = nullptr,
                          TcrMessageReply* reply = nullptr);
@@ -168,49 +168,49 @@ class CPPCACHE_EXPORT ThinClientRegion : public LocalRegion {
   uint32_t size_remote();
 
   virtual void txDestroy(const CacheableKeyPtr& key,
-                         const UserDataPtr& callBack, VersionTagPtr versionTag);
+                         const SerializablePtr& callBack, VersionTagPtr versionTag);
   virtual void txInvalidate(const CacheableKeyPtr& key,
-                            const UserDataPtr& callBack,
+                            const SerializablePtr& callBack,
                             VersionTagPtr versionTag);
   virtual void txPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                     const UserDataPtr& callBack, VersionTagPtr versionTag);
+                     const SerializablePtr& callBack, VersionTagPtr versionTag);
 
  protected:
   /** @brief the methods need to be overloaded in TCR
    */
   GfErrType getNoThrow_remote(const CacheableKeyPtr& keyPtr,
                               CacheablePtr& valPtr,
-                              const UserDataPtr& aCallbackArgument,
+                              const SerializablePtr& aCallbackArgument,
                               VersionTagPtr& versionTag);
   GfErrType putNoThrow_remote(const CacheableKeyPtr& keyPtr,
                               const CacheablePtr& cvalue,
-                              const UserDataPtr& aCallbackArgument,
+                              const SerializablePtr& aCallbackArgument,
                               VersionTagPtr& versionTag,
                               bool checkDelta = true);
   GfErrType createNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                  const CacheablePtr& cvalue,
-                                 const UserDataPtr& aCallbackArgument,
+                                 const SerializablePtr& aCallbackArgument,
                                  VersionTagPtr& versionTag);
   GfErrType destroyNoThrow_remote(const CacheableKeyPtr& keyPtr,
-                                  const UserDataPtr& aCallbackArgument,
+                                  const SerializablePtr& aCallbackArgument,
                                   VersionTagPtr& versionTag);
   GfErrType removeNoThrow_remote(const CacheableKeyPtr& keyPtr,
                                  const CacheablePtr& cvalue,
-                                 const UserDataPtr& aCallbackArgument,
+                                 const SerializablePtr& aCallbackArgument,
                                  VersionTagPtr& versionTag);
   GfErrType removeNoThrowEX_remote(const CacheableKeyPtr& keyPtr,
-                                   const UserDataPtr& aCallbackArgument,
+                                   const SerializablePtr& aCallbackArgument,
                                    VersionTagPtr& versionTag);
   GfErrType invalidateNoThrow_remote(const CacheableKeyPtr& keyPtr,
-                                     const UserDataPtr& aCallbackArgument,
+                                     const SerializablePtr& aCallbackArgument,
                                      VersionTagPtr& versionTag);
   GfErrType getAllNoThrow_remote(const VectorOfCacheableKey* keys,
                                  const HashMapOfCacheablePtr& values,
                                  const HashMapOfExceptionPtr& exceptions,
                                  const VectorOfCacheableKeyPtr& resultKeys,
                                  bool addToLocalCache,
-                                 const UserDataPtr& aCallbackArgument);
-  GfErrType destroyRegionNoThrow_remote(const UserDataPtr& aCallbackArgument);
+                                 const SerializablePtr& aCallbackArgument);
+  GfErrType destroyRegionNoThrow_remote(const SerializablePtr& aCallbackArgument);
   GfErrType registerKeysNoThrow(
       const VectorOfCacheableKey& keys, bool attemptFailover = true,
       TcrEndpoint* endpoint = nullptr, bool isDurable = false,
@@ -291,7 +291,7 @@ class CPPCACHE_EXPORT ThinClientRegion : public LocalRegion {
       std::unordered_map<CacheableKeyPtr, InterestResultPolicy>& interestList);
   GfErrType createOnServer(const CacheableKeyPtr& keyPtr,
                            const CacheablePtr& cvalue,
-                           const UserDataPtr& aCallbackArgument);
+                           const SerializablePtr& aCallbackArgument);
   // method to get the values for a register interest
   void registerInterestGetValues(const char* method,
                                  const VectorOfCacheableKey* keys,
@@ -306,21 +306,21 @@ class CPPCACHE_EXPORT ThinClientRegion : public LocalRegion {
       ThinClientPoolDM* tcrdm, const HashMapOfCacheable& map,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   GfErrType multiHopPutAllNoThrow_remote(
       const HashMapOfCacheable& map,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
 
   GfErrType singleHopRemoveAllNoThrow_remote(
       ThinClientPoolDM* tcrdm, const VectorOfCacheableKey& keys,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
   GfErrType multiHopRemoveAllNoThrow_remote(
       const VectorOfCacheableKey& keys,
       VersionedCacheableObjectPartListPtr& versionedObjPartList,
-      const UserDataPtr& aCallbackArgument = nullptr);
+      const SerializablePtr& aCallbackArgument = nullptr);
 
   ACE_RW_Thread_Mutex m_RegionMutex;
   bool m_isMetaDataRefreshed;
diff --git a/cppcache/test/TcrMessage_unittest.cpp b/cppcache/test/TcrMessage_unittest.cpp
index 87f6c17..2fb0417 100644
--- a/cppcache/test/TcrMessage_unittest.cpp
+++ b/cppcache/test/TcrMessage_unittest.cpp
@@ -65,7 +65,7 @@ TEST_F(TcrMessageTest, intializeDefaultConstructor) {
 
 TEST_F(TcrMessageTest, testConstructor1MessageDataContentWithDESTROY_REGION) {
   const Region *region = nullptr;
-  const UserDataPtr aCallbackArgument = nullptr;
+  const SerializablePtr aCallbackArgument = nullptr;
   int messageResponseTimeout = 1000;
   ThinClientBaseDM *connectionDM = nullptr;
 
@@ -84,7 +84,7 @@ TEST_F(TcrMessageTest, testConstructor1MessageDataContentWithDESTROY_REGION) {
 
 TEST_F(TcrMessageTest, testConstructor1MessageDataContentWithCLEAR_REGION) {
   const Region *region = nullptr;
-  const UserDataPtr aCallbackArgument = nullptr;
+  const SerializablePtr aCallbackArgument = nullptr;
   int messageResponseTimeout = 1000;
   ThinClientBaseDM *connectionDM = nullptr;
 
@@ -167,7 +167,7 @@ TEST_F(TcrMessageTest,
        testParameterizedQueryConstructorWithQUERY_WITH_PARAMETERS) {
   int messageResponseTimeout = 1000;
   ThinClientBaseDM *connectionDM = nullptr;
-  const UserDataPtr aCallbackArgument = nullptr;
+  const SerializablePtr aCallbackArgument = nullptr;
   CacheableVectorPtr paramList = CacheableVector::create();
 
   TcrMessageQueryWithParameters message(
@@ -189,7 +189,7 @@ TEST_F(TcrMessageTest, testConstructorWithCONTAINS_KEY) {
       static_cast<const Region *>(nullptr),
       CacheableString::create(
           "mykey"),  // static_cast<const CacheableKeyPtr>(nullptr),
-      static_cast<const UserDataPtr>(nullptr),
+      static_cast<const SerializablePtr>(nullptr),
       true,  // isContainsKey
       static_cast<ThinClientBaseDM *>(nullptr));
   EXPECT_EQ(TcrMessage::CONTAINS_KEY, message.getMessageType());
@@ -216,7 +216,7 @@ TEST_F(TcrMessageTest, testConstructor2WithREQUEST) {
       static_cast<const Region *>(nullptr),
       CacheableString::create(
           "mykey"),  // static_cast<const CacheableKeyPtr>(nullptr),
-      static_cast<const UserDataPtr>(nullptr),
+      static_cast<const SerializablePtr>(nullptr),
       static_cast<ThinClientBaseDM *>(nullptr));
 
   EXPECT_EQ(TcrMessage::REQUEST, message.getMessageType());
@@ -232,7 +232,7 @@ TEST_F(TcrMessageTest, testConstructor2WithDESTROY) {
       std::unique_ptr<DataOutputUnderTest>(new DataOutputUnderTest()),
       static_cast<const Region *>(nullptr), CacheableString::create("mykey"),
       static_cast<const CacheableKeyPtr>(nullptr),
-      static_cast<const UserDataPtr>(nullptr),
+      static_cast<const SerializablePtr>(nullptr),
       static_cast<ThinClientBaseDM *>(nullptr));
 
   EXPECT_EQ(TcrMessage::DESTROY, message.getMessageType());
@@ -250,7 +250,7 @@ TEST_F(TcrMessageTest, testConstructor2WithINVALIDATE) {
       static_cast<const Region *>(nullptr),
       CacheableString::create(
           "mykey"),  // static_cast<const CacheableKeyPtr>(nullptr),
-      static_cast<const UserDataPtr>(nullptr),
+      static_cast<const SerializablePtr>(nullptr),
       static_cast<ThinClientBaseDM *>(nullptr));
 
   EXPECT_EQ(TcrMessage::INVALIDATE, message.getMessageType());
@@ -267,7 +267,7 @@ TEST_F(TcrMessageTest, testConstructor3WithPUT) {
       std::unique_ptr<DataOutputUnderTest>(new DataOutputUnderTest()),
       static_cast<const Region *>(nullptr), CacheableString::create("mykey"),
       CacheableString::create("myvalue"),
-      static_cast<const UserDataPtr>(nullptr),
+      static_cast<const SerializablePtr>(nullptr),
       false,  // isDelta
       static_cast<ThinClientBaseDM *>(nullptr),
       false,  // isMetaRegion
diff --git a/quickstart/cpp/Exceptions.cpp b/quickstart/cpp/Exceptions.cpp
index df714de..d6976c7 100644
--- a/quickstart/cpp/Exceptions.cpp
+++ b/quickstart/cpp/Exceptions.cpp
@@ -83,7 +83,7 @@ int main(int argc, char** argv) {
     LOGINFO("Obtained the second Entry from the Region");
 
     // Destroy exampleRegion2.
-    UserDataPtr userDataPtr = nullptr;
+    SerializablePtr userDataPtr = nullptr;
     regionPtr2->destroyRegion(userDataPtr);
 
     try {
diff --git a/quickstart/cpp/plugins/SimpleCacheLoader.cpp b/quickstart/cpp/plugins/SimpleCacheLoader.cpp
index 7142088..9b73d75 100644
--- a/quickstart/cpp/plugins/SimpleCacheLoader.cpp
+++ b/quickstart/cpp/plugins/SimpleCacheLoader.cpp
@@ -19,7 +19,7 @@
 
 CacheablePtr SimpleCacheLoader::load(const RegionPtr& region,
                                      const CacheableKeyPtr& key,
-                                     const UserDataPtr& aCallbackArgument) {
+                                     const SerializablePtr& aCallbackArgument) {
   LOGINFO("SimpleCacheLoader: Got a load event.");
 
   CacheablePtr value = CacheableString::create("LoaderValue");
diff --git a/quickstart/cpp/plugins/SimpleCacheLoader.hpp b/quickstart/cpp/plugins/SimpleCacheLoader.hpp
index 8a06b94..0082317 100644
--- a/quickstart/cpp/plugins/SimpleCacheLoader.hpp
+++ b/quickstart/cpp/plugins/SimpleCacheLoader.hpp
@@ -34,7 +34,7 @@ using namespace apache::geode::client;
 class SimpleCacheLoader : public CacheLoader {
  public:
   virtual CacheablePtr load(const RegionPtr& region, const CacheableKeyPtr& key,
-                            const UserDataPtr& aCallbackArgument);
+                            const SerializablePtr& aCallbackArgument);
 
   virtual void close(const RegionPtr& region);
 };

-- 
To stop receiving notification emails like this one, please contact
['"commits@geode.apache.org" <co...@geode.apache.org>'].