geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [23/50] [abbrv] geode git commit: GEODE-2316: Rename namespace gemfire to apache::geode::client.
Date Mon, 23 Jan 2017 19:17:15 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/AttributesMutator.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/AttributesMutator.hpp b/src/clicache/src/AttributesMutator.hpp
index 4bc1745..a398718 100644
--- a/src/clicache/src/AttributesMutator.hpp
+++ b/src/clicache/src/AttributesMutator.hpp
@@ -54,7 +54,7 @@ namespace GemStone
       /// <seealso cref="AttributesFactory" />
       generic<class TKey, class TValue>
       public ref class AttributesMutator sealed
-        : public Internal::SBWrap<gemfire::AttributesMutator>
+        : public Internal::SBWrap<apache::geode::client::AttributesMutator>
       {
       public:
 
@@ -242,7 +242,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static AttributesMutator<TKey, TValue>^ Create( gemfire::AttributesMutator* nativeptr )
+        inline static AttributesMutator<TKey, TValue>^ Create( apache::geode::client::AttributesMutator* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew AttributesMutator<TKey, TValue>( nativeptr ) : nullptr );
@@ -255,7 +255,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline AttributesMutator<TKey, TValue>( gemfire::AttributesMutator* nativeptr )
+        inline AttributesMutator<TKey, TValue>( apache::geode::client::AttributesMutator* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Cache.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Cache.cpp b/src/clicache/src/Cache.cpp
index f1d5f9a..936a8c4 100644
--- a/src/clicache/src/Cache.cpp
+++ b/src/clicache/src/Cache.cpp
@@ -57,7 +57,7 @@ namespace GemStone
 
       DistributedSystem^ Cache::DistributedSystem::get( )
       {
-        gemfire::DistributedSystemPtr& nativeptr(
+        apache::geode::client::DistributedSystemPtr& nativeptr(
           NativePtr->getDistributedSystem( ) );
 
         return GemStone::GemFire::Cache::Generic::DistributedSystem::Create(
@@ -66,7 +66,7 @@ namespace GemStone
 
       CacheTransactionManager^ Cache::CacheTransactionManager::get( )
       {
-        gemfire::InternalCacheTransactionManager2PCPtr& nativeptr = static_cast<InternalCacheTransactionManager2PCPtr>(
+        apache::geode::client::InternalCacheTransactionManager2PCPtr& nativeptr = static_cast<InternalCacheTransactionManager2PCPtr>(
           NativePtr->getCacheTransactionManager( ) );
 
         return GemStone::GemFire::Cache::Generic::CacheTransactionManager::Create(
@@ -90,7 +90,7 @@ namespace GemStone
           NativePtr->close( keepalive );
 
           // If DS automatically disconnected due to the new bootstrap API, then cleanup the C++/CLI side
-          //if (!gemfire::DistributedSystem::isConnected())
+          //if (!apache::geode::client::DistributedSystem::isConnected())
           {
             GemStone::GemFire::Cache::Generic::DistributedSystem::UnregisterBuiltinManagedTypes();
           }
@@ -120,7 +120,7 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           ManagedString mg_path( path );
-          gemfire::RegionPtr& nativeptr(
+          apache::geode::client::RegionPtr& nativeptr(
             NativePtr->getRegion( mg_path.CharPtr ) );
 
           return Generic::Region<TKey,TValue>::Create( nativeptr.ptr( ) );
@@ -131,14 +131,14 @@ namespace GemStone
       generic<class TKey, class TValue>
       array<Generic::IRegion<TKey, TValue>^>^ Cache::RootRegions( )
       {
-        gemfire::VectorOfRegion vrr;
+        apache::geode::client::VectorOfRegion vrr;
         NativePtr->rootRegions( vrr );
         array<Generic::IRegion<TKey, TValue>^>^ rootRegions =
           gcnew array<Generic::IRegion<TKey, TValue>^>( vrr.size( ) );
 
         for( int32_t index = 0; index < vrr.size( ); index++ )
         {
-          gemfire::RegionPtr& nativeptr( vrr[ index ] );
+          apache::geode::client::RegionPtr& nativeptr( vrr[ index ] );
           rootRegions[ index ] = Generic::Region<TKey, TValue>::Create( nativeptr.ptr( ) );
         }
         return rootRegions;
@@ -169,24 +169,24 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          gemfire::RegionShortcut preDefineRegionAttr = gemfire::CACHING_PROXY;
+          apache::geode::client::RegionShortcut preDefineRegionAttr = apache::geode::client::CACHING_PROXY;
 
           switch(preDefinedRegionAttributes)
           {
           case RegionShortcut::PROXY:
-              preDefineRegionAttr = gemfire::PROXY;
+              preDefineRegionAttr = apache::geode::client::PROXY;
               break;
           case RegionShortcut::CACHING_PROXY:
-              preDefineRegionAttr = gemfire::CACHING_PROXY;
+              preDefineRegionAttr = apache::geode::client::CACHING_PROXY;
               break;
           case RegionShortcut::CACHING_PROXY_ENTRY_LRU:
-              preDefineRegionAttr = gemfire::CACHING_PROXY_ENTRY_LRU;
+              preDefineRegionAttr = apache::geode::client::CACHING_PROXY_ENTRY_LRU;
               break;
           case RegionShortcut::LOCAL:
-              preDefineRegionAttr = gemfire::LOCAL;
+              preDefineRegionAttr = apache::geode::client::LOCAL;
               break;
           case RegionShortcut::LOCAL_ENTRY_LRU:
-              preDefineRegionAttr = gemfire::LOCAL_ENTRY_LRU;
+              preDefineRegionAttr = apache::geode::client::LOCAL_ENTRY_LRU;
               break;          
           }
 
@@ -199,12 +199,12 @@ namespace GemStone
       {
         //  TODO:
 				//TODO::split
-        gemfire::Properties* prop = NULL;
+        apache::geode::client::Properties* prop = NULL;
 
         if (credentials != nullptr)
-          prop = GetNativePtr<gemfire::Properties>( credentials );
+          prop = GetNativePtr<apache::geode::client::Properties>( credentials );
 
-        gemfire::PropertiesPtr credPtr(prop);
+        apache::geode::client::PropertiesPtr credPtr(prop);
         
         
         _GF_MG_EXCEPTION_TRY2
@@ -236,12 +236,12 @@ namespace GemStone
       {
          // TODO:
 				//TODO::split
-        gemfire::Properties* prop = NULL;
+        apache::geode::client::Properties* prop = NULL;
 
         if (credentials != nullptr)
-          prop = GetNativePtr<gemfire::Properties>( credentials );
+          prop = GetNativePtr<apache::geode::client::Properties>( credentials );
 
-        gemfire::PropertiesPtr credPtr(prop);
+        apache::geode::client::PropertiesPtr credPtr(prop);
 
         ManagedString mg_poolName( poolName );
         

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Cache.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Cache.hpp b/src/clicache/src/Cache.hpp
index 7ad8011..9e7eaea 100644
--- a/src/clicache/src/Cache.hpp
+++ b/src/clicache/src/Cache.hpp
@@ -65,7 +65,7 @@ namespace GemStone
       /// </para>
       /// </remarks>
       public ref class Cache sealed
-        : public IGemFireCache, Internal::SBWrap<gemfire::Cache>
+        : public IGemFireCache, Internal::SBWrap<apache::geode::client::Cache>
       {
       public:
 
@@ -270,7 +270,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Cache^ Create( gemfire::Cache* nativeptr )
+        inline static Cache^ Create( apache::geode::client::Cache* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew Cache( nativeptr ) : nullptr );
@@ -283,7 +283,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Cache( gemfire::Cache* nativeptr )
+        inline Cache( apache::geode::client::Cache* nativeptr )
           : SBWrap( nativeptr ) { }
       };
       } // end namespace Generic

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheFactory.cpp b/src/clicache/src/CacheFactory.cpp
index 051b083..c76a6ad 100644
--- a/src/clicache/src/CacheFactory.cpp
+++ b/src/clicache/src/CacheFactory.cpp
@@ -48,10 +48,10 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-           gemfire::PropertiesPtr nativepropsptr(
-            GetNativePtr<gemfire::Properties>(dsProps));
+           apache::geode::client::PropertiesPtr nativepropsptr(
+            GetNativePtr<apache::geode::client::Properties>(dsProps));
 
-          gemfire::CacheFactoryPtr& nativeptr( gemfire::CacheFactory::createCacheFactory( nativepropsptr) );         
+          apache::geode::client::CacheFactoryPtr& nativeptr( apache::geode::client::CacheFactory::createCacheFactory( nativepropsptr) );         
           if (nativeptr.ptr() != nullptr)
             return gcnew CacheFactory( nativeptr.ptr(), dsProps );
             
@@ -71,22 +71,22 @@ namespace GemStone
     
           if(!m_connected)
           {
-             gemfire::PropertiesPtr nativepropsptr(
-               GetNativePtr<gemfire::Properties>(m_dsProps));
+             apache::geode::client::PropertiesPtr nativepropsptr(
+               GetNativePtr<apache::geode::client::Properties>(m_dsProps));
             DistributedSystem::AppDomainInstanceInitialization(nativepropsptr);                  
           }
 
-          gemfire::CachePtr& nativeptr( NativePtr->create( ) );
+          apache::geode::client::CachePtr& nativeptr( NativePtr->create( ) );
 					pdxIgnoreUnreadFields = nativeptr->getPdxIgnoreUnreadFields();
           pdxReadSerialized = nativeptr->getPdxReadSerialized();
 
           appDomainEnable = DistributedSystem::SystemProperties->AppDomainEnabled;
-          Log::SetLogLevel(static_cast<LogLevel>(gemfire::Log::logLevel( )));
+          Log::SetLogLevel(static_cast<LogLevel>(apache::geode::client::Log::logLevel( )));
 					//TODO::split
           SafeConvertClassGeneric::SetAppDomainEnabled(appDomainEnable);
 
             Serializable::RegisterTypeGeneric(
-              gemfire::GemfireTypeIds::PdxType,
+              apache::geode::client::GemfireTypeIds::PdxType,
               gcnew TypeFactoryMethodGeneric(GemStone::GemFire::Cache::Generic::Internal::PdxType::CreateDeserializable),
               nullptr);
 
@@ -115,10 +115,10 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          gemfire::DistributedSystemPtr p_system(
-            GetNativePtr<gemfire::DistributedSystem>( system ) );
-          gemfire::CachePtr& nativeptr(
-            gemfire::CacheFactory::getInstance( p_system ) );
+          apache::geode::client::DistributedSystemPtr p_system(
+            GetNativePtr<apache::geode::client::DistributedSystem>( system ) );
+          apache::geode::client::CachePtr& nativeptr(
+            apache::geode::client::CacheFactory::getInstance( p_system ) );
 
           return Cache::Create( nativeptr.ptr( ) );
 
@@ -129,10 +129,10 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          gemfire::DistributedSystemPtr p_system(
-            GetNativePtr<gemfire::DistributedSystem>( system ) );
-          gemfire::CachePtr& nativeptr(
-            gemfire::CacheFactory::getInstanceCloseOk( p_system ) );
+          apache::geode::client::DistributedSystemPtr p_system(
+            GetNativePtr<apache::geode::client::DistributedSystem>( system ) );
+          apache::geode::client::CachePtr& nativeptr(
+            apache::geode::client::CacheFactory::getInstanceCloseOk( p_system ) );
 
           return Cache::Create( nativeptr.ptr( ) );
 
@@ -143,8 +143,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          gemfire::CachePtr& nativeptr(
-            gemfire::CacheFactory::getAnyInstance( ) );
+          apache::geode::client::CachePtr& nativeptr(
+            apache::geode::client::CacheFactory::getAnyInstance( ) );
           return Cache::Create( nativeptr.ptr( ) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2
@@ -152,13 +152,13 @@ namespace GemStone
 
       String^ CacheFactory::Version::get( )
       {
-        return ManagedString::Get( gemfire::CacheFactory::getVersion( ) );
+        return ManagedString::Get( apache::geode::client::CacheFactory::getVersion( ) );
       }
 
       String^ CacheFactory::ProductDescription::get( )
       {
         return ManagedString::Get(
-          gemfire::CacheFactory::getProductDescription( ) );
+          apache::geode::client::CacheFactory::getProductDescription( ) );
       }
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheFactory.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheFactory.hpp b/src/clicache/src/CacheFactory.hpp
index 6474100..31ee627 100644
--- a/src/clicache/src/CacheFactory.hpp
+++ b/src/clicache/src/CacheFactory.hpp
@@ -46,7 +46,7 @@ namespace GemStone
       /// To get an existing unclosed cache instance, use <see cref="CacheFactory.GetInstance" />.
       /// </para>
       /// </remarks>
-      public ref class CacheFactory :public Internal::SBWrap<gemfire::CacheFactory>
+      public ref class CacheFactory :public Internal::SBWrap<apache::geode::client::CacheFactory>
       {
       public:
 
@@ -128,7 +128,7 @@ namespace GemStone
         /// </summary>
         static void SetNewAndDelete()
         {
-          gemfire::setNewAndDelete( & operator new, & operator delete );
+          apache::geode::client::setNewAndDelete( & operator new, & operator delete );
         }
 
         /// <summary>
@@ -592,7 +592,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-         inline CacheFactory( gemfire::CacheFactory* nativeptr, Properties<String^, String^>^ dsProps )
+         inline CacheFactory( apache::geode::client::CacheFactory* nativeptr, Properties<String^, String^>^ dsProps )
 					 : SBWrap( nativeptr ) 
          { 
             m_dsProps = dsProps;

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheStatistics.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheStatistics.hpp b/src/clicache/src/CacheStatistics.hpp
index 82b6f25..ffbecf6 100644
--- a/src/clicache/src/CacheStatistics.hpp
+++ b/src/clicache/src/CacheStatistics.hpp
@@ -39,7 +39,7 @@ namespace GemStone
       /// <seealso cref="Region.Statistics" />
       /// <seealso cref="RegionEntry.Statistics" />
       public ref class CacheStatistics sealed
-        : public Internal::SBWrap<gemfire::CacheStatistics>
+        : public Internal::SBWrap<apache::geode::client::CacheStatistics>
       {
       public:
 
@@ -131,7 +131,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CacheStatistics^ Create( gemfire::CacheStatistics* nativeptr )
+        inline static CacheStatistics^ Create( apache::geode::client::CacheStatistics* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew CacheStatistics( nativeptr ) : nullptr );
@@ -144,7 +144,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheStatistics( gemfire::CacheStatistics* nativeptr )
+        inline CacheStatistics( apache::geode::client::CacheStatistics* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheTransactionManager.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheTransactionManager.cpp b/src/clicache/src/CacheTransactionManager.cpp
index 9d3b1cf..0650d09 100644
--- a/src/clicache/src/CacheTransactionManager.cpp
+++ b/src/clicache/src/CacheTransactionManager.cpp
@@ -92,7 +92,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
         
-          return NativePtr->resume( gemfire::TransactionIdPtr(transactionId->NativePtr()));
+          return NativePtr->resume( apache::geode::client::TransactionIdPtr(transactionId->NativePtr()));
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -100,7 +100,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          return NativePtr->isSuspended( gemfire::TransactionIdPtr(transactionId->NativePtr()));
+          return NativePtr->isSuspended( apache::geode::client::TransactionIdPtr(transactionId->NativePtr()));
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -108,7 +108,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          return NativePtr->tryResume( gemfire::TransactionIdPtr(transactionId->NativePtr()));
+          return NativePtr->tryResume( apache::geode::client::TransactionIdPtr(transactionId->NativePtr()));
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -116,7 +116,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          return NativePtr->tryResume( gemfire::TransactionIdPtr(transactionId->NativePtr()), waitTimeInMilliSec);
+          return NativePtr->tryResume( apache::geode::client::TransactionIdPtr(transactionId->NativePtr()), waitTimeInMilliSec);
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -124,7 +124,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          return NativePtr->exists( gemfire::TransactionIdPtr(transactionId->NativePtr()));
+          return NativePtr->exists( apache::geode::client::TransactionIdPtr(transactionId->NativePtr()));
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -136,9 +136,9 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2
 
           // Conver the unmanaged object to  managed generic object 
-          gemfire::TransactionWriterPtr& writerPtr( NativePtr->getWriter( ) );
-          gemfire::ManagedTransactionWriterGeneric* twg =
-          dynamic_cast<gemfire::ManagedTransactionWriterGeneric*>( writerPtr.ptr( ) );
+          apache::geode::client::TransactionWriterPtr& writerPtr( NativePtr->getWriter( ) );
+          apache::geode::client::ManagedTransactionWriterGeneric* twg =
+          dynamic_cast<apache::geode::client::ManagedTransactionWriterGeneric*>( writerPtr.ptr( ) );
 
           if (twg != nullptr)
           {
@@ -156,13 +156,13 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2
           // Create a unmanaged object using the ManagedTransactionWriterGeneric.
           // Set the generic object inside the TransactionWriterGeneric that is a non generic object
-          gemfire::TransactionWriterPtr writerPtr;
+          apache::geode::client::TransactionWriterPtr writerPtr;
           if ( transactionWriter != nullptr ) 
           {
             TransactionWriterGeneric<TKey, TValue>^ twg = gcnew TransactionWriterGeneric<TKey, TValue> ();
             twg->SetTransactionWriter(transactionWriter);
-            writerPtr = new gemfire::ManagedTransactionWriterGeneric( transactionWriter );
-            ((gemfire::ManagedTransactionWriterGeneric*)writerPtr.ptr())->setptr(twg);
+            writerPtr = new apache::geode::client::ManagedTransactionWriterGeneric( transactionWriter );
+            ((apache::geode::client::ManagedTransactionWriterGeneric*)writerPtr.ptr())->setptr(twg);
           }
           NativePtr->setWriter( writerPtr );
           
@@ -175,13 +175,13 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2
           // Create a unmanaged object using the ManagedTransactionListenerGeneric.
           // Set the generic object inside the TransactionListenerGeneric that is a non generic object
-          gemfire::TransactionListenerPtr listenerPtr;
+          apache::geode::client::TransactionListenerPtr listenerPtr;
           if ( transactionListener != nullptr ) 
           {
             TransactionListenerGeneric<TKey, TValue>^ twg = gcnew TransactionListenerGeneric<TKey, TValue> ();
             twg->SetTransactionListener(transactionListener);
-            listenerPtr = new gemfire::ManagedTransactionListenerGeneric( transactionListener );
-            ((gemfire::ManagedTransactionListenerGeneric*)listenerPtr.ptr())->setptr(twg);
+            listenerPtr = new apache::geode::client::ManagedTransactionListenerGeneric( transactionListener );
+            ((apache::geode::client::ManagedTransactionListenerGeneric*)listenerPtr.ptr())->setptr(twg);
           }
           NativePtr->addListener( listenerPtr );
           
@@ -194,13 +194,13 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2
           // Create an unmanaged non generic object using the managed generic object
           // use this to call the remove listener
-          gemfire::TransactionListenerPtr listenerPtr;
+          apache::geode::client::TransactionListenerPtr listenerPtr;
           if ( transactionListener != nullptr ) 
           {
             TransactionListenerGeneric<TKey, TValue>^ twg = gcnew TransactionListenerGeneric<TKey, TValue> ();
             twg->SetTransactionListener(transactionListener);
-            listenerPtr = new gemfire::ManagedTransactionListenerGeneric( transactionListener );
-            ((gemfire::ManagedTransactionListenerGeneric*)listenerPtr.ptr())->setptr(twg);
+            listenerPtr = new apache::geode::client::ManagedTransactionListenerGeneric( transactionListener );
+            ((apache::geode::client::ManagedTransactionListenerGeneric*)listenerPtr.ptr())->setptr(twg);
           }
           NativePtr->removeListener( listenerPtr );
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheTransactionManager.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheTransactionManager.hpp b/src/clicache/src/CacheTransactionManager.hpp
index 6696862..26f18ea 100644
--- a/src/clicache/src/CacheTransactionManager.hpp
+++ b/src/clicache/src/CacheTransactionManager.hpp
@@ -38,7 +38,7 @@ namespace GemStone
       /// CacheTransactionManager encapsulates the transactions for a cache
       /// </summary>
       public ref class CacheTransactionManager sealed
-        : Internal::SBWrap<gemfire::InternalCacheTransactionManager2PC>
+        : Internal::SBWrap<apache::geode::client::InternalCacheTransactionManager2PC>
       {
       public:
         /// <summary>
@@ -248,7 +248,7 @@ namespace GemStone
 
       internal:
 
-        inline static CacheTransactionManager^ Create( gemfire::InternalCacheTransactionManager2PC* nativeptr )
+        inline static CacheTransactionManager^ Create( apache::geode::client::InternalCacheTransactionManager2PC* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew CacheTransactionManager( nativeptr ) : nullptr );
@@ -261,7 +261,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheTransactionManager( gemfire::InternalCacheTransactionManager2PC* nativeptr )
+        inline CacheTransactionManager( apache::geode::client::InternalCacheTransactionManager2PC* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableBuiltins.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableBuiltins.hpp b/src/clicache/src/CacheableBuiltins.hpp
index 363ad38..d2f70df 100644
--- a/src/clicache/src/CacheableBuiltins.hpp
+++ b/src/clicache/src/CacheableBuiltins.hpp
@@ -53,7 +53,7 @@ namespace GemStone
           /// </summary>
           CacheableBuiltinKey()
           {
-            gemfire::SharedPtr<TNative>& nativeptr = TNative::create();
+            apache::geode::client::SharedPtr<TNative>& nativeptr = TNative::create();
 
             SetSP(nativeptr.ptr());
           }
@@ -64,7 +64,7 @@ namespace GemStone
           /// <param name="value">the value of the new instance</param>
           CacheableBuiltinKey(TManaged value)
           {
-            gemfire::SharedPtr<TNative>& nativeptr = TNative::create(value);
+            apache::geode::client::SharedPtr<TNative>& nativeptr = TNative::create(value);
 
             SetSP(nativeptr.ptr());
           }
@@ -149,7 +149,7 @@ namespace GemStone
           /// Protected constructor to wrap a native object pointer
           /// </summary>
           /// <param name="nativeptr">The native object pointer</param>
-          inline CacheableBuiltinKey(gemfire::Serializable* nativeptr)
+          inline CacheableBuiltinKey(apache::geode::client::Serializable* nativeptr)
             : CacheableKey(nativeptr) { }
         };
 
@@ -245,7 +245,7 @@ namespace GemStone
           inline CacheableBuiltinArray()
           {
             //TODO:
-            //gemfire::Serializable* sp = TNative::createDeserializable();
+            //apache::geode::client::Serializable* sp = TNative::createDeserializable();
             //SetSP(sp);
           }
 
@@ -253,12 +253,12 @@ namespace GemStone
           /// Protected constructor to wrap a native object pointer
           /// </summary>
           /// <param name="nativeptr">The native object pointer</param>
-          inline CacheableBuiltinArray(gemfire::Serializable* nptr)
+          inline CacheableBuiltinArray(apache::geode::client::Serializable* nptr)
             : Serializable(nptr)
           { 
             //TODO: ??
-             // ManagedPtrWrap< gemfire::Serializable,
-               // Internal::SBWrap<gemfire::Serializable> > nptr = nativeptr;
+             // ManagedPtrWrap< apache::geode::client::Serializable,
+               // Internal::SBWrap<apache::geode::client::Serializable> > nptr = nativeptr;
               TNative* nativeptr = static_cast<TNative*>(nptr);
               int32_t len = nativeptr->length();
               if (len > 0)
@@ -363,20 +363,20 @@ namespace GemStone
         }                                                                     \
                                                                               \
       internal:                                                               \
-        static IGFSerializable^ Create(gemfire::Serializable* obj)            \
+        static IGFSerializable^ Create(apache::geode::client::Serializable* obj)            \
         {                                                                     \
           return (obj != nullptr ? gcnew m(obj) : nullptr);                   \
         }                                                                     \
                                                                               \
       private:                                                                \
-        inline m(gemfire::Serializable* nativeptr)                            \
+        inline m(apache::geode::client::Serializable* nativeptr)                            \
           : CacheableBuiltinKey(nativeptr) { }                                \
       };
 
 
 #define _GFCLI_CACHEABLE_ARRAY_DEF_NEW(m, mt)                                    \
       ref class m : public CacheableBuiltinArray<            \
-        gemfire::m, gemfire::m##Ptr, mt, GemFireClassIds::m>                  \
+        apache::geode::client::m, apache::geode::client::m##Ptr, mt, GemFireClassIds::m>                  \
       {                                                                       \
       public:                                                                 \
         /** <summary>
@@ -426,7 +426,7 @@ namespace GemStone
         }                                                                     \
                                                                               \
       internal:                                                               \
-        static IGFSerializable^ Create(gemfire::Serializable* obj)            \
+        static IGFSerializable^ Create(apache::geode::client::Serializable* obj)            \
         {                                                                     \
           return (obj != nullptr ? gcnew m(obj) : nullptr);                   \
         }                                                                     \
@@ -459,7 +459,7 @@ namespace GemStone
          */                                                                   \
         inline m(array<mt>^ value, int32_t length)                              \
           : CacheableBuiltinArray(value, length) { }                          \
-        inline m(gemfire::Serializable* nativeptr)                            \
+        inline m(apache::geode::client::Serializable* nativeptr)                            \
           : CacheableBuiltinArray(nativeptr) { }                              \
       };
 
@@ -470,56 +470,56 @@ namespace GemStone
       /// An immutable wrapper for booleans that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableBoolean,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableBoolean,
         CacheableBoolean, bool);
 
       /// <summary>
       /// An immutable wrapper for bytes that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableByte,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableByte,
         CacheableByte, Byte);
 
       /// <summary>
       /// An immutable wrapper for 16-bit characters that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableWideChar,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableWideChar,
         CacheableCharacter, Char);
 
       /// <summary>
       /// An immutable wrapper for doubles that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableDouble,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableDouble,
         CacheableDouble, Double);
 
       /// <summary>
       /// An immutable wrapper for floats that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableFloat,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableFloat,
         CacheableFloat, Single);
 
       /// <summary>
       /// An immutable wrapper for 16-bit integers that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableInt16,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableInt16,
         CacheableInt16, int16_t);
 
       /// <summary>
       /// An immutable wrapper for 32-bit integers that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableInt32,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableInt32,
         CacheableInt32, int32_t);
 
       /// <summary>
       /// An immutable wrapper for 64-bit integers that can serve
       /// as a distributable key object for caching.
       /// </summary>
-      _GFCLI_CACHEABLE_KEY_DEF_NEW(gemfire::CacheableInt64,
+      _GFCLI_CACHEABLE_KEY_DEF_NEW(apache::geode::client::CacheableInt64,
         CacheableInt64, int64_t);
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableFileName.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableFileName.cpp b/src/clicache/src/CacheableFileName.cpp
index 5478536..1fade1f 100644
--- a/src/clicache/src/CacheableFileName.cpp
+++ b/src/clicache/src/CacheableFileName.cpp
@@ -34,11 +34,11 @@ namespace GemStone
       void CacheableFileName::ToData(DataOutput^ output)
       {
         if (m_str->Length <= 0xFFFF) {
-          output->WriteByte(gemfire::GemfireTypeIds::CacheableString);
+          output->WriteByte(apache::geode::client::GemfireTypeIds::CacheableString);
           output->WriteUTF(m_str);
         }
         else {
-          output->WriteByte(gemfire::GemfireTypeIds::CacheableStringHuge);
+          output->WriteByte(apache::geode::client::GemfireTypeIds::CacheableStringHuge);
           output->WriteUTFHuge(m_str);
         }
       }
@@ -46,7 +46,7 @@ namespace GemStone
       IGFSerializable^ CacheableFileName::FromData(DataInput^ input)
       {
         unsigned char filetype = input->ReadByte();
-        if (filetype == gemfire::GemfireTypeIds::CacheableString) {
+        if (filetype == apache::geode::client::GemfireTypeIds::CacheableString) {
           m_str = input->ReadUTF();
         }
         else {

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableHashSet.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableHashSet.hpp b/src/clicache/src/CacheableHashSet.hpp
index c043ca3..df9caeb 100644
--- a/src/clicache/src/CacheableHashSet.hpp
+++ b/src/clicache/src/CacheableHashSet.hpp
@@ -51,8 +51,8 @@ namespace GemStone
         {
           output->WriteArrayLen(this->Count);
 
-          Internal::ManagedPtrWrap< gemfire::Serializable,
-              Internal::SBWrap<gemfire::Serializable> > nptr = NativePtr;
+          Internal::ManagedPtrWrap< apache::geode::client::Serializable,
+              Internal::SBWrap<apache::geode::client::Serializable> > nptr = NativePtr;
           HSTYPE* set = static_cast<HSTYPE*>(nptr());
           for (typename HSTYPE::Iterator iter = set->begin();
               iter != set->end(); ++iter) {
@@ -326,7 +326,7 @@ namespace GemStone
           {
             _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-              gemfire::CacheableKeyPtr nativeptr(Serializable::GetUnmanagedValueGeneric(item));
+              apache::geode::client::CacheableKeyPtr nativeptr(Serializable::GetUnmanagedValueGeneric(item));
             static_cast<HSTYPE*>(NativePtr())->insert(nativeptr);
 
             _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -354,7 +354,7 @@ namespace GemStone
           virtual bool Contains(Object^ item)
           {
             return static_cast<HSTYPE*>(NativePtr())->contains(
-              gemfire::CacheableKeyPtr(Serializable::GetUnmanagedValueGeneric(item)));
+              apache::geode::client::CacheableKeyPtr(Serializable::GetUnmanagedValueGeneric(item)));
           }
 
           /// <summary>
@@ -385,8 +385,8 @@ namespace GemStone
               throw gcnew IllegalArgumentException("CacheableHashSet.CopyTo():"
                 " array is null or array index is less than zero");
             }
-            Internal::ManagedPtrWrap< gemfire::Serializable,
-              Internal::SBWrap<gemfire::Serializable> > nptr = NativePtr;
+            Internal::ManagedPtrWrap< apache::geode::client::Serializable,
+              Internal::SBWrap<apache::geode::client::Serializable> > nptr = NativePtr;
             HSTYPE* set = static_cast<HSTYPE*>(nptr());
             int32_t index = arrayIndex;
 
@@ -432,7 +432,7 @@ namespace GemStone
           virtual bool Remove(Object^ item)
           {
             return (static_cast<HSTYPE*>(NativePtr())->erase(
-              gemfire::CacheableKeyPtr(Serializable::GetUnmanagedValueGeneric(item))) > 0);
+              apache::geode::client::CacheableKeyPtr(Serializable::GetUnmanagedValueGeneric(item))) > 0);
           }
 
           /// <summary>
@@ -475,7 +475,7 @@ namespace GemStone
           /// <summary>
           /// Factory function to register wrapper
           /// </summary>
-          static IGFSerializable^ Create(gemfire::Serializable* obj)
+          static IGFSerializable^ Create(apache::geode::client::Serializable* obj)
           {
             return (obj != NULL ?
               gcnew CacheableHashSetType<TYPEID,HSTYPE>(obj) : nullptr);
@@ -504,7 +504,7 @@ namespace GemStone
           /// Private constructor to wrap a native object pointer
           /// </summary>
           /// <param name="nativeptr">The native object pointer</param>
-          inline CacheableHashSetType<TYPEID, HSTYPE>(gemfire::Serializable* nativeptr)
+          inline CacheableHashSetType<TYPEID, HSTYPE>(apache::geode::client::Serializable* nativeptr)
             : Serializable(nativeptr) { }
 
           /// <summary>
@@ -571,13 +571,13 @@ namespace GemStone
         }                                                                     \
                                                                               \
       internal:                                                               \
-        static IGFSerializable^ Create(gemfire::Serializable* obj)            \
+        static IGFSerializable^ Create(apache::geode::client::Serializable* obj)            \
         {                                                                     \
           return gcnew m(obj);                                                \
         }                                                                     \
                                                                               \
       private:                                                                \
-        inline m(gemfire::Serializable* nativeptr)                            \
+        inline m(apache::geode::client::Serializable* nativeptr)                            \
         : Internal::CacheableHashSetType<GemStone::GemFire::Cache::Generic::GemFireClassIds::m, HSTYPE>(nativeptr) { }             \
       };
 
@@ -586,7 +586,7 @@ namespace GemStone
       /// a distributable object for caching.
       /// </summary>
       _GFCLI_CACHEABLEHASHSET_DEF_GENERIC(CacheableHashSet,
-        gemfire::CacheableHashSet);
+        apache::geode::client::CacheableHashSet);
 
       /// <summary>
       /// A mutable <c>ICacheableKey</c> hash set wrapper that can serve as
@@ -596,7 +596,7 @@ namespace GemStone
       /// java <c>LinkedHashSet</c>.
       /// </summary>
       _GFCLI_CACHEABLEHASHSET_DEF_GENERIC(CacheableLinkedHashSet,
-        gemfire::CacheableLinkedHashSet);
+        apache::geode::client::CacheableLinkedHashSet);
     }
   }
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableKey.cpp b/src/clicache/src/CacheableKey.cpp
index a06b9ad..4fb147d 100644
--- a/src/clicache/src/CacheableKey.cpp
+++ b/src/clicache/src/CacheableKey.cpp
@@ -31,7 +31,7 @@ namespace GemStone
      // generic<class TKey>
       int32_t CacheableKey::GetHashCode()
       {
-        return static_cast<gemfire::CacheableKey*>(NativePtr())->hashcode();
+        return static_cast<apache::geode::client::CacheableKey*>(NativePtr())->hashcode();
       }
 
      // generic<class TKey>
@@ -40,8 +40,8 @@ namespace GemStone
         if (other == nullptr || other->ClassId != ClassId) {
           return false;
         }
-        return static_cast<gemfire::CacheableKey*>(NativePtr())->operator==(
-          *static_cast<gemfire::CacheableKey*>(
+        return static_cast<apache::geode::client::CacheableKey*>(NativePtr())->operator==(
+          *static_cast<apache::geode::client::CacheableKey*>(
             ((Generic::CacheableKey^)other)->NativePtr()));
       }
 
@@ -52,8 +52,8 @@ namespace GemStone
           dynamic_cast<CacheableKey^>(obj);
 
         if (otherKey != nullptr) {
-          return static_cast<gemfire::CacheableKey*>(NativePtr())->operator==(
-            *static_cast<gemfire::CacheableKey*>(otherKey->NativePtr()));
+          return static_cast<apache::geode::client::CacheableKey*>(NativePtr())->operator==(
+            *static_cast<apache::geode::client::CacheableKey*>(otherKey->NativePtr()));
         }
         return false;
       }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableKey.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableKey.hpp b/src/clicache/src/CacheableKey.hpp
index 3e824d0..84936f0 100644
--- a/src/clicache/src/CacheableKey.hpp
+++ b/src/clicache/src/CacheableKey.hpp
@@ -33,7 +33,7 @@ namespace GemStone
     namespace Cache { namespace Generic
     {
       /// <summary>
-      /// This class wraps the native C++ <c>gemfire::Serializable</c> objects
+      /// This class wraps the native C++ <c>apache::geode::client::Serializable</c> objects
       /// as managed <see cref="../../IGFSerializable" /> objects.
       /// </summary>
       public ref class CacheableKey
@@ -43,20 +43,20 @@ namespace GemStone
         /// <summary>
         /// Return the hashcode for this key.
         /// It gets the hash code by calling the <c>hashcode()</c> function
-        /// of the underlying <c>gemfire::CacheableKey</c> object.
+        /// of the underlying <c>apache::geode::client::CacheableKey</c> object.
         /// </summary>
         virtual int32_t GetHashCode() override;
 
         /// <summary>
         /// Return true if this key matches other object. It invokes the '=='
-        /// operator of the underlying <c>gemfire::CacheableKey</c> object.
+        /// operator of the underlying <c>apache::geode::client::CacheableKey</c> object.
         /// </summary>
         virtual bool Equals(ICacheableKey^ other);
 
         /// <summary>
         /// Return true if this key matches other object.
         /// It invokes the '==' operator if the underlying object is a
-        /// <c>gemfire::CacheableKey</c>, else returns
+        /// <c>apache::geode::client::CacheableKey</c>, else returns
         /// <c>System.Object.Equals()</c>
         /// </summary>
         virtual bool Equals(Object^ obj) override;
@@ -128,7 +128,7 @@ namespace GemStone
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableKey(gemfire::Serializable* nativeptr)
+        inline CacheableKey(apache::geode::client::Serializable* nativeptr)
           : Generic::Serializable(nativeptr) { }
       };
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableObjectArray.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableObjectArray.cpp b/src/clicache/src/CacheableObjectArray.cpp
index cf35e2e..d56895e 100644
--- a/src/clicache/src/CacheableObjectArray.cpp
+++ b/src/clicache/src/CacheableObjectArray.cpp
@@ -41,8 +41,8 @@ namespace GemStone
       void CacheableObjectArray::ToData(DataOutput^ output)
       {
         output->WriteArrayLen((int32_t)Count);
-        output->WriteByte((int8_t)gemfire::GemfireTypeIdsImpl::Class);
-        output->WriteByte((int8_t)gemfire::GemfireTypeIds::CacheableASCIIString);
+        output->WriteByte((int8_t)apache::geode::client::GemfireTypeIdsImpl::Class);
+        output->WriteByte((int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIString);
         output->WriteUTF("java.lang.Object");
 
         for each (Object^ obj in this) {
@@ -52,13 +52,13 @@ namespace GemStone
 
         /*_GF_MG_EXCEPTION_TRY
 
-          gemfire::DataOutput& nativeOutput = *(output->_NativePtr);
+          apache::geode::client::DataOutput& nativeOutput = *(output->_NativePtr);
           nativeOutput.writeArrayLen((int32_t)Count);
-          nativeOutput.write((int8_t)gemfire::GemfireTypeIdsImpl::Class);
-          nativeOutput.write((int8_t)gemfire::GemfireTypeIds::CacheableASCIIString);
+          nativeOutput.write((int8_t)apache::geode::client::GemfireTypeIdsImpl::Class);
+          nativeOutput.write((int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIString);
           nativeOutput.writeASCII("java.lang.Object");
           for each (IGFSerializable^ obj in this) {
-            gemfire::SerializablePtr objPtr(SafeMSerializableConvert(obj));
+            apache::geode::client::SerializablePtr objPtr(SafeMSerializableConvert(obj));
             nativeOutput.writeObject(objPtr);
           }
 
@@ -84,7 +84,7 @@ namespace GemStone
         return this;
         /*_GF_MG_EXCEPTION_TRY
 
-          gemfire::DataInput& nativeInput = *(input->_NativePtr);
+          apache::geode::client::DataInput& nativeInput = *(input->_NativePtr);
           int32_t len;
           nativeInput.readArrayLen(&len);
           if (len >= 0) {
@@ -95,7 +95,7 @@ namespace GemStone
             nativeInput.readInt(&classLen);
             nativeInput.advanceCursor(classLen);
           }
-          gemfire::CacheablePtr value;
+          apache::geode::client::CacheablePtr value;
           for (int32_t index = 0; index < len; ++index) {
             nativeInput.readObject(value);
             Add(SafeUMSerializableConvert(value.ptr()));

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableString.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableString.cpp b/src/clicache/src/CacheableString.cpp
index 1d58ef8..dddaa65 100644
--- a/src/clicache/src/CacheableString.cpp
+++ b/src/clicache/src/CacheableString.cpp
@@ -71,31 +71,31 @@ namespace GemStone
 
 
       inline void CacheableString::GetCacheableString(String^ value,
-        gemfire::CacheableStringPtr& cStr)
+        apache::geode::client::CacheableStringPtr& cStr)
       {
         size_t len;
         if (value != nullptr && (len = value->Length) > 0) {
           pin_ptr<const wchar_t> pin_value = PtrToStringChars(value);
-          cStr = gemfire::CacheableString::create(pin_value, (int32_t)len);
+          cStr = apache::geode::client::CacheableString::create(pin_value, (int32_t)len);
         }
         else {
-          cStr = (gemfire::CacheableString*)
-            gemfire::CacheableString::createDeserializable();
+          cStr = (apache::geode::client::CacheableString*)
+            apache::geode::client::CacheableString::createDeserializable();
         }
       }
 
       inline void CacheableString::GetCacheableString(array<Char>^ value,
-        gemfire::CacheableStringPtr& cStr)
+        apache::geode::client::CacheableStringPtr& cStr)
       {
         size_t len;
         if (value != nullptr && (len = value->Length) > 0) {
           pin_ptr<const Char> pin_value = &value[0];
-          cStr = gemfire::CacheableString::create(
+          cStr = apache::geode::client::CacheableString::create(
             (const wchar_t*)pin_value, (int32_t)len);
         }
         else {
-          cStr = (gemfire::CacheableString*)
-            gemfire::CacheableString::createDeserializable();
+          cStr = (apache::geode::client::CacheableString*)
+            apache::geode::client::CacheableString::createDeserializable();
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableString.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableString.hpp b/src/clicache/src/CacheableString.hpp
index 6b94db9..047ef23 100644
--- a/src/clicache/src/CacheableString.hpp
+++ b/src/clicache/src/CacheableString.hpp
@@ -146,14 +146,14 @@ namespace GemStone
         /// <summary>
         /// Return true if this key matches other object.
         /// It invokes the '==' operator of the underlying
-        /// <c>gemfire::CacheableString</c> object.
+        /// <c>apache::geode::client::CacheableString</c> object.
         /// </summary>
         virtual bool Equals(GemStone::GemFire::Cache::Generic::ICacheableKey^ other) override;
 
         /// <summary>
         /// Return true if this key matches other object.
         /// It invokes the '==' operator of the underlying
-        /// <c>gemfire::CacheableString</c> object.
+        /// <c>apache::geode::client::CacheableString</c> object.
         /// </summary>
         virtual bool Equals(Object^ obj) override;
 
@@ -238,31 +238,31 @@ namespace GemStone
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        static IGFSerializable^ Create(gemfire::Serializable* obj)
+        static IGFSerializable^ Create(apache::geode::client::Serializable* obj)
         {
           return (obj != nullptr ?
             gcnew CacheableString(obj) : nullptr);
         }
 
         /// <summary>
-        /// Internal function to create a <c>gemfire::CacheableString</c>
+        /// Internal function to create a <c>apache::geode::client::CacheableString</c>
         /// from the given managed string.
         /// </summary>
         static void GetCacheableString(String^ value,
-          gemfire::CacheableStringPtr& cStr);
+          apache::geode::client::CacheableStringPtr& cStr);
 
         /// <summary>
-        /// Internal function to create a <c>gemfire::CacheableString</c>
+        /// Internal function to create a <c>apache::geode::client::CacheableString</c>
         /// from the given managed array of characters.
         /// </summary>
         static void GetCacheableString(array<Char>^ value,
-          gemfire::CacheableStringPtr& cStr);
+          apache::geode::client::CacheableStringPtr& cStr);
 
         /// <summary>
         /// Get the <c>System.String</c> from the given
-        /// <c>gemfire::CacheableString</c>
+        /// <c>apache::geode::client::CacheableString</c>
         /// </summary>
-        inline static String^ GetString(gemfire::CacheableString * cStr)
+        inline static String^ GetString(apache::geode::client::CacheableString * cStr)
         {
           if (cStr == NULL) {
             return nullptr;
@@ -312,7 +312,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableString(gemfire::Serializable* nativeptr)
+        inline CacheableString(apache::geode::client::Serializable* nativeptr)
           : CacheableKey(nativeptr) { }
       };
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CacheableStringArray.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableStringArray.hpp b/src/clicache/src/CacheableStringArray.hpp
index ebdeaa6..909971e 100644
--- a/src/clicache/src/CacheableStringArray.hpp
+++ b/src/clicache/src/CacheableStringArray.hpp
@@ -151,7 +151,7 @@ namespace GemStone
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        static IGFSerializable^ Create(gemfire::Serializable* obj)
+        static IGFSerializable^ Create(apache::geode::client::Serializable* obj)
         {
           return (obj != nullptr ?
             gcnew CacheableStringArray(obj) : nullptr);
@@ -171,7 +171,7 @@ namespace GemStone
         inline CacheableStringArray()
           : Serializable() 
         { 
-          //gemfire::Serializable* sp = gemfire::CacheableStringArray::createDeserializable();
+          //apache::geode::client::Serializable* sp = apache::geode::client::CacheableStringArray::createDeserializable();
           //SetSP(sp);
         }
 
@@ -179,7 +179,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CacheableStringArray(gemfire::Serializable* nativeptr)
+        inline CacheableStringArray(apache::geode::client::Serializable* nativeptr)
           : Serializable(nativeptr) { }
       };
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqAttributes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqAttributes.cpp b/src/clicache/src/CqAttributes.cpp
index 251182b..6991b4c 100644
--- a/src/clicache/src/CqAttributes.cpp
+++ b/src/clicache/src/CqAttributes.cpp
@@ -34,22 +34,22 @@ namespace GemStone
       generic<class TKey, class TResult>
       array<ICqListener<TKey, TResult>^>^ CqAttributes<TKey, TResult>::getCqListeners( )
       {
-        gemfire::VectorOfCqListener vrr;
+        apache::geode::client::VectorOfCqListener vrr;
         NativePtr->getCqListeners( vrr );
         array<ICqListener<TKey, TResult>^>^ listners = gcnew array<ICqListener<TKey, TResult>^>( vrr.size( ) );
 
         for( int32_t index = 0; index < vrr.size( ); index++ )
         {
-          gemfire::CqListenerPtr& nativeptr( vrr[ index ] );
-          gemfire::ManagedCqListenerGeneric* mg_listener =
-            dynamic_cast<gemfire::ManagedCqListenerGeneric*>( nativeptr.ptr( ) );
+          apache::geode::client::CqListenerPtr& nativeptr( vrr[ index ] );
+          apache::geode::client::ManagedCqListenerGeneric* mg_listener =
+            dynamic_cast<apache::geode::client::ManagedCqListenerGeneric*>( nativeptr.ptr( ) );
           if (mg_listener != nullptr)
           {
             listners[ index ] =  (ICqListener<TKey, TResult>^) mg_listener->userptr( );
           }else 
           {
-            gemfire::ManagedCqStatusListenerGeneric* mg_statuslistener =
-              dynamic_cast<gemfire::ManagedCqStatusListenerGeneric*>( nativeptr.ptr( ) );
+            apache::geode::client::ManagedCqStatusListenerGeneric* mg_statuslistener =
+              dynamic_cast<apache::geode::client::ManagedCqStatusListenerGeneric*>( nativeptr.ptr( ) );
             if (mg_statuslistener != nullptr) {
               listners[ index ] =  (ICqStatusListener<TKey, TResult>^) mg_statuslistener->userptr( );
             }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqAttributes.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqAttributes.hpp b/src/clicache/src/CqAttributes.hpp
index 5c234a8..4b82f79 100644
--- a/src/clicache/src/CqAttributes.hpp
+++ b/src/clicache/src/CqAttributes.hpp
@@ -38,7 +38,7 @@ namespace GemStone
       /// </summary>
       generic<class TKey, class TResult>
       public ref class CqAttributes sealed
-        : public Internal::SBWrap<gemfire::CqAttributes>
+        : public Internal::SBWrap<apache::geode::client::CqAttributes>
       {
       public:
 
@@ -57,7 +57,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqAttributes<TKey, TResult>^ Create( gemfire::CqAttributes* nativeptr )
+        inline static CqAttributes<TKey, TResult>^ Create( apache::geode::client::CqAttributes* nativeptr )
         {
           if (nativeptr == nullptr)
           {
@@ -73,7 +73,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqAttributes( gemfire::CqAttributes* nativeptr )
+        inline CqAttributes( apache::geode::client::CqAttributes* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqAttributesFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqAttributesFactory.cpp b/src/clicache/src/CqAttributesFactory.cpp
index 1ad1cdd..bdf2ebc 100644
--- a/src/clicache/src/CqAttributesFactory.cpp
+++ b/src/clicache/src/CqAttributesFactory.cpp
@@ -35,14 +35,14 @@ namespace GemStone
       generic<class TKey, class TResult>
       void CqAttributesFactory<TKey, TResult>::AddCqListener(Generic::ICqListener<TKey, TResult>^ cqListener )
       {
-        gemfire::CqListenerPtr listenerptr;
+        apache::geode::client::CqListenerPtr listenerptr;
         if ( cqListener != nullptr ) {
           ICqStatusListener<TKey, TResult>^ cqStatusListener = 
             dynamic_cast<ICqStatusListener<TKey, TResult>^>(cqListener);
           if (cqStatusListener != nullptr) {
             CqStatusListenerGeneric<TKey, TResult>^ sLstr = gcnew CqStatusListenerGeneric<TKey, TResult>();
             sLstr->AddCqListener(cqListener);
-            listenerptr = new gemfire::ManagedCqStatusListenerGeneric(cqListener);
+            listenerptr = new apache::geode::client::ManagedCqStatusListenerGeneric(cqListener);
             try {
               CqListenerHelper<TKey, TResult>::g_readerWriterLock->AcquireWriterLock(-1);
               if ( CqListenerHelper<TKey, TResult>::m_ManagedVsUnManagedCqLstrDict->ContainsKey( cqListener) ) {
@@ -54,14 +54,14 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqStatusListenerGeneric*)listenerptr.ptr())->setptr(sLstr);
+            ((apache::geode::client::ManagedCqStatusListenerGeneric*)listenerptr.ptr())->setptr(sLstr);
           }
           else {
             //TODO::split
             CqListenerGeneric<TKey, TResult>^ cqlg = gcnew CqListenerGeneric<TKey, TResult>();
             cqlg->AddCqListener(cqListener);
-            //listenerptr = new gemfire::ManagedCqListenerGeneric((ICqListener<Object^, Object^>^)cqListener );
-            listenerptr = new gemfire::ManagedCqListenerGeneric( /*clg,*/ cqListener );
+            //listenerptr = new apache::geode::client::ManagedCqListenerGeneric((ICqListener<Object^, Object^>^)cqListener );
+            listenerptr = new apache::geode::client::ManagedCqListenerGeneric( /*clg,*/ cqListener );
             try {
               CqListenerHelper<TKey, TResult>::g_readerWriterLock->AcquireWriterLock(-1);
               if ( CqListenerHelper<TKey, TResult>::m_ManagedVsUnManagedCqLstrDict->ContainsKey( cqListener) ) {
@@ -73,7 +73,7 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqListenerGeneric*)listenerptr.ptr())->setptr(cqlg);
+            ((apache::geode::client::ManagedCqListenerGeneric*)listenerptr.ptr())->setptr(cqlg);
           }
         }
 
@@ -83,12 +83,12 @@ namespace GemStone
       generic<class TKey, class TResult>
       void CqAttributesFactory<TKey, TResult>::InitCqListeners(array<Generic::ICqListener<TKey, TResult>^>^ cqListeners)
       {
-        gemfire::VectorOfCqListener vrr;
+        apache::geode::client::VectorOfCqListener vrr;
         for( int i = 0; i < cqListeners->Length; i++ )
         {
           ICqStatusListener<TKey, TResult>^ lister = dynamic_cast<ICqStatusListener<TKey, TResult>^>(cqListeners[i]);
           if (lister != nullptr) {
-            gemfire::CqStatusListenerPtr cptr(new gemfire::ManagedCqStatusListenerGeneric(
+            apache::geode::client::CqStatusListenerPtr cptr(new apache::geode::client::ManagedCqStatusListenerGeneric(
               (ICqStatusListener<TKey, TResult>^)lister ));
             vrr.push_back(cptr);
             CqStatusListenerGeneric<TKey, TResult>^ cqlg = gcnew CqStatusListenerGeneric<TKey, TResult>();
@@ -104,11 +104,11 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqStatusListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
+            ((apache::geode::client::ManagedCqStatusListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
           }
           else {
             ICqListener<TKey, TResult>^ lister = cqListeners[i];
-            gemfire::CqListenerPtr cptr(new gemfire::ManagedCqListenerGeneric(
+            apache::geode::client::CqListenerPtr cptr(new apache::geode::client::ManagedCqListenerGeneric(
               (ICqListener<TKey, TResult>^)lister ));
             vrr.push_back(cptr);
             CqListenerGeneric<TKey, TResult>^ cqlg = gcnew CqListenerGeneric<TKey, TResult>();
@@ -124,7 +124,7 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
+            ((apache::geode::client::ManagedCqListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
           }
         }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqAttributesFactory.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqAttributesFactory.hpp b/src/clicache/src/CqAttributesFactory.hpp
index e9a837c..4ffba8b 100644
--- a/src/clicache/src/CqAttributesFactory.hpp
+++ b/src/clicache/src/CqAttributesFactory.hpp
@@ -47,7 +47,7 @@ namespace GemStone
       /// <seealso cref="CqAttributes" />
       generic<class TKey, class TResult>
       public ref class CqAttributesFactory sealed
-        : public Internal::UMWrap<gemfire::CqAttributesFactory>
+        : public Internal::UMWrap<apache::geode::client::CqAttributesFactory>
       {
       public:
 
@@ -56,11 +56,11 @@ namespace GemStone
         /// to create a <c>CqAttributes</c> with default settings.
         /// </summary>
         inline CqAttributesFactory( )
-          : UMWrap( new gemfire::CqAttributesFactory( ), true )
+          : UMWrap( new apache::geode::client::CqAttributesFactory( ), true )
         { }
 
         inline CqAttributesFactory(Generic::CqAttributes<TKey, TResult>^ cqAttributes )
-          : UMWrap( new gemfire::CqAttributesFactory(gemfire::CqAttributesPtr(GetNativePtrFromSBWrapGeneric<gemfire::CqAttributes>(cqAttributes ))), true )
+          : UMWrap( new apache::geode::client::CqAttributesFactory(apache::geode::client::CqAttributesPtr(GetNativePtrFromSBWrapGeneric<apache::geode::client::CqAttributes>(cqAttributes ))), true )
         { }
 
         // ATTRIBUTES

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqAttributesMutator.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqAttributesMutator.cpp b/src/clicache/src/CqAttributesMutator.cpp
index 0536df0..bc11d36 100644
--- a/src/clicache/src/CqAttributesMutator.cpp
+++ b/src/clicache/src/CqAttributesMutator.cpp
@@ -34,14 +34,14 @@ namespace GemStone
       generic<class TKey, class TResult>
       void CqAttributesMutator<TKey, TResult>::AddCqListener( Generic::ICqListener<TKey, TResult>^ cqListener )
       {
-        gemfire::CqListenerPtr listenerptr;
+        apache::geode::client::CqListenerPtr listenerptr;
         if ( cqListener != nullptr ) {
           ICqStatusListener<TKey, TResult>^ cqStatusListener = 
             dynamic_cast<ICqStatusListener<TKey, TResult>^>(cqListener);
           if (cqStatusListener != nullptr) {
             CqStatusListenerGeneric<TKey, TResult>^ sLstr = gcnew CqStatusListenerGeneric<TKey, TResult>();
             sLstr->AddCqListener(cqListener);
-            listenerptr = new gemfire::ManagedCqStatusListenerGeneric(cqListener);
+            listenerptr = new apache::geode::client::ManagedCqStatusListenerGeneric(cqListener);
             try {
               CqListenerHelper<TKey, TResult>::g_readerWriterLock->AcquireWriterLock(-1);
               if ( CqListenerHelper<TKey, TResult>::m_ManagedVsUnManagedCqLstrDict->ContainsKey(cqListener) ) {
@@ -54,14 +54,14 @@ namespace GemStone
             finally {
               CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqStatusListenerGeneric*)listenerptr.ptr())->setptr(sLstr);
+            ((apache::geode::client::ManagedCqStatusListenerGeneric*)listenerptr.ptr())->setptr(sLstr);
           }
           else {
             //TODO::split
             CqListenerGeneric<TKey, TResult>^ cqlg = gcnew CqListenerGeneric<TKey, TResult>();
             cqlg->AddCqListener(cqListener);
-            //listenerptr = new gemfire::ManagedCqListenerGeneric((ICqListener<Object^, Object^>^)cqListener );
-            listenerptr = new gemfire::ManagedCqListenerGeneric( /*clg,*/ cqListener );
+            //listenerptr = new apache::geode::client::ManagedCqListenerGeneric((ICqListener<Object^, Object^>^)cqListener );
+            listenerptr = new apache::geode::client::ManagedCqListenerGeneric( /*clg,*/ cqListener );
             try {
               CqListenerHelper<TKey, TResult>::g_readerWriterLock->AcquireWriterLock(-1);
               if ( CqListenerHelper<TKey, TResult>::m_ManagedVsUnManagedCqLstrDict->ContainsKey(cqListener) ) {
@@ -73,7 +73,7 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqListenerGeneric*)listenerptr.ptr())->setptr(cqlg);            
+            ((apache::geode::client::ManagedCqListenerGeneric*)listenerptr.ptr())->setptr(cqlg);            
           }
         }
         NativePtr->addCqListener( listenerptr );
@@ -86,14 +86,14 @@ namespace GemStone
         if (lister != nullptr) {
           CqStatusListenerGeneric<TKey, TResult>^ cqlg = gcnew CqStatusListenerGeneric<TKey, TResult>();
           cqlg->AddCqListener(cqListener);
-          gemfire::CqStatusListenerPtr lptr(new gemfire::ManagedCqStatusListenerGeneric(
+          apache::geode::client::CqStatusListenerPtr lptr(new apache::geode::client::ManagedCqStatusListenerGeneric(
           (Generic::ICqStatusListener<TKey, TResult>^) lister ));
-          ((gemfire::ManagedCqStatusListenerGeneric*)lptr.ptr())->setptr(cqlg);
+          ((apache::geode::client::ManagedCqStatusListenerGeneric*)lptr.ptr())->setptr(cqlg);
           try {
             IntPtr value;
             CqListenerHelper<TKey, TResult>::g_readerWriterLock->AcquireWriterLock(-1);
             if ( CqListenerHelper<TKey, TResult>::m_ManagedVsUnManagedCqLstrDict->TryGetValue(cqListener, value) ) {
-              gemfire::CqStatusListenerPtr lptr((gemfire::CqStatusListener*)value.ToPointer());
+              apache::geode::client::CqStatusListenerPtr lptr((apache::geode::client::CqStatusListener*)value.ToPointer());
               NativePtr->removeCqListener(lptr);
             }
           } finally {
@@ -103,14 +103,14 @@ namespace GemStone
         else {
           CqListenerGeneric<TKey, TResult>^ cqlg = gcnew CqListenerGeneric<TKey, TResult>();
           cqlg->AddCqListener(cqListener);
-          gemfire::CqListenerPtr lptr(new gemfire::ManagedCqListenerGeneric(
+          apache::geode::client::CqListenerPtr lptr(new apache::geode::client::ManagedCqListenerGeneric(
             (Generic::ICqListener<TKey, TResult>^) cqListener ));
-          ((gemfire::ManagedCqListenerGeneric*)lptr.ptr())->setptr(cqlg);
+          ((apache::geode::client::ManagedCqListenerGeneric*)lptr.ptr())->setptr(cqlg);
           try {
             IntPtr value;
             CqListenerHelper<TKey, TResult>::g_readerWriterLock->AcquireWriterLock(-1);
             if ( CqListenerHelper<TKey, TResult>::m_ManagedVsUnManagedCqLstrDict->TryGetValue(cqListener, value) ) {
-              gemfire::CqListenerPtr lptr((gemfire::CqListener*)value.ToPointer());
+              apache::geode::client::CqListenerPtr lptr((apache::geode::client::CqListener*)value.ToPointer());
               NativePtr->removeCqListener(lptr);
             } 
           } finally {
@@ -122,12 +122,12 @@ namespace GemStone
       generic<class TKey, class TResult>
       void CqAttributesMutator<TKey, TResult>::SetCqListeners(array<Generic::ICqListener<TKey, TResult>^>^ newListeners)
       {
-        gemfire::VectorOfCqListener vrr;
+        apache::geode::client::VectorOfCqListener vrr;
         for( int i = 0; i < newListeners->Length; i++ )
         {
           Generic::ICqStatusListener<TKey, TResult>^ lister = dynamic_cast<Generic::ICqStatusListener<TKey, TResult>^>(newListeners[i]);
           if (lister != nullptr) {
-            gemfire::CqStatusListenerPtr cptr(new gemfire::ManagedCqStatusListenerGeneric(
+            apache::geode::client::CqStatusListenerPtr cptr(new apache::geode::client::ManagedCqStatusListenerGeneric(
               (ICqStatusListener<TKey, TResult>^)lister ));
             vrr.push_back(cptr);
             CqStatusListenerGeneric<TKey, TResult>^ cqlg = gcnew CqStatusListenerGeneric<TKey, TResult>();
@@ -143,11 +143,11 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqStatusListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
+            ((apache::geode::client::ManagedCqStatusListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
           }
           else {
             Generic::ICqListener<TKey, TResult>^ lister = newListeners[i];
-            gemfire::CqListenerPtr cptr(new gemfire::ManagedCqListenerGeneric(
+            apache::geode::client::CqListenerPtr cptr(new apache::geode::client::ManagedCqListenerGeneric(
               (ICqListener<TKey, TResult>^)lister ));
             vrr.push_back(cptr);
             CqListenerGeneric<TKey, TResult>^ cqlg = gcnew CqListenerGeneric<TKey, TResult>();
@@ -163,7 +163,7 @@ namespace GemStone
             } finally {
                 CqListenerHelper<TKey, TResult>::g_readerWriterLock->ReleaseWriterLock();
             }
-            ((gemfire::ManagedCqListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
+            ((apache::geode::client::ManagedCqListenerGeneric*)vrr[i].ptr())->setptr(cqlg);
           }
         }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqAttributesMutator.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqAttributesMutator.hpp b/src/clicache/src/CqAttributesMutator.hpp
index 5fbe7a4..21d8bca 100644
--- a/src/clicache/src/CqAttributesMutator.hpp
+++ b/src/clicache/src/CqAttributesMutator.hpp
@@ -52,7 +52,7 @@ namespace GemStone
       /// </summary>
       generic<class TKey, class TResult>
       public ref class CqAttributesMutator sealed
-        : public Internal::SBWrap<gemfire::CqAttributesMutator>
+        : public Internal::SBWrap<apache::geode::client::CqAttributesMutator>
       {
       public:
 
@@ -87,7 +87,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Generic::CqAttributesMutator<TKey, TResult>^ Create( gemfire::CqAttributesMutator* nativeptr )
+        inline static Generic::CqAttributesMutator<TKey, TResult>^ Create( apache::geode::client::CqAttributesMutator* nativeptr )
         {
           if (nativeptr == nullptr)
           {
@@ -103,7 +103,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqAttributesMutator<TKey, TResult>( gemfire::CqAttributesMutator* nativeptr )
+        inline CqAttributesMutator<TKey, TResult>( apache::geode::client::CqAttributesMutator* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqEvent.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqEvent.cpp b/src/clicache/src/CqEvent.cpp
index 4aa16ef..1beb96e 100644
--- a/src/clicache/src/CqEvent.cpp
+++ b/src/clicache/src/CqEvent.cpp
@@ -32,7 +32,7 @@ namespace GemStone
       generic<class TKey, class TResult>
       CqQuery<TKey, TResult>^ CqEvent<TKey, TResult>::getCq( )
       {
-        gemfire::CqQueryPtr& cQueryptr( NativePtr->getCq( ) );
+        apache::geode::client::CqQueryPtr& cQueryptr( NativePtr->getCq( ) );
         return CqQuery<TKey, TResult>::Create( cQueryptr.ptr( ) );
       }
 
@@ -51,21 +51,21 @@ namespace GemStone
       generic<class TKey, class TResult>
       TKey CqEvent<TKey, TResult>::getKey( )
       {
-        gemfire::CacheableKeyPtr& keyptr( NativePtr->getKey( ) );
+        apache::geode::client::CacheableKeyPtr& keyptr( NativePtr->getKey( ) );
         return Serializable::GetManagedValueGeneric<TKey>(keyptr);
       }
 
       generic<class TKey, class TResult>
       TResult CqEvent<TKey, TResult>::getNewValue( )
       {
-        gemfire::CacheablePtr& valptr( NativePtr->getNewValue( ) );
+        apache::geode::client::CacheablePtr& valptr( NativePtr->getNewValue( ) );
         return Serializable::GetManagedValueGeneric<TResult>(valptr);
       }
 
       generic<class TKey, class TResult>
       array< Byte >^ CqEvent<TKey, TResult>::getDeltaValue( )
       {
-        gemfire::CacheableBytesPtr deltaBytes = NativePtr->getDeltaValue( );
+        apache::geode::client::CacheableBytesPtr deltaBytes = NativePtr->getDeltaValue( );
         CacheableBytes^ managedDeltaBytes = ( CacheableBytes^ ) CacheableBytes::Create( deltaBytes.ptr( ) );
         return ( array< Byte >^ ) managedDeltaBytes;
       }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqEvent.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqEvent.hpp b/src/clicache/src/CqEvent.hpp
index 7986400..09f58c4 100644
--- a/src/clicache/src/CqEvent.hpp
+++ b/src/clicache/src/CqEvent.hpp
@@ -44,7 +44,7 @@ namespace GemStone
       /// </summary>
       generic<class TKey, class TResult>
       public ref class CqEvent sealed
-        : public Internal::UMWrap<gemfire::CqEvent>
+        : public Internal::UMWrap<apache::geode::client::CqEvent>
       {
       public:
 
@@ -85,8 +85,8 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqEvent( const gemfire::CqEvent* nativeptr )
-          : UMWrap( const_cast<gemfire::CqEvent*>( nativeptr ), false ) { }
+        inline CqEvent( const apache::geode::client::CqEvent* nativeptr )
+          : UMWrap( const_cast<apache::geode::client::CqEvent*>( nativeptr ), false ) { }
       };
 
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqListener.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqListener.hpp b/src/clicache/src/CqListener.hpp
index 93d1f65..a74f640 100644
--- a/src/clicache/src/CqListener.hpp
+++ b/src/clicache/src/CqListener.hpp
@@ -36,12 +36,12 @@ namespace GemStone
 	//interface class ICqListener;
 
       /// <summary>
-      /// This class wraps the native C++ <c>gemfire::Serializable</c> objects
+      /// This class wraps the native C++ <c>apache::geode::client::Serializable</c> objects
       /// as managed <see cref="../../IGFSerializable" /> objects.
       /// </summary>
       generic<class TKey, class TResult>    
       public ref class CqListener
-        : public Internal::SBWrap<gemfire::CqListener>, public ICqListener<TKey, TResult>
+        : public Internal::SBWrap<apache::geode::client::CqListener>, public ICqListener<TKey, TResult>
       {
       public:
 
@@ -78,7 +78,7 @@ namespace GemStone
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqListener<TKey, TResult>( gemfire::CqListener* nativeptr )
+        inline CqListener<TKey, TResult>( apache::geode::client::CqListener* nativeptr )
           : SBWrap( nativeptr ) { }
 
         /// <summary>
@@ -88,7 +88,7 @@ namespace GemStone
         /// Note the order of preserveSB() and releaseSB(). This handles the
         /// corner case when <c>m_nativeptr</c> is same as <c>nativeptr</c>.
         /// </remarks>
-        inline void AssignSP( gemfire::CqListener* nativeptr )
+        inline void AssignSP( apache::geode::client::CqListener* nativeptr )
         {
           AssignPtr( nativeptr );
         }
@@ -96,7 +96,7 @@ namespace GemStone
         /// <summary>
         /// Used to assign the native CqListener pointer to a new object.
         /// </summary>
-        inline void SetSP( gemfire::CqListener* nativeptr )
+        inline void SetSP( apache::geode::client::CqListener* nativeptr )
         {
           if ( nativeptr != nullptr ) {
             nativeptr->preserveSB( );

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqOperation.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqOperation.hpp b/src/clicache/src/CqOperation.hpp
index 4f2570a..a1cb017 100644
--- a/src/clicache/src/CqOperation.hpp
+++ b/src/clicache/src/CqOperation.hpp
@@ -46,28 +46,28 @@ namespace GemStone
         OP_TYPE_MARKER = 32
       };
 	public ref class CqOperation sealed
-        : public Internal::UMWrap<gemfire::CqOperation>
+        : public Internal::UMWrap<apache::geode::client::CqOperation>
       {
       public:
 
       /// <summary>
       /// conenience function for convertin from c++ 
-      /// gemfire::CqOperation::CqOperationType to
+      /// apache::geode::client::CqOperation::CqOperationType to
       /// CqOperationType here.
       /// </summary>
-	  inline static CqOperationType ConvertFromNative(gemfire::CqOperation::CqOperationType tp)
+	  inline static CqOperationType ConvertFromNative(apache::geode::client::CqOperation::CqOperationType tp)
 	  {
-		  if(tp==gemfire::CqOperation::OP_TYPE_CREATE)
+		  if(tp==apache::geode::client::CqOperation::OP_TYPE_CREATE)
 			  return CqOperationType::OP_TYPE_CREATE;
-  		  if(tp==gemfire::CqOperation::OP_TYPE_UPDATE)
+  		  if(tp==apache::geode::client::CqOperation::OP_TYPE_UPDATE)
 			  return CqOperationType::OP_TYPE_UPDATE;
-		  if(tp==gemfire::CqOperation::OP_TYPE_INVALIDATE)
+		  if(tp==apache::geode::client::CqOperation::OP_TYPE_INVALIDATE)
 			  return CqOperationType::OP_TYPE_INVALIDATE;
-		  if(tp==gemfire::CqOperation::OP_TYPE_REGION_CLEAR)
+		  if(tp==apache::geode::client::CqOperation::OP_TYPE_REGION_CLEAR)
 			  return CqOperationType::OP_TYPE_REGION_CLEAR;
-  		  if(tp==gemfire::CqOperation::OP_TYPE_DESTROY)
+  		  if(tp==apache::geode::client::CqOperation::OP_TYPE_DESTROY)
 			  return CqOperationType::OP_TYPE_DESTROY;
-  		  if(tp==gemfire::CqOperation::OP_TYPE_MARKER)
+  		  if(tp==apache::geode::client::CqOperation::OP_TYPE_MARKER)
 			  return CqOperationType::OP_TYPE_MARKER;
 		  return CqOperationType::OP_TYPE_INVALID;
 	  }
@@ -77,7 +77,7 @@ namespace GemStone
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqOperation( gemfire::CqOperation* nativeptr )
+        inline CqOperation( apache::geode::client::CqOperation* nativeptr )
 		            : UMWrap( nativeptr, false ) { }
 	  };
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqQuery.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqQuery.cpp b/src/clicache/src/CqQuery.cpp
index ed431b2..3fdee08 100644
--- a/src/clicache/src/CqQuery.cpp
+++ b/src/clicache/src/CqQuery.cpp
@@ -46,15 +46,15 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CqResultsPtr& nativeptr =
+          apache::geode::client::CqResultsPtr& nativeptr =
             NativePtr->executeWithInitialResults(timeout);
           if (nativeptr.ptr() == NULL) return nullptr;
 
-          gemfire::ResultSet* resultptr = dynamic_cast<gemfire::ResultSet*>(
+          apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
             nativeptr.ptr( ) );
           if ( resultptr == NULL )
           {
-            gemfire::StructSet* structptr = dynamic_cast<gemfire::StructSet*>(
+            apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
               nativeptr.ptr( ) );
             if ( structptr == NULL )
             {
@@ -121,23 +121,23 @@ namespace GemStone
       generic<class TKey, class TResult>
       CqStateType CqQuery<TKey, TResult>::GetState( )
       {
-        gemfire::CqState::StateType st =  NativePtr->getState( );
+        apache::geode::client::CqState::StateType st =  NativePtr->getState( );
         CqStateType state;
         switch (st)
         {
-          case gemfire::CqState::STOPPED: {
+          case apache::geode::client::CqState::STOPPED: {
             state = CqStateType::STOPPED;
             break;
           }
-          case gemfire::CqState::RUNNING: {
+          case apache::geode::client::CqState::RUNNING: {
             state = CqStateType::RUNNING;
             break;
           }
-          case gemfire::CqState::CLOSED: {
+          case apache::geode::client::CqState::CLOSED: {
             state = CqStateType::CLOSED;
             break;
           }
-          case gemfire::CqState::CLOSING: {
+          case apache::geode::client::CqState::CLOSING: {
             state = CqStateType::CLOSING;
             break;
           }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqQuery.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqQuery.hpp b/src/clicache/src/CqQuery.hpp
index 8d21033..3f51aef 100644
--- a/src/clicache/src/CqQuery.hpp
+++ b/src/clicache/src/CqQuery.hpp
@@ -62,7 +62,7 @@ namespace GemStone
       /// </remarks>
       generic<class TKey, class TResult>
       public ref class CqQuery sealed
-        : public Internal::SBWrap<gemfire::CqQuery>
+        : public Internal::SBWrap<apache::geode::client::CqQuery>
       {
       public:
 
@@ -165,7 +165,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqQuery<TKey, TResult>^ Create( gemfire::CqQuery* nativeptr )
+        inline static CqQuery<TKey, TResult>^ Create( apache::geode::client::CqQuery* nativeptr )
         {
           if (nativeptr == nullptr)
           {
@@ -181,7 +181,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqQuery( gemfire::CqQuery* nativeptr )
+        inline CqQuery( apache::geode::client::CqQuery* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqServiceStatistics.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqServiceStatistics.hpp b/src/clicache/src/CqServiceStatistics.hpp
index 2286829..a324810 100644
--- a/src/clicache/src/CqServiceStatistics.hpp
+++ b/src/clicache/src/CqServiceStatistics.hpp
@@ -33,7 +33,7 @@ namespace GemStone
       /// Defines common statistical information for cqservice 
       /// </summary>
       public ref class CqServiceStatistics sealed
-        : public Internal::SBWrap<gemfire::CqServiceStatistics>
+        : public Internal::SBWrap<apache::geode::client::CqServiceStatistics>
       {
       public:
 
@@ -75,7 +75,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqServiceStatistics^ Create( gemfire::CqServiceStatistics* nativeptr )
+        inline static CqServiceStatistics^ Create( apache::geode::client::CqServiceStatistics* nativeptr )
         {
           if (nativeptr == nullptr)
           {
@@ -91,7 +91,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqServiceStatistics( gemfire::CqServiceStatistics* nativeptr )
+        inline CqServiceStatistics( apache::geode::client::CqServiceStatistics* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqState.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqState.cpp b/src/clicache/src/CqState.cpp
index 1dd3441..10fc2a6 100644
--- a/src/clicache/src/CqState.cpp
+++ b/src/clicache/src/CqState.cpp
@@ -57,30 +57,30 @@ namespace GemStone
 
       void CqState::SetState( CqStateType state )
       {
-		  gemfire::CqState::StateType st =gemfire::CqState::INVALID;
+		  apache::geode::client::CqState::StateType st =apache::geode::client::CqState::INVALID;
 		  if(state == CqStateType::STOPPED)
-			  st = gemfire::CqState::STOPPED;
+			  st = apache::geode::client::CqState::STOPPED;
 		  else if(state == CqStateType::RUNNING)
-			  st = gemfire::CqState::RUNNING;
+			  st = apache::geode::client::CqState::RUNNING;
 		  else if(state == CqStateType::CLOSED)
-			  st = gemfire::CqState::CLOSED;
+			  st = apache::geode::client::CqState::CLOSED;
 		  else if(state == CqStateType::CLOSING)
-			  st = gemfire::CqState::CLOSING;
+			  st = apache::geode::client::CqState::CLOSING;
 
 		  NativePtr->setState( st );
       }
 
       CqStateType CqState::GetState( )
       {
-		gemfire::CqState::StateType st =  NativePtr->getState( );
+		apache::geode::client::CqState::StateType st =  NativePtr->getState( );
         CqStateType state;
-		if(st==gemfire::CqState::STOPPED)
+		if(st==apache::geode::client::CqState::STOPPED)
 			state = CqStateType::STOPPED;
-		else if(st==gemfire::CqState::RUNNING)
+		else if(st==apache::geode::client::CqState::RUNNING)
 			state = CqStateType::RUNNING;
-		else if(st==gemfire::CqState::CLOSED)
+		else if(st==apache::geode::client::CqState::CLOSED)
 			state = CqStateType::CLOSED;
-		else if(st==gemfire::CqState::CLOSING)
+		else if(st==apache::geode::client::CqState::CLOSING)
 			state = CqStateType::CLOSING;
 		else
 			state = CqStateType::INVALID;

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqState.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqState.hpp b/src/clicache/src/CqState.hpp
index 51e3588..3973a7e 100644
--- a/src/clicache/src/CqState.hpp
+++ b/src/clicache/src/CqState.hpp
@@ -50,7 +50,7 @@ namespace GemStone
       /// Static class containing convenience methods for <c>CqState</c>.
       /// </summary>
       public ref class CqState sealed
-        : public Internal::UMWrap<gemfire::CqState>
+        : public Internal::UMWrap<apache::geode::client::CqState>
       {
       public:
 
@@ -87,7 +87,7 @@ namespace GemStone
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqState( gemfire::CqState* nativeptr )
+        inline CqState( apache::geode::client::CqState* nativeptr )
 		            : UMWrap( nativeptr, false ) { }
 
       };

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/CqStatistics.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CqStatistics.hpp b/src/clicache/src/CqStatistics.hpp
index f5a27e6..c67b240 100644
--- a/src/clicache/src/CqStatistics.hpp
+++ b/src/clicache/src/CqStatistics.hpp
@@ -33,7 +33,7 @@ namespace GemStone
       /// Defines common statistical information for a cq.
       /// </summary>
       public ref class CqStatistics sealed
-        : public Internal::SBWrap<gemfire::CqStatistics>
+        : public Internal::SBWrap<apache::geode::client::CqStatistics>
       {
       public:
 
@@ -67,7 +67,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static CqStatistics^ Create( gemfire::CqStatistics* nativeptr )
+        inline static CqStatistics^ Create( apache::geode::client::CqStatistics* nativeptr )
         {
           if (nativeptr == nullptr)
           {
@@ -83,7 +83,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline CqStatistics( gemfire::CqStatistics* nativeptr )
+        inline CqStatistics( apache::geode::client::CqStatistics* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 


Mime
View raw message