geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [20/50] [abbrv] geode git commit: GEODE-2316: Rename namespace gemfire to apache::geode::client.
Date Mon, 23 Jan 2017 19:17:12 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Region.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Region.cpp b/src/clicache/src/Region.cpp
index 546b8f1..bd19cfd 100644
--- a/src/clicache/src/Region.cpp
+++ b/src/clicache/src/Region.cpp
@@ -46,10 +46,10 @@ namespace GemStone
       generic<class TKey, class TValue>
       TValue Region<TKey, TValue>::Get(TKey key, Object^ callbackArg)
       {
-        gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );        
-        gemfire::UserDataPtr callbackptr(
+        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );        
+        apache::geode::client::UserDataPtr callbackptr(
           Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
-        gemfire::CacheablePtr nativeptr(this->get(keyptr, callbackptr));
+        apache::geode::client::CacheablePtr nativeptr(this->get(keyptr, callbackptr));
         if (nativeptr == NULLPTR)
         {
           throw gcnew KeyNotFoundException("The given key was not present in the region.");
@@ -60,7 +60,7 @@ namespace GemStone
       }
       
       generic<class TKey, class TValue>
-      gemfire::SerializablePtr Region<TKey, TValue>::get(gemfire::CacheableKeyPtr& keyptr, gemfire::SerializablePtr& callbackptr)
+      apache::geode::client::SerializablePtr Region<TKey, TValue>::get(apache::geode::client::CacheableKeyPtr& keyptr, apache::geode::client::SerializablePtr& callbackptr)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           return NativePtr->get( keyptr, callbackptr ) ;
@@ -68,7 +68,7 @@ namespace GemStone
       }
 
       generic<class TKey, class TValue>
-      gemfire::SerializablePtr Region<TKey, TValue>::get(gemfire::CacheableKeyPtr& keyptr)
+      apache::geode::client::SerializablePtr Region<TKey, TValue>::get(apache::geode::client::CacheableKeyPtr& keyptr)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           return NativePtr->get( keyptr ) ;
@@ -96,9 +96,9 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-        gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );                
-          gemfire::UserDataPtr callbackptr(
+        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+        apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );                
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
           NativePtr->put( keyptr, valueptr, callbackptr );       
 
@@ -108,8 +108,8 @@ namespace GemStone
       generic<class TKey, class TValue>
       TValue Region<TKey, TValue>::default::get(TKey key)
       {  
-        gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-        gemfire::CacheablePtr nativeptr(this->get(keyptr));
+        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+        apache::geode::client::CacheablePtr nativeptr(this->get(keyptr));
         if (nativeptr == NULLPTR)
         {
           throw gcnew KeyNotFoundException("The given key was not present in the region.");
@@ -123,8 +123,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-        gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );
+        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+        apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );
         NativePtr->put( keyptr, valueptr );
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -135,7 +135,7 @@ namespace GemStone
         Region<TKey, TValue>::GetEnumerator()
       {
         array<KeyValuePair<TKey,TValue>>^ toArray;
-        gemfire::VectorOfRegionEntry vc;
+        apache::geode::client::VectorOfRegionEntry vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -147,7 +147,7 @@ namespace GemStone
 
         for( int32_t index = 0; index < vc.size( ); index++ )
         {
-          gemfire::RegionEntryPtr nativeptr =  vc[ index ];  
+          apache::geode::client::RegionEntryPtr nativeptr =  vc[ index ];  
           TKey key = Serializable::GetManagedValueGeneric<TKey> (nativeptr->getKey());
           TValue val = Serializable::GetManagedValueGeneric<TValue> (nativeptr->getValue());
           toArray[ index ] = KeyValuePair<TKey,TValue>(key, val);           
@@ -160,7 +160,7 @@ namespace GemStone
         Region<TKey, TValue>::GetEnumeratorOld()
       {
         array<Object^>^ toArray;
-        gemfire::VectorOfRegionEntry vc;
+        apache::geode::client::VectorOfRegionEntry vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -172,7 +172,7 @@ namespace GemStone
 
         for( int32_t index = 0; index < vc.size( ); index++ )
         {
-          gemfire::RegionEntryPtr nativeptr =  vc[ index ];                       
+          apache::geode::client::RegionEntryPtr nativeptr =  vc[ index ];                       
           TKey key = Serializable::GetManagedValueGeneric<TKey> (nativeptr->getKey());
           TValue val = Serializable::GetManagedValueGeneric<TValue> (nativeptr->getValue());            
           toArray[ index ] = KeyValuePair<TKey,TValue>(key, val);           
@@ -181,7 +181,7 @@ namespace GemStone
       }
 
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::AreValuesEqual(gemfire::CacheablePtr& val1, gemfire::CacheablePtr& val2)
+      bool Region<TKey, TValue>::AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2)
       {
         if ( val1 == NULLPTR && val2 == NULLPTR )
         {          
@@ -197,8 +197,8 @@ namespace GemStone
           {            
             return false;
           }
-          gemfire::DataOutput out1;
-          gemfire::DataOutput out2;
+          apache::geode::client::DataOutput out1;
+          apache::geode::client::DataOutput out2;
           val1->toData(out1);
           val2->toData(out2);
           if ( out1.getBufferLength() != out2.getBufferLength() )
@@ -217,8 +217,8 @@ namespace GemStone
       generic<class TKey, class TValue> 
       bool Region<TKey, TValue>::Contains(KeyValuePair<TKey,TValue> keyValuePair) 
       { 
-        gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) ); 
-        gemfire::CacheablePtr nativeptr(this->get(keyptr)); 
+        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) ); 
+        apache::geode::client::CacheablePtr nativeptr(this->get(keyptr)); 
         //This means that key is not present.
         if (nativeptr == NULLPTR) {
           return false;
@@ -232,7 +232,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );          
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );          
 
           return NativePtr->containsKeyOnServer( keyptr );
 
@@ -243,8 +243,8 @@ namespace GemStone
       bool Region<TKey, TValue>::TryGetValue(TKey key, TValue %val)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-        gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-        gemfire::CacheablePtr nativeptr(this->get(keyptr));
+        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+        apache::geode::client::CacheablePtr nativeptr(this->get(keyptr));
         if (nativeptr == NULLPTR) {            
           val = TValue();
           return false;
@@ -262,14 +262,14 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        gemfire::VectorOfCacheableKey vc;
+        apache::geode::client::VectorOfCacheableKey vc;
         NativePtr->serverKeys( vc );
         //List<TKey>^ collectionlist = gcnew List<TKey>(vc.size());
         array<TKey>^ keyarr =
           gcnew array<TKey>( vc.size( ) );
         for( int32_t index = 0; index < vc.size( ); index++ )
         {            
-          gemfire::CacheableKeyPtr& nativeptr( vc[ index ] );
+          apache::geode::client::CacheableKeyPtr& nativeptr( vc[ index ] );
           keyarr[ index ] = Serializable::GetManagedValueGeneric<TKey>(nativeptr);
           //collectionlist[ index ] = Serializable::GetManagedValue<TKey>(nativeptr);
         }
@@ -285,14 +285,14 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::VectorOfCacheable vc;
+          apache::geode::client::VectorOfCacheable vc;
           NativePtr->values( vc );
           //List<TValue>^ collectionlist = gcnew List<TValue>(vc.size());
           array<TValue>^ valarr =
             gcnew array<TValue>( vc.size( ) );
           for( int32_t index = 0; index < vc.size( ); index++ )
           {
-            gemfire::CacheablePtr& nativeptr( vc[ index ] );            
+            apache::geode::client::CacheablePtr& nativeptr( vc[ index ] );            
             valarr[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
             //collectionlist[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
           }
@@ -308,8 +308,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-          gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+          apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );
           NativePtr->create( keyptr, valueptr );
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -320,8 +320,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) );
-          gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value ) );
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) );
+          apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value ) );
           NativePtr->create( keyptr, valueptr );
 
        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -332,9 +332,9 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-          gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );          
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+          apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );          
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
           NativePtr->create( keyptr, valueptr, callbackptr );
 
@@ -346,7 +346,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );          
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );          
           return NativePtr->removeEx( keyptr );
           
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -358,8 +358,8 @@ namespace GemStone
       {
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                    
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                    
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
           return NativePtr->removeEx( keyptr, callbackptr );
           
@@ -371,8 +371,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) );                  
-          gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value ) );
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) );                  
+          apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value ) );
 
           return NativePtr->remove(keyptr, valueptr);
 
@@ -384,9 +384,9 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                   
-          gemfire::CacheablePtr valueptr ( Serializable::GetUnmanagedValueGeneric<TValue>( value ));                    
-          gemfire::UserDataPtr callbackptr( Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );          
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                   
+          apache::geode::client::CacheablePtr valueptr ( Serializable::GetUnmanagedValueGeneric<TValue>( value ));                    
+          apache::geode::client::UserDataPtr callbackptr( Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );          
           return NativePtr->remove(keyptr, valueptr, callbackptr);
 
          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -407,7 +407,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
                     
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
           NativePtr->invalidateRegion( callbackptr );
                 
@@ -429,7 +429,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
           NativePtr->destroyRegion( callbackptr );
 
@@ -452,8 +452,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                    
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                    
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );            
           NativePtr->invalidate( keyptr, callbackptr );
           
@@ -476,11 +476,11 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::HashMapOfCacheable nativeMap;
+          apache::geode::client::HashMapOfCacheable nativeMap;
           for each ( KeyValuePair<TKey, TValue> keyValPair in map )
           {
-            gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValPair.Key ) );
-            gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValPair.Value ) );
+            apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValPair.Key ) );
+            apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValPair.Value ) );
             nativeMap.insert( keyptr, valueptr );
           }
           NativePtr->putAll( nativeMap, timeout );
@@ -494,14 +494,14 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::HashMapOfCacheable nativeMap;
+          apache::geode::client::HashMapOfCacheable nativeMap;
           for each ( KeyValuePair<TKey, TValue> keyValPair in map )
           {
-            gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValPair.Key ) );
-            gemfire::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValPair.Value ) );
+            apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValPair.Key ) );
+            apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValPair.Value ) );
             nativeMap.insert( keyptr, valueptr );
           }
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
           NativePtr->putAll( nativeMap, timeout, callbackptr );
 
@@ -531,7 +531,7 @@ namespace GemStone
         if (keys != nullptr) {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            gemfire::VectorOfCacheableKey vecKeys;
+            apache::geode::client::VectorOfCacheableKey vecKeys;
 
             for each(TKey item in keys)
             {
@@ -539,18 +539,18 @@ namespace GemStone
                 Serializable::GetUnmanagedValueGeneric<TKey>( item ));
             }
                         
-            gemfire::HashMapOfCacheablePtr valuesPtr(NULLPTR);
+            apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
             if (values != nullptr) {
-              valuesPtr = new gemfire::HashMapOfCacheable();
+              valuesPtr = new apache::geode::client::HashMapOfCacheable();
             }
-            gemfire::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
+            apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
             if (exceptions != nullptr) {
-              exceptionsPtr = new gemfire::HashMapOfException();
+              exceptionsPtr = new apache::geode::client::HashMapOfException();
             }
             NativePtr->getAll(vecKeys, valuesPtr, exceptionsPtr,
               addToLocalCache);            
             if (values != nullptr) {
-              for (gemfire::HashMapOfCacheable::Iterator iter =
+              for (apache::geode::client::HashMapOfCacheable::Iterator iter =
                 valuesPtr->begin(); iter != valuesPtr->end(); ++iter) {                                   
                   TKey key = Serializable::GetManagedValueGeneric<TKey>(iter.first());                  
                   TValue val = Serializable::GetManagedValueGeneric<TValue>( iter.second());                  
@@ -558,7 +558,7 @@ namespace GemStone
               }
             }
             if (exceptions != nullptr) {
-              for (gemfire::HashMapOfException::Iterator iter =
+              for (apache::geode::client::HashMapOfException::Iterator iter =
                 exceptionsPtr->begin(); iter != exceptionsPtr->end(); ++iter) {
                   TKey key = Serializable::GetManagedValueGeneric<TKey>(iter.first());                  
                   System::Exception^ ex = GemFireException::Get(*iter.second());                  
@@ -582,7 +582,7 @@ namespace GemStone
         if (keys != nullptr) {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            gemfire::VectorOfCacheableKey vecKeys;
+            apache::geode::client::VectorOfCacheableKey vecKeys;
 
             for each(TKey item in keys)
             {
@@ -590,22 +590,22 @@ namespace GemStone
                 Serializable::GetUnmanagedValueGeneric<TKey>( item ));
             }
                         
-            gemfire::HashMapOfCacheablePtr valuesPtr(NULLPTR);
+            apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
             if (values != nullptr) {
-              valuesPtr = new gemfire::HashMapOfCacheable();
+              valuesPtr = new apache::geode::client::HashMapOfCacheable();
             }
-            gemfire::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
+            apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
             if (exceptions != nullptr) {
-              exceptionsPtr = new gemfire::HashMapOfException();
+              exceptionsPtr = new apache::geode::client::HashMapOfException();
             }
 
-            gemfire::UserDataPtr callbackptr(
+            apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
 
             NativePtr->getAll(vecKeys, valuesPtr, exceptionsPtr,
               addToLocalCache, callbackptr);
             if (values != nullptr) {
-              for (gemfire::HashMapOfCacheable::Iterator iter =
+              for (apache::geode::client::HashMapOfCacheable::Iterator iter =
                 valuesPtr->begin(); iter != valuesPtr->end(); ++iter) {                             
                   TKey key = Serializable::GetManagedValueGeneric<TKey>(iter.first());
                   TValue val = Serializable::GetManagedValueGeneric<TValue>( iter.second());
@@ -613,7 +613,7 @@ namespace GemStone
               }
             }
             if (exceptions != nullptr) {
-              for (gemfire::HashMapOfException::Iterator iter =
+              for (apache::geode::client::HashMapOfException::Iterator iter =
                 exceptionsPtr->begin(); iter != exceptionsPtr->end(); ++iter) {
                   TKey key = Serializable::GetManagedValueGeneric<TKey>(iter.first());            
                   System::Exception^ ex = GemFireException::Get(*iter.second());            
@@ -645,11 +645,11 @@ namespace GemStone
       {
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
            
-         gemfire::VectorOfCacheableKey vecKeys;
+         apache::geode::client::VectorOfCacheableKey vecKeys;
          for each(TKey item in keys)
            vecKeys.push_back(Serializable::GetUnmanagedValueGeneric<TKey>( item ));
          
-         gemfire::UserDataPtr callbackptr(
+         apache::geode::client::UserDataPtr callbackptr(
             Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );   
          
          NativePtr->removeAll(vecKeys, callbackptr);
@@ -674,7 +674,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::RegionPtr& nativeptr( NativePtr->getParentRegion( ) );
+          apache::geode::client::RegionPtr& nativeptr( NativePtr->getParentRegion( ) );
 
           return Region::Create( nativeptr.ptr( ) );
 
@@ -686,7 +686,7 @@ namespace GemStone
       { 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        gemfire::RegionAttributesPtr& nativeptr( NativePtr->getAttributes( ) );
+        apache::geode::client::RegionAttributesPtr& nativeptr( NativePtr->getAttributes( ) );
 
         return GemStone::GemFire::Cache::Generic::RegionAttributes<TKey, TValue>::Create(nativeptr.ptr());
 
@@ -698,7 +698,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::AttributesMutatorPtr& nativeptr(
+          apache::geode::client::AttributesMutatorPtr& nativeptr(
             NativePtr->getAttributesMutator( ) );
 
         return GemStone::GemFire::Cache::Generic::AttributesMutator<TKey, TValue>::Create( nativeptr.ptr( ) );
@@ -711,7 +711,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        gemfire::CacheStatisticsPtr& nativeptr( NativePtr->getStatistics( ) );
+        apache::geode::client::CacheStatisticsPtr& nativeptr( NativePtr->getStatistics( ) );
         return GemStone::GemFire::Cache::Generic::CacheStatistics::Create( nativeptr.ptr( ) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -723,7 +723,7 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           ManagedString mg_path( path );
-          gemfire::RegionPtr& nativeptr(
+          apache::geode::client::RegionPtr& nativeptr(
             NativePtr->getSubregion( mg_path.CharPtr ) );
           return Region::Create( nativeptr.ptr( ) );
 
@@ -738,10 +738,10 @@ namespace GemStone
 
           ManagedString mg_subregionName( subRegionName );
 				//TODO:split
-          gemfire::RegionAttributesPtr p_attrs(
-            GetNativePtrFromSBWrapGeneric<gemfire::RegionAttributes>( attributes ) );
+          apache::geode::client::RegionAttributesPtr p_attrs(
+            GetNativePtrFromSBWrapGeneric<apache::geode::client::RegionAttributes>( attributes ) );
 
-          gemfire::RegionPtr& nativeptr( NativePtr->createSubregion(
+          apache::geode::client::RegionPtr& nativeptr( NativePtr->createSubregion(
             mg_subregionName.CharPtr, p_attrs /*NULLPTR*/ ) );
           return Region::Create( nativeptr.ptr( ) );
 
@@ -754,14 +754,14 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::VectorOfRegion vsr;
+          apache::geode::client::VectorOfRegion vsr;
           NativePtr->subregions( recursive, vsr );
           array<IRegion<TKey, TValue>^>^ subRegions =
             gcnew array<IRegion<TKey, TValue>^>( vsr.size( ) );
 
           for( int32_t index = 0; index < vsr.size( ); index++ )
           {
-            gemfire::RegionPtr& nativeptr( vsr[ index ] );
+            apache::geode::client::RegionPtr& nativeptr( vsr[ index ] );
             subRegions[ index ] = Region<TKey, TValue>::Create( nativeptr.ptr( ) );
           }
           System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ collection =
@@ -776,8 +776,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-          gemfire::RegionEntryPtr& nativeptr( NativePtr->getEntry( keyptr ) );
+          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+          apache::geode::client::RegionEntryPtr& nativeptr( NativePtr->getEntry( keyptr ) );
           return RegionEntry<TKey, TValue>::Create( nativeptr.ptr( ) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -788,13 +788,13 @@ namespace GemStone
       {
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::VectorOfRegionEntry vc;
+          apache::geode::client::VectorOfRegionEntry vc;
           NativePtr->entries( vc, recursive );          
           array<RegionEntry<TKey, TValue>^>^ entryarr = gcnew array<RegionEntry<TKey, TValue>^>( vc.size( ) );
 
           for( int32_t index = 0; index < vc.size( ); index++ )
           {
-            gemfire::RegionEntryPtr& nativeptr( vc[ index ] );
+            apache::geode::client::RegionEntryPtr& nativeptr( vc[ index ] );
             entryarr[ index ] = RegionEntry<TKey, TValue>::Create( nativeptr.ptr( ) );
           }
           System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^ collection =
@@ -811,13 +811,13 @@ namespace GemStone
       {        
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::RegionServicePtr& nativeptr( NativePtr->getRegionService( ) );
+          apache::geode::client::RegionServicePtr& nativeptr( NativePtr->getRegionService( ) );
 
-          gemfire::Cache* realCache = dynamic_cast<gemfire::Cache*>(nativeptr.ptr());
+          apache::geode::client::Cache* realCache = dynamic_cast<apache::geode::client::Cache*>(nativeptr.ptr());
 
           if(realCache != NULL)
           {
-            return GemStone::GemFire::Cache::Generic::Cache::Create( ((gemfire::CachePtr)nativeptr).ptr( ) );
+            return GemStone::GemFire::Cache::Generic::Cache::Create( ((apache::geode::client::CachePtr)nativeptr).ptr( ) );
           }
           else
           {
@@ -832,7 +832,7 @@ namespace GemStone
       {
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-           gemfire::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+           apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
            return NativePtr->containsValueForKey( keyptr );
 
          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -856,7 +856,7 @@ namespace GemStone
       void Region<TKey, TValue>::Clear(Object^ callbackArg)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-          gemfire::UserDataPtr callbackptr(
+          apache::geode::client::UserDataPtr callbackptr(
               Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );          
           NativePtr->clear(callbackptr );
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -877,7 +877,7 @@ namespace GemStone
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        gemfire::VectorOfRegionEntry vc;
+        apache::geode::client::VectorOfRegionEntry vc;
         NativePtr->entries( vc, false );        
 
         if (toArray->Rank > 1 || (vc.size() > (toArray->Length - startIdx)))
@@ -887,7 +887,7 @@ namespace GemStone
 
         for( int32_t index = 0; index < vc.size( ); index++ )
         {
-          gemfire::RegionEntryPtr nativeptr =  vc[ index ];                       
+          apache::geode::client::RegionEntryPtr nativeptr =  vc[ index ];                       
           TKey key = Serializable::GetManagedValueGeneric<TKey> (nativeptr->getKey());
           TValue val = Serializable::GetManagedValueGeneric<TValue> (nativeptr->getValue());            
           toArray[ startIdx ] = KeyValuePair<TKey,TValue>(key, val);
@@ -925,7 +925,7 @@ namespace GemStone
         {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            gemfire::VectorOfCacheableKey vecKeys;
+            apache::geode::client::VectorOfCacheableKey vecKeys;
 
             for each(TKey item in keys)
             {
@@ -945,7 +945,7 @@ namespace GemStone
         {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-            gemfire::VectorOfCacheableKey vecKeys;
+            apache::geode::client::VectorOfCacheableKey vecKeys;
 
             for each(TKey item in keys)
             {
@@ -988,8 +988,8 @@ namespace GemStone
          _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           if (resultKeys != nullptr) {
-            gemfire::VectorOfCacheableKeyPtr mg_keys(
-              new gemfire::VectorOfCacheableKey());
+            apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
+              new apache::geode::client::VectorOfCacheableKey());
 
             NativePtr->registerAllKeys(isDurable, mg_keys, getInitialValues, receiveValues);            
 
@@ -1010,14 +1010,14 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::VectorOfCacheableKey vc;
+          apache::geode::client::VectorOfCacheableKey vc;
           NativePtr->getInterestList( vc );
           //List<TValue>^ collectionlist = gcnew List<TValue>(vc.size());
           array<TKey>^ keyarr =
             gcnew array<TKey>( vc.size( ) );
           for( int32_t index = 0; index < vc.size( ); index++ )
           {
-            gemfire::CacheableKeyPtr& nativeptr( vc[ index ] );
+            apache::geode::client::CacheableKeyPtr& nativeptr( vc[ index ] );
             keyarr[ index ] = Serializable::GetManagedValueGeneric<TKey>(nativeptr);
             //collectionlist[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
           }
@@ -1034,7 +1034,7 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::VectorOfCacheableString vc;
+          apache::geode::client::VectorOfCacheableString vc;
           NativePtr->getInterestListRegex( vc );
           array<String^>^ strarr =
             gcnew array<String^>( vc.size( ) );
@@ -1096,8 +1096,8 @@ namespace GemStone
 
           ManagedString mg_regex( regex );
           if (resultKeys != nullptr) {
-            gemfire::VectorOfCacheableKeyPtr mg_keys(
-              new gemfire::VectorOfCacheableKey());
+            apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
+              new apache::geode::client::VectorOfCacheableKey());
             NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
               mg_keys, getInitialValues, receiveValues);
 
@@ -1135,15 +1135,15 @@ namespace GemStone
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::SelectResultsPtr& nativeptr = NativePtr->query(
+          apache::geode::client::SelectResultsPtr& nativeptr = NativePtr->query(
             mg_predicate.CharPtr, DEFAULT_QUERY_RESPONSE_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 )
             {
@@ -1167,15 +1167,15 @@ namespace GemStone
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::SelectResultsPtr& nativeptr = NativePtr->query(
+          apache::geode::client::SelectResultsPtr& nativeptr = NativePtr->query(
             mg_predicate.CharPtr, 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 )
             {
@@ -1222,7 +1222,7 @@ namespace GemStone
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::CacheablePtr& nativeptr( NativePtr->selectValue(
+          apache::geode::client::CacheablePtr& nativeptr( NativePtr->selectValue(
             mg_predicate.CharPtr, timeout ) );
 
           return Serializable::GetManagedValueGeneric<Object^>(nativeptr);

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Region.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Region.hpp b/src/clicache/src/Region.hpp
index 6eee6fa..005abac 100644
--- a/src/clicache/src/Region.hpp
+++ b/src/clicache/src/Region.hpp
@@ -40,7 +40,7 @@ namespace GemStone
      // ref class AttributesMutator;
 
       generic<class TKey, class TValue>
-			public ref class Region : public Internal::SBWrap<gemfire::Region>,
+			public ref class Region : public Internal::SBWrap<apache::geode::client::Region>,
         public IRegion<TKey, TValue>,
         public ISubscriptionService<TKey>
       {
@@ -271,7 +271,7 @@ namespace GemStone
         /// </returns>
         //generic<class TKey, class TValue>
         inline static GemStone::GemFire::Cache::Generic::IRegion<TKey, TValue>^
-        Create( gemfire::Region* nativeptr )
+        Create( apache::geode::client::Region* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew Region<TKey, TValue>( nativeptr ) : nullptr );
@@ -283,12 +283,12 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Region( gemfire::Region* nativeptr )
-					: SBWrap<gemfire::Region>( nativeptr ) { }
+        inline Region( apache::geode::client::Region* nativeptr )
+					: SBWrap<apache::geode::client::Region>( nativeptr ) { }
 
-        inline gemfire::SerializablePtr get(gemfire::CacheableKeyPtr& key, gemfire::SerializablePtr& callbackArg);
-        inline gemfire::SerializablePtr get(gemfire::CacheableKeyPtr& key);
-        bool AreValuesEqual(gemfire::CacheablePtr& val1, gemfire::CacheablePtr& val2);
+        inline apache::geode::client::SerializablePtr get(apache::geode::client::CacheableKeyPtr& key, apache::geode::client::SerializablePtr& callbackArg);
+        inline apache::geode::client::SerializablePtr get(apache::geode::client::CacheableKeyPtr& key);
+        bool AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2);
         bool isPoolInMultiuserMode();
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionAttributes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionAttributes.cpp b/src/clicache/src/RegionAttributes.cpp
index c1c7fb9..78df6d2 100644
--- a/src/clicache/src/RegionAttributes.cpp
+++ b/src/clicache/src/RegionAttributes.cpp
@@ -51,8 +51,8 @@ namespace GemStone
       void Generic::RegionAttributes<TKey, TValue>::ToData(
         GemStone::GemFire::Cache::Generic::DataOutput^ output )
       {
-        gemfire::DataOutput* nativeOutput =
-          GemStone::GemFire::Cache::Generic::GetNativePtrFromUMWrapGeneric<gemfire::DataOutput>( output );
+        apache::geode::client::DataOutput* nativeOutput =
+          GemStone::GemFire::Cache::Generic::GetNativePtrFromUMWrapGeneric<apache::geode::client::DataOutput>( output );
         if (nativeOutput != nullptr)
         {
           NativePtr->toData( *nativeOutput );
@@ -63,11 +63,11 @@ namespace GemStone
       GemStone::GemFire::Cache::Generic::IGFSerializable^ Generic::RegionAttributes<TKey, TValue>::FromData(
         GemStone::GemFire::Cache::Generic::DataInput^ input )
       {
-        gemfire::DataInput* nativeInput =
-          GemStone::GemFire::Cache::Generic::GetNativePtrFromUMWrapGeneric<gemfire::DataInput>( input );
+        apache::geode::client::DataInput* nativeInput =
+          GemStone::GemFire::Cache::Generic::GetNativePtrFromUMWrapGeneric<apache::geode::client::DataInput>( input );
         if (nativeInput != nullptr)
         {
-          AssignPtr( static_cast<gemfire::RegionAttributes*>(
+          AssignPtr( static_cast<apache::geode::client::RegionAttributes*>(
             NativePtr->fromData( *nativeInput ) ) );
         }
         return this;
@@ -76,9 +76,9 @@ namespace GemStone
       generic <class TKey, class TValue>
       ICacheLoader<TKey, TValue>^ Generic::RegionAttributes<TKey, TValue>::CacheLoader::get()
       {
-        gemfire::CacheLoaderPtr& loaderptr( NativePtr->getCacheLoader( ) );
-        gemfire::ManagedCacheLoaderGeneric* mg_loader =
-          dynamic_cast<gemfire::ManagedCacheLoaderGeneric*>( loaderptr.ptr( ) );
+        apache::geode::client::CacheLoaderPtr& loaderptr( NativePtr->getCacheLoader( ) );
+        apache::geode::client::ManagedCacheLoaderGeneric* mg_loader =
+          dynamic_cast<apache::geode::client::ManagedCacheLoaderGeneric*>( loaderptr.ptr( ) );
 
         if (mg_loader != nullptr)
         {
@@ -90,9 +90,9 @@ namespace GemStone
       generic <class TKey, class TValue>
       ICacheWriter<TKey, TValue>^ Generic::RegionAttributes<TKey, TValue>::CacheWriter::get()
       {
-        gemfire::CacheWriterPtr& writerptr( NativePtr->getCacheWriter( ) );
-        gemfire::ManagedCacheWriterGeneric* mg_writer =
-          dynamic_cast<gemfire::ManagedCacheWriterGeneric*>( writerptr.ptr( ) );
+        apache::geode::client::CacheWriterPtr& writerptr( NativePtr->getCacheWriter( ) );
+        apache::geode::client::ManagedCacheWriterGeneric* mg_writer =
+          dynamic_cast<apache::geode::client::ManagedCacheWriterGeneric*>( writerptr.ptr( ) );
 
         if (mg_writer != nullptr)
         {
@@ -104,9 +104,9 @@ namespace GemStone
       generic <class TKey, class TValue>
       ICacheListener<TKey, TValue>^ Generic::RegionAttributes<TKey, TValue>::CacheListener::get()
       {
-        gemfire::CacheListenerPtr& listenerptr( NativePtr->getCacheListener( ) );
-        gemfire::ManagedCacheListenerGeneric* mg_listener =
-          dynamic_cast<gemfire::ManagedCacheListenerGeneric*>( listenerptr.ptr( ) );
+        apache::geode::client::CacheListenerPtr& listenerptr( NativePtr->getCacheListener( ) );
+        apache::geode::client::ManagedCacheListenerGeneric* mg_listener =
+          dynamic_cast<apache::geode::client::ManagedCacheListenerGeneric*>( listenerptr.ptr( ) );
 
         if (mg_listener != nullptr)
         {
@@ -123,17 +123,17 @@ namespace GemStone
       generic <class TKey, class TValue>
       IPartitionResolver<TKey, TValue>^ Generic::RegionAttributes<TKey, TValue>::PartitionResolver::get()
       {
-        gemfire::PartitionResolverPtr& resolverptr( NativePtr->getPartitionResolver( ) );
-        gemfire::ManagedPartitionResolverGeneric* mg_resolver =
-          dynamic_cast<gemfire::ManagedPartitionResolverGeneric*>( resolverptr.ptr( ) );
+        apache::geode::client::PartitionResolverPtr& resolverptr( NativePtr->getPartitionResolver( ) );
+        apache::geode::client::ManagedPartitionResolverGeneric* mg_resolver =
+          dynamic_cast<apache::geode::client::ManagedPartitionResolverGeneric*>( resolverptr.ptr( ) );
 
         if (mg_resolver != nullptr)
         {
           return (IPartitionResolver<TKey, TValue>^)mg_resolver->userptr( );
         }
 
-        gemfire::ManagedFixedPartitionResolverGeneric* mg_fixedResolver =
-          dynamic_cast<gemfire::ManagedFixedPartitionResolverGeneric*>( resolverptr.ptr( ) );
+        apache::geode::client::ManagedFixedPartitionResolverGeneric* mg_fixedResolver =
+          dynamic_cast<apache::geode::client::ManagedFixedPartitionResolverGeneric*>( resolverptr.ptr( ) );
 
         if (mg_fixedResolver != nullptr)
         {
@@ -290,8 +290,8 @@ namespace GemStone
       generic <class TKey, class TValue>
       bool Generic::RegionAttributes<TKey, TValue>::Equals(Generic::RegionAttributes<TKey, TValue>^ other)
       {
-        gemfire::RegionAttributes* otherPtr =
-          GetNativePtrFromSBWrapGeneric<gemfire::RegionAttributes>( other );
+        apache::geode::client::RegionAttributes* otherPtr =
+          GetNativePtrFromSBWrapGeneric<apache::geode::client::RegionAttributes>( other );
         if (_NativePtr != nullptr && otherPtr != nullptr) {
           return NativePtr->operator==(*otherPtr);
         }
@@ -301,7 +301,7 @@ namespace GemStone
       generic <class TKey, class TValue>
       bool Generic::RegionAttributes<TKey, TValue>::Equals(Object^ other)
       {
-        gemfire::RegionAttributes* otherPtr = GetNativePtrFromSBWrapGeneric<gemfire::
+        apache::geode::client::RegionAttributes* otherPtr = GetNativePtrFromSBWrapGeneric<apache::geode::client::
           RegionAttributes>( dynamic_cast<Generic::RegionAttributes<TKey, TValue>^>( other ) );
         if (_NativePtr != nullptr && otherPtr != nullptr) {
           return NativePtr->operator==(*otherPtr);
@@ -353,7 +353,7 @@ namespace GemStone
       generic <class TKey, class TValue>
       Properties<String^, String^>^Generic::RegionAttributes<TKey, TValue>::PersistenceProperties::get()
       {
-        gemfire::PropertiesPtr& nativeptr(
+        apache::geode::client::PropertiesPtr& nativeptr(
           NativePtr->getPersistenceProperties( ) );
         return Properties<String^, String^>::Create<String^, String^>( nativeptr.ptr( ) );
       }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionAttributes.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionAttributes.hpp b/src/clicache/src/RegionAttributes.hpp
index 16ca0d5..adf8f5b 100644
--- a/src/clicache/src/RegionAttributes.hpp
+++ b/src/clicache/src/RegionAttributes.hpp
@@ -70,7 +70,7 @@ namespace GemStone
       /// <seealso cref="Region.Attributes" />
       generic <class TKey, class TValue>
       public ref class RegionAttributes sealed
-				: public Generic::Internal::SBWrap<gemfire::RegionAttributes>, public IGFSerializable
+				: public Generic::Internal::SBWrap<apache::geode::client::RegionAttributes>, public IGFSerializable
       {
       public:
 
@@ -483,7 +483,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static RegionAttributes<TKey, TValue>^ Create( gemfire::RegionAttributes* nativeptr )
+        inline static RegionAttributes<TKey, TValue>^ Create( apache::geode::client::RegionAttributes* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew RegionAttributes<TKey, TValue>( nativeptr ) : nullptr );
@@ -496,7 +496,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline RegionAttributes<TKey, TValue>( gemfire::RegionAttributes* nativeptr )
+        inline RegionAttributes<TKey, TValue>( apache::geode::client::RegionAttributes* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionEntry.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionEntry.cpp b/src/clicache/src/RegionEntry.cpp
index 6357901..3ed1d4d 100644
--- a/src/clicache/src/RegionEntry.cpp
+++ b/src/clicache/src/RegionEntry.cpp
@@ -33,7 +33,7 @@ namespace GemStone
       generic<class TKey, class TValue>
       TKey RegionEntry<TKey, TValue>::Key::get( )
       {
-        gemfire::CacheableKeyPtr& nativeptr( NativePtr->getKey( ) );
+        apache::geode::client::CacheableKeyPtr& nativeptr( NativePtr->getKey( ) );
         
         return Serializable::GetManagedValueGeneric<TKey>( nativeptr );
       }
@@ -41,7 +41,7 @@ namespace GemStone
       generic<class TKey, class TValue>
       TValue RegionEntry<TKey, TValue>::Value::get( )
       {
-        gemfire::CacheablePtr& nativeptr( NativePtr->getValue( ) );
+        apache::geode::client::CacheablePtr& nativeptr( NativePtr->getValue( ) );
 
         return Serializable::GetManagedValueGeneric<TValue>( nativeptr );
       }
@@ -49,7 +49,7 @@ namespace GemStone
       generic<class TKey, class TValue>
       IRegion<TKey, TValue>^ RegionEntry<TKey, TValue>::Region::get( )
       {
-        gemfire::RegionPtr rptr;
+        apache::geode::client::RegionPtr rptr;
 
         NativePtr->getRegion( rptr );
         return GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create( rptr.ptr( ) );
@@ -58,7 +58,7 @@ namespace GemStone
       generic<class TKey, class TValue>
       GemStone::GemFire::Cache::Generic::CacheStatistics^ RegionEntry<TKey, TValue>::Statistics::get( )
       {
-        gemfire::CacheStatisticsPtr nativeptr;
+        apache::geode::client::CacheStatisticsPtr nativeptr;
 
         NativePtr->getStatistics( nativeptr );
         return GemStone::GemFire::Cache::Generic::CacheStatistics::Create( nativeptr.ptr( ) );

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionEntry.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionEntry.hpp b/src/clicache/src/RegionEntry.hpp
index 75a4ea4..7c16dc0 100644
--- a/src/clicache/src/RegionEntry.hpp
+++ b/src/clicache/src/RegionEntry.hpp
@@ -52,7 +52,7 @@ namespace GemStone
       /// </remarks>
       generic<class TKey, class TValue>
       public ref class RegionEntry sealed
-        : public Internal::SBWrap<gemfire::RegionEntry>
+        : public Internal::SBWrap<apache::geode::client::RegionEntry>
       {
       public:
 
@@ -160,7 +160,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static Generic::RegionEntry<TKey, TValue>^ Create( gemfire::RegionEntry* nativeptr )
+        inline static Generic::RegionEntry<TKey, TValue>^ Create( apache::geode::client::RegionEntry* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew Generic::RegionEntry<TKey, TValue>( nativeptr ) : nullptr );
@@ -173,7 +173,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline RegionEntry( gemfire::RegionEntry* nativeptr )
+        inline RegionEntry( apache::geode::client::RegionEntry* nativeptr )
           : SBWrap( nativeptr ) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionEvent.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionEvent.cpp b/src/clicache/src/RegionEvent.cpp
index d3f5c65..42f54c2 100644
--- a/src/clicache/src/RegionEvent.cpp
+++ b/src/clicache/src/RegionEvent.cpp
@@ -40,17 +40,17 @@ namespace GemStone
             "null region passed" );
         }
 
-        gemfire::UserDataPtr callbackptr(SafeMSerializableConvert(
+        apache::geode::client::UserDataPtr callbackptr(SafeMSerializableConvert(
             aCallbackArgument));
 
-        SetPtr(new gemfire::RegionEvent(gemfire::RegionPtr(region->_NativePtr),
+        SetPtr(new apache::geode::client::RegionEvent(apache::geode::client::RegionPtr(region->_NativePtr),
           callbackptr, remoteOrigin), true);*/
       }
 
       generic<class TKey, class TValue>
       IRegion<TKey, TValue>^ RegionEvent<TKey, TValue>::Region::get( )
       {
-        gemfire::RegionPtr& regionptr( NativePtr->getRegion( ) );
+        apache::geode::client::RegionPtr& regionptr( NativePtr->getRegion( ) );
 
         return Generic::Region<TKey, TValue>::Create( regionptr.ptr( ) );
       }
@@ -58,7 +58,7 @@ namespace GemStone
       generic<class TKey, class TValue>
       Object^ RegionEvent<TKey, TValue>::CallbackArgument::get()
       {
-        gemfire::UserDataPtr& valptr(NativePtr->getCallbackArgument());
+        apache::geode::client::UserDataPtr& valptr(NativePtr->getCallbackArgument());
         return Serializable::GetManagedValueGeneric<Object^>( valptr );
       }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionEvent.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionEvent.hpp b/src/clicache/src/RegionEvent.hpp
index 315ab4d..b13a30a 100644
--- a/src/clicache/src/RegionEvent.hpp
+++ b/src/clicache/src/RegionEvent.hpp
@@ -40,7 +40,7 @@ namespace GemStone
       /// </summary>
       generic<class TKey, class TValue>
       public ref class RegionEvent sealed
-        : public Generic::Internal::UMWrap<gemfire::RegionEvent>
+        : public Generic::Internal::UMWrap<apache::geode::client::RegionEvent>
       {
       public:
 
@@ -86,9 +86,9 @@ namespace GemStone
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline GemStone::GemFire::Cache::Generic::RegionEvent<TKey, TValue>( const gemfire::RegionEvent* nativeptr )
-          : GemStone::GemFire::Cache::Generic::Internal::UMWrap<gemfire::RegionEvent>(
-            const_cast<gemfire::RegionEvent*>( nativeptr ), false ) { }
+        inline GemStone::GemFire::Cache::Generic::RegionEvent<TKey, TValue>( const apache::geode::client::RegionEvent* nativeptr )
+          : GemStone::GemFire::Cache::Generic::Internal::UMWrap<apache::geode::client::RegionEvent>(
+            const_cast<apache::geode::client::RegionEvent*>( nativeptr ), false ) { }
       };
 
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionFactory.cpp b/src/clicache/src/RegionFactory.cpp
index b4a0038..a12af6a 100644
--- a/src/clicache/src/RegionFactory.cpp
+++ b/src/clicache/src/RegionFactory.cpp
@@ -100,28 +100,28 @@ namespace GemStone
       RegionFactory^ RegionFactory::SetEntryIdleTimeout( ExpirationAction action, uint32_t idleTimeout )
       {
         NativePtr->setEntryIdleTimeout(
-          static_cast<gemfire::ExpirationAction::Action>( action ), idleTimeout );
+          static_cast<apache::geode::client::ExpirationAction::Action>( action ), idleTimeout );
         return this;
       }
 
       RegionFactory^ RegionFactory::SetEntryTimeToLive( ExpirationAction action, uint32_t timeToLive )
       {
         NativePtr->setEntryTimeToLive(
-          static_cast<gemfire::ExpirationAction::Action>( action ), timeToLive );
+          static_cast<apache::geode::client::ExpirationAction::Action>( action ), timeToLive );
         return this;
       }
 
       RegionFactory^ RegionFactory::SetRegionIdleTimeout( ExpirationAction action, uint32_t idleTimeout )
       {
         NativePtr->setRegionIdleTimeout(
-          static_cast<gemfire::ExpirationAction::Action>( action ), idleTimeout );
+          static_cast<apache::geode::client::ExpirationAction::Action>( action ), idleTimeout );
         return this;
       }
 
       RegionFactory^ RegionFactory::SetRegionTimeToLive( ExpirationAction action, uint32_t timeToLive )
       {
         NativePtr->setRegionTimeToLive(
-          static_cast<gemfire::ExpirationAction::Action>( action ), timeToLive );
+          static_cast<apache::geode::client::ExpirationAction::Action>( action ), timeToLive );
         return this;
       }
 
@@ -131,14 +131,14 @@ namespace GemStone
       RegionFactory^ RegionFactory::SetPersistenceManager( Generic::IPersistenceManager<TKey, TValue>^ persistenceManager, 
           Properties<String^, String^>^ config)
       {
-        gemfire::PersistenceManagerPtr persistenceManagerptr;
+        apache::geode::client::PersistenceManagerPtr persistenceManagerptr;
         if ( persistenceManager != nullptr ) {
           PersistenceManagerGeneric<TKey, TValue>^ clg = gcnew PersistenceManagerGeneric<TKey, TValue>();
           clg->SetPersistenceManager(persistenceManager);
-          persistenceManagerptr = new gemfire::ManagedPersistenceManagerGeneric( /*clg,*/ persistenceManager);
-          ((gemfire::ManagedPersistenceManagerGeneric*)persistenceManagerptr.ptr())->setptr(clg);
+          persistenceManagerptr = new apache::geode::client::ManagedPersistenceManagerGeneric( /*clg,*/ persistenceManager);
+          ((apache::geode::client::ManagedPersistenceManagerGeneric*)persistenceManagerptr.ptr())->setptr(clg);
         }
-        gemfire::PropertiesPtr configptr(GetNativePtr<gemfire::Properties>( config ) );
+        apache::geode::client::PropertiesPtr configptr(GetNativePtr<apache::geode::client::Properties>( config ) );
         NativePtr->setPersistenceManager( persistenceManagerptr, configptr );
         return this;
       }
@@ -162,8 +162,8 @@ namespace GemStone
         ManagedString mg_libpath( libPath );
         ManagedString mg_factoryFunctionName( factoryFunctionName );
 				//TODO:split
-        gemfire::PropertiesPtr configptr(
-          GetNativePtr<gemfire::Properties>( config ) );
+        apache::geode::client::PropertiesPtr configptr(
+          GetNativePtr<apache::geode::client::Properties>( config ) );
 
         NativePtr->setPersistenceManager( mg_libpath.CharPtr,
           mg_factoryFunctionName.CharPtr, configptr );
@@ -219,7 +219,7 @@ namespace GemStone
       RegionFactory^ RegionFactory::SetDiskPolicy( DiskPolicyType diskPolicy )
       {
         NativePtr->setDiskPolicy(
-          static_cast<gemfire::DiskPolicyType::PolicyType>( diskPolicy ) );
+          static_cast<apache::geode::client::DiskPolicyType::PolicyType>( diskPolicy ) );
         return this;
       }
 
@@ -249,7 +249,7 @@ namespace GemStone
 
         ManagedString mg_name( regionName );
           
-        gemfire::RegionPtr& nativeptr( NativePtr->create(
+        apache::geode::client::RegionPtr& nativeptr( NativePtr->create(
             mg_name.CharPtr ) );
           return Generic::Region<TKey,TValue>::Create( nativeptr.ptr( ) );
 
@@ -259,12 +259,12 @@ namespace GemStone
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetCacheLoader( Generic::ICacheLoader<TKey, TValue>^ cacheLoader )
       {
-        gemfire::CacheLoaderPtr loaderptr;
+        apache::geode::client::CacheLoaderPtr loaderptr;
         if ( cacheLoader != nullptr ) {
           CacheLoaderGeneric<TKey, TValue>^ clg = gcnew CacheLoaderGeneric<TKey, TValue>();
           clg->SetCacheLoader(cacheLoader);
-          loaderptr = new gemfire::ManagedCacheLoaderGeneric( /*clg,*/ cacheLoader );
-          ((gemfire::ManagedCacheLoaderGeneric*)loaderptr.ptr())->setptr(clg);
+          loaderptr = new apache::geode::client::ManagedCacheLoaderGeneric( /*clg,*/ cacheLoader );
+          ((apache::geode::client::ManagedCacheLoaderGeneric*)loaderptr.ptr())->setptr(clg);
         }
         NativePtr->setCacheLoader( loaderptr );
         return this;
@@ -273,12 +273,12 @@ namespace GemStone
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetCacheWriter( Generic::ICacheWriter<TKey, TValue>^ cacheWriter )
       {
-        gemfire::CacheWriterPtr writerptr;
+        apache::geode::client::CacheWriterPtr writerptr;
         if ( cacheWriter != nullptr ) {
           CacheWriterGeneric<TKey, TValue>^ cwg = gcnew CacheWriterGeneric<TKey, TValue>();
           cwg->SetCacheWriter(cacheWriter);
-          writerptr = new gemfire::ManagedCacheWriterGeneric( /*cwg,*/ cacheWriter );
-          ((gemfire::ManagedCacheWriterGeneric*)writerptr.ptr())->setptr(cwg);
+          writerptr = new apache::geode::client::ManagedCacheWriterGeneric( /*cwg,*/ cacheWriter );
+          ((apache::geode::client::ManagedCacheWriterGeneric*)writerptr.ptr())->setptr(cwg);
         }
         NativePtr->setCacheWriter( writerptr );
         return this;
@@ -287,14 +287,14 @@ namespace GemStone
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetCacheListener( Generic::ICacheListener<TKey, TValue>^ cacheListener )
       {
-        gemfire::CacheListenerPtr listenerptr;
+        apache::geode::client::CacheListenerPtr listenerptr;
         if ( cacheListener != nullptr ) {
           CacheListenerGeneric<TKey, TValue>^ clg = gcnew CacheListenerGeneric<TKey, TValue>();
           clg->SetCacheListener(cacheListener);
-          listenerptr = new gemfire::ManagedCacheListenerGeneric( /*clg,*/ cacheListener );
-          ((gemfire::ManagedCacheListenerGeneric*)listenerptr.ptr())->setptr(clg);
+          listenerptr = new apache::geode::client::ManagedCacheListenerGeneric( /*clg,*/ cacheListener );
+          ((apache::geode::client::ManagedCacheListenerGeneric*)listenerptr.ptr())->setptr(clg);
           /*
-          listenerptr = new gemfire::ManagedCacheListenerGeneric(
+          listenerptr = new apache::geode::client::ManagedCacheListenerGeneric(
             (Generic::ICacheListener<Object^, Object^>^)cacheListener);
             */
         }
@@ -305,21 +305,21 @@ namespace GemStone
       generic <class TKey, class TValue>
       RegionFactory^ RegionFactory::SetPartitionResolver( Generic::IPartitionResolver<TKey, TValue>^ partitionresolver )
       {
-        gemfire::PartitionResolverPtr resolverptr;
+        apache::geode::client::PartitionResolverPtr resolverptr;
         if ( partitionresolver != nullptr ) {
           Generic::IFixedPartitionResolver<TKey, TValue>^ resolver = 
             dynamic_cast<Generic::IFixedPartitionResolver<TKey, TValue>^>(partitionresolver);
           if (resolver != nullptr) {            
             FixedPartitionResolverGeneric<TKey, TValue>^ prg = gcnew FixedPartitionResolverGeneric<TKey, TValue>();
             prg->SetPartitionResolver(resolver);
-            resolverptr = new gemfire::ManagedFixedPartitionResolverGeneric( resolver ); 
-            ((gemfire::ManagedFixedPartitionResolverGeneric*)resolverptr.ptr())->setptr(prg);
+            resolverptr = new apache::geode::client::ManagedFixedPartitionResolverGeneric( resolver ); 
+            ((apache::geode::client::ManagedFixedPartitionResolverGeneric*)resolverptr.ptr())->setptr(prg);
           }
           else {            
             PartitionResolverGeneric<TKey, TValue>^ prg = gcnew PartitionResolverGeneric<TKey, TValue>();
             prg->SetPartitionResolver(partitionresolver);
-            resolverptr = new gemfire::ManagedPartitionResolverGeneric( partitionresolver );
-            ((gemfire::ManagedPartitionResolverGeneric*)resolverptr.ptr())->setptr(prg);            
+            resolverptr = new apache::geode::client::ManagedPartitionResolverGeneric( partitionresolver );
+            ((apache::geode::client::ManagedPartitionResolverGeneric*)resolverptr.ptr())->setptr(prg);            
           }         
         }
         NativePtr->setPartitionResolver( resolverptr );

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/RegionFactory.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionFactory.hpp b/src/clicache/src/RegionFactory.hpp
index 6a2d39a..47fd3e5 100644
--- a/src/clicache/src/RegionFactory.hpp
+++ b/src/clicache/src/RegionFactory.hpp
@@ -52,7 +52,7 @@ namespace GemStone
       /// This interface provides for the configuration and creation of instances of Region.
       /// </summary>
       public ref class RegionFactory sealed
-				: public Internal::SBWrap<gemfire::RegionFactory>
+				: public Internal::SBWrap<apache::geode::client::RegionFactory>
       {
       public:
         /// <summary>
@@ -429,7 +429,7 @@ namespace GemStone
       /// <returns>
       /// The managed wrapper object; null if the native pointer is null.
       /// </returns>
-      inline static RegionFactory^ Create( gemfire::RegionFactory* nativeptr )
+      inline static RegionFactory^ Create( apache::geode::client::RegionFactory* nativeptr )
       {
         return ( nativeptr != nullptr ?
           gcnew RegionFactory( nativeptr ) : nullptr );
@@ -441,8 +441,8 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-      inline RegionFactory( gemfire::RegionFactory* nativeptr )
-				: Internal::SBWrap<gemfire::RegionFactory>( nativeptr ) { }
+      inline RegionFactory( apache::geode::client::RegionFactory* nativeptr )
+				: Internal::SBWrap<apache::geode::client::RegionFactory>( nativeptr ) { }
       };
       } // end namespace Generic
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/ResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultCollector.cpp b/src/clicache/src/ResultCollector.cpp
index 0e1d3bf..eb51a1d 100644
--- a/src/clicache/src/ResultCollector.cpp
+++ b/src/clicache/src/ResultCollector.cpp
@@ -36,8 +36,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          gemfire::Serializable * result = SafeGenericMSerializableConvert((IGFSerializable^)rs);
-        NativePtr->addResult( result==NULL ? (NULLPTR) : (gemfire::CacheablePtr(result)) );
+          apache::geode::client::Serializable * result = SafeGenericMSerializableConvert((IGFSerializable^)rs);
+        NativePtr->addResult( result==NULL ? (NULLPTR) : (apache::geode::client::CacheablePtr(result)) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -52,12 +52,12 @@ namespace GemStone
       System::Collections::Generic::ICollection<TResult>^  ResultCollector<TResult>::GetResult(UInt32 timeout)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-          gemfire::CacheableVectorPtr results = NativePtr->getResult(timeout);
+          apache::geode::client::CacheableVectorPtr results = NativePtr->getResult(timeout);
         array<TResult>^ rs =
           gcnew array<TResult>( results->size( ) );
         for( int32_t index = 0; index < results->size( ); index++ )
         {
-          gemfire::CacheablePtr& nativeptr(results->operator[](index));
+          apache::geode::client::CacheablePtr& nativeptr(results->operator[](index));
 
           rs[ index] =  Serializable::GetManagedValueGeneric<TResult>( nativeptr);
         }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/ResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultCollector.hpp b/src/clicache/src/ResultCollector.hpp
index 960fd0a..e00983f 100644
--- a/src/clicache/src/ResultCollector.hpp
+++ b/src/clicache/src/ResultCollector.hpp
@@ -42,7 +42,7 @@ namespace GemStone
       /// </summary>
      generic<class TResult>
       public ref class ResultCollector
-        : public Internal::SBWrap<gemfire::ResultCollector>, public IResultCollector<TResult>
+        : public Internal::SBWrap<apache::geode::client::ResultCollector>, public IResultCollector<TResult>
       {
       public:
 
@@ -85,7 +85,7 @@ namespace GemStone
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline ResultCollector( gemfire::ResultCollector* nativeptr ):
+        inline ResultCollector( apache::geode::client::ResultCollector* nativeptr ):
         SBWrap( nativeptr ){ }
 
         /// <summary>
@@ -95,7 +95,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 AssignSPGeneric( gemfire::ResultCollector* nativeptr )
+        inline void AssignSPGeneric( apache::geode::client::ResultCollector* nativeptr )
         {
           AssignPtr( nativeptr );
         }
@@ -103,7 +103,7 @@ namespace GemStone
         /// <summary>
         /// Used to assign the native CqListener pointer to a new object.
         /// </summary>
-        inline void SetSPGeneric( gemfire::ResultCollector* nativeptr )
+        inline void SetSPGeneric( apache::geode::client::ResultCollector* nativeptr )
         {
           if ( nativeptr != nullptr ) {
             nativeptr->preserveSB( );

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/ResultSet.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultSet.cpp b/src/clicache/src/ResultSet.cpp
index a31e243..74da11a 100644
--- a/src/clicache/src/ResultSet.cpp
+++ b/src/clicache/src/ResultSet.cpp
@@ -53,8 +53,8 @@ namespace GemStone
       generic<class TResult>
       SelectResultsIterator<TResult>^ ResultSet<TResult>::GetIterator( )
       {
-        gemfire::SelectResultsIterator* nativeptr =
-          new gemfire::SelectResultsIterator( NativePtr->getIterator( ) );
+        apache::geode::client::SelectResultsIterator* nativeptr =
+          new apache::geode::client::SelectResultsIterator( NativePtr->getIterator( ) );
 
         return SelectResultsIterator<TResult>::Create( nativeptr );
       }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/ResultSet.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultSet.hpp b/src/clicache/src/ResultSet.hpp
index 337e2d6..d099577 100644
--- a/src/clicache/src/ResultSet.hpp
+++ b/src/clicache/src/ResultSet.hpp
@@ -44,7 +44,7 @@ namespace GemStone
       /// </summary>
       generic<class TResult>
       public ref class ResultSet sealed
-        : public Internal::SBWrap<gemfire::ResultSet>, public ISelectResults<TResult>
+        : public Internal::SBWrap<apache::geode::client::ResultSet>, public ISelectResults<TResult>
       {
       public:
 
@@ -98,7 +98,7 @@ namespace GemStone
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static ResultSet<TResult>^ Create(gemfire::ResultSet* nativeptr)
+        inline static ResultSet<TResult>^ Create(apache::geode::client::ResultSet* nativeptr)
         {
           return (nativeptr != nullptr ? gcnew ResultSet(nativeptr) : nullptr);
         }
@@ -113,7 +113,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline ResultSet(gemfire::ResultSet* nativeptr)
+        inline ResultSet(apache::geode::client::ResultSet* nativeptr)
           : SBWrap(nativeptr) { }
       };
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/SelectResultsIterator.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SelectResultsIterator.hpp b/src/clicache/src/SelectResultsIterator.hpp
index 626487e..312fa04 100644
--- a/src/clicache/src/SelectResultsIterator.hpp
+++ b/src/clicache/src/SelectResultsIterator.hpp
@@ -38,7 +38,7 @@ namespace GemStone
       /// </summary>
       generic<class TResult>
       public ref class SelectResultsIterator sealed
-        : public Internal::UMWrap<gemfire::SelectResultsIterator>,
+        : public Internal::UMWrap<apache::geode::client::SelectResultsIterator>,
         public System::Collections::Generic::IEnumerator</*GemStone::GemFire::Cache::Generic::IGFSerializable^*/TResult>
       {
       public:
@@ -97,7 +97,7 @@ namespace GemStone
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
         inline static GemStone::GemFire::Cache::Generic::SelectResultsIterator<TResult>^ Create(
-          gemfire::SelectResultsIterator* nativeptr )
+          apache::geode::client::SelectResultsIterator* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew GemStone::GemFire::Cache::Generic::SelectResultsIterator<TResult>( nativeptr ) : nullptr );
@@ -120,7 +120,7 @@ namespace GemStone
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
         inline SelectResultsIterator(
-          gemfire::SelectResultsIterator* nativeptr )
+          apache::geode::client::SelectResultsIterator* nativeptr )
           : UMWrap( nativeptr, true ) { }
       };
 


Mime
View raw message