geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aba...@apache.org
Subject [12/50] [abbrv] geode-native git commit: GEODE-2365: Replace gemfire with geode in clicache.
Date Thu, 09 Feb 2017 18:09:09 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/fc9f1f6f/src/clicache/src/Region.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Region.cpp b/src/clicache/src/Region.cpp
index 0a10e06..5c50f8e 100644
--- a/src/clicache/src/Region.cpp
+++ b/src/clicache/src/Region.cpp
@@ -47,24 +47,24 @@ namespace Apache
       generic<class TKey, class TValue>
       TValue Region<TKey, TValue>::Get(TKey key, Object^ callbackArg)
       {
-        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );        
+        apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
         apache::geode::client::UserDataPtr callbackptr(
-          Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
         apache::geode::client::CacheablePtr nativeptr(this->get(keyptr, callbackptr));
         if (nativeptr == NULLPTR)
         {
           throw gcnew KeyNotFoundException("The given key was not present in the region.");
         }
-        TValue returnVal = Serializable::GetManagedValueGeneric<TValue>( nativeptr );
+        TValue returnVal = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
         return returnVal;
 
       }
-      
+
       generic<class TKey, class TValue>
       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 ) ;
+          return NativePtr->get(keyptr, callbackptr);
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
@@ -72,7 +72,7 @@ namespace Apache
       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 ) ;
+          return NativePtr->get(keyptr);
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
@@ -81,15 +81,15 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           Apache::Geode::Client::RegionAttributes<TKey, TValue>^ rAttributes = this->Attributes;
-          String^ poolName = rAttributes->PoolName;
-          if (poolName != nullptr) {
-            Pool/*<TKey, TValue>*/^ pool = PoolManager/*<TKey, TValue>*/::Find(poolName);
-            if (pool != nullptr && !pool->Destroyed) {
-              return pool->MultiuserAuthentication;
-            }
+        String^ poolName = rAttributes->PoolName;
+        if (poolName != nullptr) {
+          Pool/*<TKey, TValue>*/^ pool = PoolManager/*<TKey, TValue>*/::Find(poolName);
+          if (pool != nullptr && !pool->Destroyed) {
+            return pool->MultiuserAuthentication;
           }
-          return false;
-          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+        }
+        return false;
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
@@ -97,67 +97,67 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        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 );       
+          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);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
       TValue Region<TKey, TValue>::default::get(TKey key)
-      {  
-        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+      {
+        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.");
         }
-        TValue returnVal = Serializable::GetManagedValueGeneric<TValue>( nativeptr );
+        TValue returnVal = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
         return returnVal;
       }
 
-      generic<class TKey, class TValue>      
+      generic<class TKey, class TValue>
       void Region<TKey, TValue>::default::set(TKey key, TValue value)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-        apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );
-        NativePtr->put( keyptr, valueptr );
+          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 */
       }
 
       generic<class TKey, class TValue>
-      System::Collections::Generic::IEnumerator<KeyValuePair<TKey,TValue>>^ 
+      System::Collections::Generic::IEnumerator<KeyValuePair<TKey, TValue>>^
         Region<TKey, TValue>::GetEnumerator()
       {
-        array<KeyValuePair<TKey,TValue>>^ toArray;
+        array<KeyValuePair<TKey, TValue>>^ toArray;
         apache::geode::client::VectorOfRegionEntry vc;
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          NativePtr->entries( vc, false );
+          NativePtr->entries(vc, false);
 
-        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */ 
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
-          toArray = gcnew array<KeyValuePair<TKey,TValue>>(vc.size());
+          toArray = gcnew array<KeyValuePair<TKey, TValue>>(vc.size());
 
-        for( int32_t index = 0; index < vc.size( ); index++ )
+        for (int32_t index = 0; index < vc.size(); 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);           
-        } 
-        return ((System::Collections::Generic::IEnumerable<KeyValuePair<TKey,TValue>>^)toArray)->GetEnumerator();        
+          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);
+        }
+        return ((System::Collections::Generic::IEnumerable<KeyValuePair<TKey, TValue>>^)toArray)->GetEnumerator();
       }
 
       generic<class TKey, class TValue>
-      System::Collections::IEnumerator^ 
+      System::Collections::IEnumerator^
         Region<TKey, TValue>::GetEnumeratorOld()
       {
         array<Object^>^ toArray;
@@ -165,77 +165,77 @@ namespace Apache
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          NativePtr->entries( vc, false );
+          NativePtr->entries(vc, false);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
           toArray = gcnew array<Object^>(vc.size());
 
-        for( int32_t index = 0; index < vc.size( ); index++ )
+        for (int32_t index = 0; index < vc.size(); 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);           
+          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);
         }
-        return ((System::Collections::Generic::IEnumerable<Object^>^)toArray)->GetEnumerator();        
+        return ((System::Collections::Generic::IEnumerable<Object^>^)toArray)->GetEnumerator();
       }
 
       generic<class TKey, class TValue>
       bool Region<TKey, TValue>::AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2)
       {
-        if ( val1 == NULLPTR && val2 == NULLPTR )
-        {          
+        if (val1 == NULLPTR && val2 == NULLPTR)
+        {
           return true;
         }
         else if ((val1 == NULLPTR && val2 != NULLPTR) || (val1 != NULLPTR && val2 == NULLPTR))
-        {          
+        {
           return false;
         }
-        else if ( val1 != NULLPTR && val2 != NULLPTR )
-        {          
+        else if (val1 != NULLPTR && val2 != NULLPTR)
+        {
           if (val1->classId() != val2->classId() || val1->typeId() != val2->typeId())
-          {            
+          {
             return false;
           }
           apache::geode::client::DataOutput out1;
           apache::geode::client::DataOutput out2;
           val1->toData(out1);
           val2->toData(out2);
-          if ( out1.getBufferLength() != out2.getBufferLength() )
-          {            
+          if (out1.getBufferLength() != out2.getBufferLength())
+          {
             return false;
           }
           else if (memcmp(out1.getBuffer(), out2.getBuffer(), out1.getBufferLength()) != 0)
-          {            
+          {
             return false;
-          }          
+          }
           return true;
-        }        
+        }
         return false;
       }
 
-      generic<class TKey, class TValue> 
-      bool Region<TKey, TValue>::Contains(KeyValuePair<TKey,TValue> keyValuePair) 
-      { 
-        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) ); 
-        apache::geode::client::CacheablePtr nativeptr(this->get(keyptr)); 
+      generic<class TKey, class TValue>
+      bool Region<TKey, TValue>::Contains(KeyValuePair<TKey, TValue> keyValuePair)
+      {
+        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;
         }
         TValue value = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
         return ((Object^)value)->Equals(keyValuePair.Value);
-      } 
+      }
 
       generic<class TKey, class TValue>
       bool Region<TKey, TValue>::ContainsKey(TKey key)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );          
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
 
-          return NativePtr->containsKeyOnServer( keyptr );
+        return NativePtr->containsKeyOnServer(keyptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -244,34 +244,34 @@ namespace Apache
       bool Region<TKey, TValue>::TryGetValue(TKey key, TValue %val)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-        apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
         apache::geode::client::CacheablePtr nativeptr(this->get(keyptr));
-        if (nativeptr == NULLPTR) {            
+        if (nativeptr == NULLPTR) {
           val = TValue();
           return false;
         }
         else {
-          val = Serializable::GetManagedValueGeneric<TValue>( nativeptr );
+          val = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
           return true;
-        }                           
+        }
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
-      }      
+      }
 
       generic<class TKey, class TValue>
       System::Collections::Generic::ICollection<TKey>^ Region<TKey, TValue>::Keys::get()
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::VectorOfCacheableKey vc;
-        NativePtr->serverKeys( 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++ )
-        {            
-          apache::geode::client::CacheableKeyPtr& nativeptr( vc[ index ] );
-          keyarr[ index ] = Serializable::GetManagedValueGeneric<TKey>(nativeptr);
+          gcnew array<TKey>(vc.size());
+        for (int32_t index = 0; index < vc.size(); index++)
+        {
+          apache::geode::client::CacheableKeyPtr& nativeptr(vc[index]);
+          keyarr[index] = Serializable::GetManagedValueGeneric<TKey>(nativeptr);
           //collectionlist[ index ] = Serializable::GetManagedValue<TKey>(nativeptr);
         }
         System::Collections::Generic::ICollection<TKey>^ collectionlist =
@@ -287,19 +287,19 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           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++ )
-          {
-            apache::geode::client::CacheablePtr& nativeptr( vc[ index ] );            
-            valarr[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
-            //collectionlist[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
-          }
-          System::Collections::Generic::ICollection<TValue>^ collectionlist =
-            (System::Collections::Generic::ICollection<TValue>^)valarr;
-          return collectionlist;
+        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++)
+        {
+          apache::geode::client::CacheablePtr& nativeptr(vc[index]);
+          valarr[index] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
+          //collectionlist[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
+        }
+        System::Collections::Generic::ICollection<TValue>^ collectionlist =
+          (System::Collections::Generic::ICollection<TValue>^)valarr;
+        return collectionlist;
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -309,9 +309,9 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-          apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( value ) );
-          NativePtr->create( keyptr, valueptr );
+          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 */
       }
@@ -321,23 +321,23 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) );
-          apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValuePair.Value ) );
-          NativePtr->create( keyptr, valueptr );
+          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 */
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
-      
+
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::Add(TKey key, TValue value, Object^ callbackArg)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          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 );
+          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);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -347,37 +347,37 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );          
-          return NativePtr->removeEx( keyptr );
-          
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
+        return NativePtr->removeEx(keyptr);
+
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
-      
+
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::Remove( TKey key, Object^ callbackArg )
+      bool Region<TKey, TValue>::Remove(TKey key, Object^ callbackArg)
       {
-         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                    
-          apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
-          return NativePtr->removeEx( keyptr, callbackptr );
-          
-          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
+        apache::geode::client::UserDataPtr callbackptr(
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+        return NativePtr->removeEx(keyptr, callbackptr);
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::Remove(KeyValuePair<TKey,TValue> keyValuePair)
+      bool Region<TKey, TValue>::Remove(KeyValuePair<TKey, TValue> keyValuePair)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValuePair.Key ) );                  
-          apache::geode::client::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);
+        return NativePtr->remove(keyptr, valueptr);
 
-         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
@@ -385,12 +385,12 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          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);
+          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 */
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
@@ -398,7 +398,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          InvalidateRegion( nullptr );
+          InvalidateRegion(nullptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -407,11 +407,11 @@ namespace Apache
       void Region<TKey, TValue>::InvalidateRegion(Object^ callbackArg)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-                    
+
           apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
-          NativePtr->invalidateRegion( callbackptr );
-                
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+        NativePtr->invalidateRegion(callbackptr);
+
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
@@ -420,7 +420,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          DestroyRegion( nullptr );
+          DestroyRegion(nullptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -431,8 +431,8 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
-          NativePtr->destroyRegion( callbackptr );
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+        NativePtr->destroyRegion(callbackptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -442,7 +442,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-         Invalidate(key, nullptr);
+          Invalidate(key, nullptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
@@ -453,11 +453,11 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );                    
-          apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );            
-          NativePtr->invalidate( keyptr, callbackptr );
-          
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
+        apache::geode::client::UserDataPtr callbackptr(
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+        NativePtr->invalidate(keyptr, callbackptr);
+
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
@@ -466,7 +466,7 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          return PutAll( map, DEFAULT_RESPONSE_TIMEOUT );
+          return PutAll(map, DEFAULT_RESPONSE_TIMEOUT);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
@@ -478,13 +478,13 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::HashMapOfCacheable nativeMap;
-          for each ( KeyValuePair<TKey, TValue> keyValPair in map )
-          {
-            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 );
+        for each (KeyValuePair<TKey, TValue> keyValPair in map)
+        {
+          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);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
@@ -496,24 +496,24 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::HashMapOfCacheable nativeMap;
-          for each ( KeyValuePair<TKey, TValue> keyValPair in map )
-          {
-            apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( keyValPair.Key ) );
-            apache::geode::client::CacheablePtr valueptr( Serializable::GetUnmanagedValueGeneric<TValue>( keyValPair.Value ) );
-            nativeMap.insert( keyptr, valueptr );
-          }
-          apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
-          NativePtr->putAll( nativeMap, timeout, callbackptr );
+        for each (KeyValuePair<TKey, TValue> keyValPair in map)
+        {
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(keyValPair.Key));
+          apache::geode::client::CacheablePtr valueptr(Serializable::GetUnmanagedValueGeneric<TValue>(keyValPair.Value));
+          nativeMap.insert(keyptr, valueptr);
+        }
+        apache::geode::client::UserDataPtr callbackptr(
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+        NativePtr->putAll(nativeMap, timeout, callbackptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::GetAll(System::Collections::Generic::ICollection<TKey>^ keys, 
-        System::Collections::Generic::IDictionary<TKey, TValue>^ values, 
-        System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions)
+      void Region<TKey, TValue>::GetAll(System::Collections::Generic::ICollection<TKey>^ keys,
+                                        System::Collections::Generic::IDictionary<TKey, TValue>^ values,
+                                        System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
@@ -524,185 +524,185 @@ namespace Apache
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::GetAll(System::Collections::Generic::ICollection<TKey>^ keys, 
-        System::Collections::Generic::IDictionary<TKey, TValue>^ values, 
-        System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions, 
-        bool addToLocalCache)
+      void Region<TKey, TValue>::GetAll(System::Collections::Generic::ICollection<TKey>^ keys,
+                                        System::Collections::Generic::IDictionary<TKey, TValue>^ values,
+                                        System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions,
+                                        bool addToLocalCache)
       {
         if (keys != nullptr) {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
             apache::geode::client::VectorOfCacheableKey vecKeys;
 
-            for each(TKey item in keys)
-            {
-              vecKeys.push_back(
-                Serializable::GetUnmanagedValueGeneric<TKey>( item ));
-            }
-                        
-            apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
-            if (values != nullptr) {
-              valuesPtr = new apache::geode::client::HashMapOfCacheable();
-            }
-            apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
-            if (exceptions != nullptr) {
-              exceptionsPtr = new apache::geode::client::HashMapOfException();
-            }
-            NativePtr->getAll(vecKeys, valuesPtr, exceptionsPtr,
-              addToLocalCache);            
-            if (values != nullptr) {
-              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());                  
-                  values->Add(key, val);
-              }
+          for each(TKey item in keys)
+          {
+            vecKeys.push_back(
+              Serializable::GetUnmanagedValueGeneric<TKey>(item));
+          }
+
+          apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
+          if (values != nullptr) {
+            valuesPtr = new apache::geode::client::HashMapOfCacheable();
+          }
+          apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
+          if (exceptions != nullptr) {
+            exceptionsPtr = new apache::geode::client::HashMapOfException();
+          }
+          NativePtr->getAll(vecKeys, valuesPtr, exceptionsPtr,
+                            addToLocalCache);
+          if (values != nullptr) {
+            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());
+              values->Add(key, val);
             }
-            if (exceptions != nullptr) {
-              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());                  
-                  exceptions->Add(key, ex);
-              }
+          }
+          if (exceptions != nullptr) {
+            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());
+              exceptions->Add(key, ex);
             }
+          }
 
           _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
         }
         else {
           throw gcnew IllegalArgumentException("GetAll: null keys provided");
-        }         
+        }
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::GetAll(System::Collections::Generic::ICollection<TKey>^ keys, 
-        System::Collections::Generic::IDictionary<TKey, TValue>^ values, 
-        System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions, 
-        bool addToLocalCache, Object^ callbackArg)
+      void Region<TKey, TValue>::GetAll(System::Collections::Generic::ICollection<TKey>^ keys,
+                                        System::Collections::Generic::IDictionary<TKey, TValue>^ values,
+                                        System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions,
+                                        bool addToLocalCache, Object^ callbackArg)
       {
         if (keys != nullptr) {
           _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
             apache::geode::client::VectorOfCacheableKey vecKeys;
 
-            for each(TKey item in keys)
-            {
-              vecKeys.push_back(
-                Serializable::GetUnmanagedValueGeneric<TKey>( item ));
-            }
-                        
-            apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
-            if (values != nullptr) {
-              valuesPtr = new apache::geode::client::HashMapOfCacheable();
-            }
-            apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
-            if (exceptions != nullptr) {
-              exceptionsPtr = new apache::geode::client::HashMapOfException();
-            }
+          for each(TKey item in keys)
+          {
+            vecKeys.push_back(
+              Serializable::GetUnmanagedValueGeneric<TKey>(item));
+          }
 
-            apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );
-
-            NativePtr->getAll(vecKeys, valuesPtr, exceptionsPtr,
-              addToLocalCache, callbackptr);
-            if (values != nullptr) {
-              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());
-                  values->Add(key, val);
-              }
+          apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
+          if (values != nullptr) {
+            valuesPtr = new apache::geode::client::HashMapOfCacheable();
+          }
+          apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
+          if (exceptions != nullptr) {
+            exceptionsPtr = new apache::geode::client::HashMapOfException();
+          }
+
+          apache::geode::client::UserDataPtr callbackptr(
+            Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+
+          NativePtr->getAll(vecKeys, valuesPtr, exceptionsPtr,
+                            addToLocalCache, callbackptr);
+          if (values != nullptr) {
+            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());
+              values->Add(key, val);
             }
-            if (exceptions != nullptr) {
-              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());            
-                  exceptions->Add(key, ex);
-              }
+          }
+          if (exceptions != nullptr) {
+            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());
+              exceptions->Add(key, ex);
             }
+          }
 
           _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
         }
         else {
           throw gcnew IllegalArgumentException("GetAll: null keys provided");
-        }         
+        }
       }
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RemoveAll(System::Collections::Generic::ICollection<TKey>^ keys)
       {
-         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-         RemoveAll(keys, nullptr);
+          RemoveAll(keys, nullptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
-      
+
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RemoveAll(System::Collections::Generic::ICollection<TKey>^ keys,
-            Object^ callbackArg)
+                                            Object^ callbackArg)
       {
-         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
-           
-         apache::geode::client::VectorOfCacheableKey vecKeys;
-         for each(TKey item in keys)
-           vecKeys.push_back(Serializable::GetUnmanagedValueGeneric<TKey>( item ));
-         
-         apache::geode::client::UserDataPtr callbackptr(
-            Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );   
-         
-         NativePtr->removeAll(vecKeys, callbackptr);
-        
-         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          apache::geode::client::VectorOfCacheableKey vecKeys;
+        for each(TKey item in keys)
+          vecKeys.push_back(Serializable::GetUnmanagedValueGeneric<TKey>(item));
+
+        apache::geode::client::UserDataPtr callbackptr(
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+
+        NativePtr->removeAll(vecKeys, callbackptr);
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
       generic<class TKey, class TValue>
       String^ Region<TKey, TValue>::Name::get()
-      { 
-        return ManagedString::Get( NativePtr->getName( ) ); 
-      } 
+      {
+        return ManagedString::Get(NativePtr->getName());
+      }
 
       generic<class TKey, class TValue>
       String^ Region<TKey, TValue>::FullPath::get()
-      { 
-        return ManagedString::Get( NativePtr->getFullPath( ) ); 
-      } 
+      {
+        return ManagedString::Get(NativePtr->getFullPath());
+      }
 
       generic<class TKey, class TValue>
       IRegion<TKey, TValue>^ Region<TKey, TValue>::ParentRegion::get()
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::RegionPtr& nativeptr( NativePtr->getParentRegion( ) );
+          apache::geode::client::RegionPtr& nativeptr(NativePtr->getParentRegion());
 
-          return Region::Create( nativeptr.ptr( ) );
+        return Region::Create(nativeptr.ptr());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
       Apache::Geode::Client::RegionAttributes<TKey, TValue>^ Region<TKey, TValue>::Attributes::get()
-      { 
+      {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::RegionAttributesPtr& nativeptr( NativePtr->getAttributes( ) );
+          apache::geode::client::RegionAttributesPtr& nativeptr(NativePtr->getAttributes());
 
         return Apache::Geode::Client::RegionAttributes<TKey, TValue>::Create(nativeptr.ptr());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
-      } 
+      }
 
-      generic<class TKey, class TValue>      
+      generic<class TKey, class TValue>
       AttributesMutator<TKey, TValue>^ Region<TKey, TValue>::AttributesMutator::get()
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::AttributesMutatorPtr& nativeptr(
-            NativePtr->getAttributesMutator( ) );
+          NativePtr->getAttributesMutator());
 
-        return Apache::Geode::Client::AttributesMutator<TKey, TValue>::Create( nativeptr.ptr( ) );
+        return Apache::Geode::Client::AttributesMutator<TKey, TValue>::Create(nativeptr.ptr());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -712,74 +712,74 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::CacheStatisticsPtr& nativeptr( NativePtr->getStatistics( ) );
-        return Apache::Geode::Client::CacheStatistics::Create( nativeptr.ptr( ) );
+          apache::geode::client::CacheStatisticsPtr& nativeptr(NativePtr->getStatistics());
+        return Apache::Geode::Client::CacheStatistics::Create(nativeptr.ptr());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      IRegion<TKey, TValue>^ Region<TKey, TValue>::GetSubRegion( String^ path )
+      IRegion<TKey, TValue>^ Region<TKey, TValue>::GetSubRegion(String^ path)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          ManagedString mg_path( path );
-          apache::geode::client::RegionPtr& nativeptr(
-            NativePtr->getSubregion( mg_path.CharPtr ) );
-          return Region::Create( nativeptr.ptr( ) );
+          ManagedString mg_path(path);
+        apache::geode::client::RegionPtr& nativeptr(
+          NativePtr->getSubregion(mg_path.CharPtr));
+        return Region::Create(nativeptr.ptr());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      IRegion<TKey, TValue>^ Region<TKey, TValue>::CreateSubRegion( String^ subRegionName, 
-        Apache::Geode::Client::RegionAttributes<TKey, TValue>^ attributes)
+      IRegion<TKey, TValue>^ Region<TKey, TValue>::CreateSubRegion(String^ subRegionName,
+                                                                    Apache::Geode::Client::RegionAttributes<TKey, TValue>^ attributes)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          ManagedString mg_subregionName( subRegionName );
-				//TODO:split
-          apache::geode::client::RegionAttributesPtr p_attrs(
-            GetNativePtrFromSBWrapGeneric<apache::geode::client::RegionAttributes>( attributes ) );
+          ManagedString mg_subregionName(subRegionName);
+        //TODO:split
+        apache::geode::client::RegionAttributesPtr p_attrs(
+          GetNativePtrFromSBWrapGeneric<apache::geode::client::RegionAttributes>(attributes));
 
-          apache::geode::client::RegionPtr& nativeptr( NativePtr->createSubregion(
-            mg_subregionName.CharPtr, p_attrs /*NULLPTR*/ ) );
-          return Region::Create( nativeptr.ptr( ) );
+        apache::geode::client::RegionPtr& nativeptr(NativePtr->createSubregion(
+          mg_subregionName.CharPtr, p_attrs /*NULLPTR*/));
+        return Region::Create(nativeptr.ptr());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
 
       generic<class TKey, class TValue>
-      System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ Region<TKey, TValue>::SubRegions( bool recursive )
+      System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ Region<TKey, TValue>::SubRegions(bool recursive)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::VectorOfRegion vsr;
-          NativePtr->subregions( recursive, vsr );
-          array<IRegion<TKey, TValue>^>^ subRegions =
-            gcnew array<IRegion<TKey, TValue>^>( vsr.size( ) );
+        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++ )
-          {
-            apache::geode::client::RegionPtr& nativeptr( vsr[ index ] );
-            subRegions[ index ] = Region<TKey, TValue>::Create( nativeptr.ptr( ) );
-          }
-          System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ collection =
-            (System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^)subRegions;
-          return collection;
+        for (int32_t index = 0; index < vsr.size(); index++)
+        {
+          apache::geode::client::RegionPtr& nativeptr(vsr[index]);
+          subRegions[index] = Region<TKey, TValue>::Create(nativeptr.ptr());
+        }
+        System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ collection =
+          (System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^)subRegions;
+        return collection;
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      RegionEntry<TKey, TValue>^ Region<TKey, TValue>::GetEntry( TKey key )
+      RegionEntry<TKey, TValue>^ Region<TKey, TValue>::GetEntry(TKey key)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-          apache::geode::client::RegionEntryPtr& nativeptr( NativePtr->getEntry( keyptr ) );
-          return RegionEntry<TKey, TValue>::Create( nativeptr.ptr( ) );
+          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 */
       }
@@ -787,64 +787,64 @@ namespace Apache
       generic<class TKey, class TValue>
       System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^ Region<TKey, TValue>::GetEntries(bool recursive)
       {
-         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::VectorOfRegionEntry vc;
-          NativePtr->entries( vc, recursive );          
-          array<RegionEntry<TKey, TValue>^>^ entryarr = gcnew array<RegionEntry<TKey, TValue>^>( vc.size( ) );
+        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++ )
-          {
-            apache::geode::client::RegionEntryPtr& nativeptr( vc[ index ] );
-            entryarr[ index ] = RegionEntry<TKey, TValue>::Create( nativeptr.ptr( ) );
-          }
-          System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^ collection =
-            (System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^)entryarr;
+        for (int32_t index = 0; index < vc.size(); index++)
+        {
+          apache::geode::client::RegionEntryPtr& nativeptr(vc[index]);
+          entryarr[index] = RegionEntry<TKey, TValue>::Create(nativeptr.ptr());
+        }
+        System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^ collection =
+          (System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^)entryarr;
 
-          return collection;          
+        return collection;
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
-         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
-        
       }
 
       generic<class TKey, class TValue>
       IRegionService^ Region<TKey, TValue>::RegionService::get()
-      {        
+      {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::RegionServicePtr& nativeptr( NativePtr->getRegionService( ) );
+          apache::geode::client::RegionServicePtr& nativeptr(NativePtr->getRegionService());
 
-          apache::geode::client::Cache* realCache = dynamic_cast<apache::geode::client::Cache*>(nativeptr.ptr());
+        apache::geode::client::Cache* realCache = dynamic_cast<apache::geode::client::Cache*>(nativeptr.ptr());
+
+        if (realCache != NULL)
+        {
+          return Apache::Geode::Client::Cache::Create(((apache::geode::client::CachePtr)nativeptr).ptr());
+        }
+        else
+        {
+          return Apache::Geode::Client::AuthenticatedCache::Create(nativeptr.ptr());
+        }
 
-          if(realCache != NULL)
-          {
-            return Apache::Geode::Client::Cache::Create( ((apache::geode::client::CachePtr)nativeptr).ptr( ) );
-          }
-          else
-          {
-            return Apache::Geode::Client::AuthenticatedCache::Create( nativeptr.ptr( ) );
-          }
-          
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::ContainsValueForKey( TKey key )
+      bool Region<TKey, TValue>::ContainsValueForKey(TKey key)
       {
-         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-           apache::geode::client::CacheableKeyPtr keyptr( Serializable::GetUnmanagedValueGeneric<TKey>( key ) );
-           return NativePtr->containsValueForKey( keyptr );
+          apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
+        return NativePtr->containsValueForKey(keyptr);
 
-         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
       int Region<TKey, TValue>::Count::get()
       {
-		_GF_MG_EXCEPTION_TRY2/* due to auto replace */
-        return NativePtr->size();
-		_GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+          return NativePtr->size();
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
@@ -858,18 +858,18 @@ namespace Apache
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           apache::geode::client::UserDataPtr callbackptr(
-              Serializable::GetUnmanagedValueGeneric<Object^>( callbackArg ) );          
-          NativePtr->clear(callbackptr );
+          Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
+        NativePtr->clear(callbackptr);
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::CopyTo(array<KeyValuePair<TKey,TValue>>^ toArray,
-        int startIdx)
+      void Region<TKey, TValue>::CopyTo(array<KeyValuePair<TKey, TValue>>^ toArray,
+                                        int startIdx)
       {
         if (toArray == nullptr)
         {
-          throw gcnew System::ArgumentNullException;            
+          throw gcnew System::ArgumentNullException;
         }
         if (startIdx < 0)
         {
@@ -878,22 +878,22 @@ namespace Apache
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-        apache::geode::client::VectorOfRegionEntry vc;
-        NativePtr->entries( vc, false );        
+          apache::geode::client::VectorOfRegionEntry vc;
+        NativePtr->entries(vc, false);
 
         if (toArray->Rank > 1 || (vc.size() > (toArray->Length - startIdx)))
         {
           throw gcnew System::ArgumentException;
-        }          
+        }
 
-        for( int32_t index = 0; index < vc.size( ); index++ )
+        for (int32_t index = 0; index < vc.size(); 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);
+          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);
           ++startIdx;
-        }               
+        }
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -905,7 +905,7 @@ namespace Apache
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::RegisterKeys( System::Collections::Generic::ICollection<TKey>^ keys )
+      void Region<TKey, TValue>::RegisterKeys(System::Collections::Generic::ICollection<TKey>^ keys)
       {
         RegisterKeys(keys, false, false);
       }
@@ -918,9 +918,9 @@ namespace Apache
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RegisterKeys(System::Collections::Generic::ICollection<TKey>^ keys,
-        bool isDurable,
-        bool getInitialValues,
-        bool receiveValues)
+                                              bool isDurable,
+                                              bool getInitialValues,
+                                              bool receiveValues)
       {
         if (keys != nullptr)
         {
@@ -928,15 +928,15 @@ namespace Apache
 
             apache::geode::client::VectorOfCacheableKey vecKeys;
 
-            for each(TKey item in keys)
-            {
-              vecKeys.push_back(
-                Serializable::GetUnmanagedValueGeneric<TKey>( item ));
-            }
-            NativePtr->registerKeys(vecKeys, isDurable, getInitialValues, receiveValues);
+          for each(TKey item in keys)
+          {
+            vecKeys.push_back(
+              Serializable::GetUnmanagedValueGeneric<TKey>(item));
+          }
+          NativePtr->registerKeys(vecKeys, isDurable, getInitialValues, receiveValues);
 
           _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
-        }        
+        }
       }
 
       generic<class TKey, class TValue>
@@ -948,53 +948,53 @@ namespace Apache
 
             apache::geode::client::VectorOfCacheableKey vecKeys;
 
-            for each(TKey item in keys)
-            {
-              vecKeys.push_back(
-                Serializable::GetUnmanagedValueGeneric<TKey>( item ));
-            }
+          for each(TKey item in keys)
+          {
+            vecKeys.push_back(
+              Serializable::GetUnmanagedValueGeneric<TKey>(item));
+          }
 
-            NativePtr->unregisterKeys(vecKeys);
+          NativePtr->unregisterKeys(vecKeys);
 
           _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
         }
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::RegisterAllKeys( )
+      void Region<TKey, TValue>::RegisterAllKeys()
       {
-        RegisterAllKeys( false, nullptr, false );
+        RegisterAllKeys(false, nullptr, false);
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::RegisterAllKeys( bool isDurable )
+      void Region<TKey, TValue>::RegisterAllKeys(bool isDurable)
       {
-        RegisterAllKeys( isDurable, nullptr, false );
+        RegisterAllKeys(isDurable, nullptr, false);
       }
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RegisterAllKeys(bool isDurable,
-            System::Collections::Generic::ICollection<TKey>^ resultKeys,
-            bool getInitialValues)
+                                                  System::Collections::Generic::ICollection<TKey>^ resultKeys,
+                                                  bool getInitialValues)
       {
         RegisterAllKeys(isDurable, resultKeys, getInitialValues, true);
       }
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RegisterAllKeys(bool isDurable,
-            System::Collections::Generic::ICollection<TKey>^ resultKeys,
-            bool getInitialValues,
-            bool receiveValues)
+                                                  System::Collections::Generic::ICollection<TKey>^ resultKeys,
+                                                  bool getInitialValues,
+                                                  bool receiveValues)
       {
-         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           if (resultKeys != nullptr) {
             apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
               new apache::geode::client::VectorOfCacheableKey());
 
-            NativePtr->registerAllKeys(isDurable, mg_keys, getInitialValues, receiveValues);            
+            NativePtr->registerAllKeys(isDurable, mg_keys, getInitialValues, receiveValues);
 
-            for (int32_t index = 0; index < mg_keys->size(); ++index) {              
+            for (int32_t index = 0; index < mg_keys->size(); ++index) {
               resultKeys->Add(Serializable::GetManagedValueGeneric<TKey>(
                 mg_keys->operator[](index)));
             }
@@ -1003,7 +1003,7 @@ namespace Apache
             NativePtr->registerAllKeys(isDurable, NULLPTR, getInitialValues, receiveValues);
           }
 
-        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
@@ -1012,20 +1012,20 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           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++ )
-          {
-            apache::geode::client::CacheableKeyPtr& nativeptr( vc[ index ] );
-            keyarr[ index ] = Serializable::GetManagedValueGeneric<TKey>(nativeptr);
-            //collectionlist[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
-          }
+        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++)
+        {
+          apache::geode::client::CacheableKeyPtr& nativeptr(vc[index]);
+          keyarr[index] = Serializable::GetManagedValueGeneric<TKey>(nativeptr);
+          //collectionlist[ index ] = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
+        }
 
-          System::Collections::Generic::ICollection<TKey>^ collectionlist =
-            (System::Collections::Generic::ICollection<TKey>^)keyarr;
-          return collectionlist;
+        System::Collections::Generic::ICollection<TKey>^ collectionlist =
+          (System::Collections::Generic::ICollection<TKey>^)keyarr;
+        return collectionlist;
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -1036,92 +1036,92 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::VectorOfCacheableString vc;
-          NativePtr->getInterestListRegex( vc );
-          array<String^>^ strarr =
-            gcnew array<String^>( vc.size( ) );
-          //List<String>^ collectionlist = gcnew List<String>(vc.size());
-          for( int32_t index = 0; index < vc.size( ); index++ )
-          {
-            strarr[index] = ManagedString::Get( vc[index]->asChar());
-            //collectionlist[ index ] = Serializable::GetManagedValue<TValue>(nativeptr);
-          }
-          System::Collections::Generic::ICollection<String^>^ collectionlist =
-            (System::Collections::Generic::ICollection<String^>^)strarr;
-          return collectionlist;
+        NativePtr->getInterestListRegex(vc);
+        array<String^>^ strarr =
+          gcnew array<String^>(vc.size());
+        //List<String>^ collectionlist = gcnew List<String>(vc.size());
+        for (int32_t index = 0; index < vc.size(); index++)
+        {
+          strarr[index] = ManagedString::Get(vc[index]->asChar());
+          //collectionlist[ index ] = Serializable::GetManagedValue<TValue>(nativeptr);
+        }
+        System::Collections::Generic::ICollection<String^>^ collectionlist =
+          (System::Collections::Generic::ICollection<String^>^)strarr;
+        return collectionlist;
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::UnregisterAllKeys( )
+      void Region<TKey, TValue>::UnregisterAllKeys()
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          NativePtr->unregisterAllKeys( );
+          NativePtr->unregisterAllKeys();
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::RegisterRegex(String^ regex )
+      void Region<TKey, TValue>::RegisterRegex(String^ regex)
       {
         RegisterRegex(regex, false, nullptr, false);
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::RegisterRegex(String^ regex , bool isDurable)
+      void Region<TKey, TValue>::RegisterRegex(String^ regex, bool isDurable)
       {
         RegisterRegex(regex, isDurable, nullptr, false);
       }
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RegisterRegex(String^ regex, bool isDurable,
-            System::Collections::Generic::ICollection<TKey>^ resultKeys)
+                                                System::Collections::Generic::ICollection<TKey>^ resultKeys)
       {
         RegisterRegex(regex, isDurable, resultKeys, false);
       }
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RegisterRegex(String^ regex, bool isDurable,
-            System::Collections::Generic::ICollection<TKey>^ resultKeys, bool getInitialValues)
+                                                System::Collections::Generic::ICollection<TKey>^ resultKeys, bool getInitialValues)
       {
         RegisterRegex(regex, isDurable, resultKeys, getInitialValues, true);
       }
 
       generic<class TKey, class TValue>
       void Region<TKey, TValue>::RegisterRegex(String^ regex, bool isDurable,
-            System::Collections::Generic::ICollection<TKey>^ resultKeys, bool getInitialValues, bool receiveValues)
+                                                System::Collections::Generic::ICollection<TKey>^ resultKeys, bool getInitialValues, bool receiveValues)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          ManagedString mg_regex( regex );
-          if (resultKeys != nullptr) {
-            apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
-              new apache::geode::client::VectorOfCacheableKey());
-            NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
-              mg_keys, getInitialValues, receiveValues);
+          ManagedString mg_regex(regex);
+        if (resultKeys != nullptr) {
+          apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
+            new apache::geode::client::VectorOfCacheableKey());
+          NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
+                                    mg_keys, getInitialValues, receiveValues);
 
-            for (int32_t index = 0; index < mg_keys->size(); ++index) {              
-              resultKeys->Add(Serializable::GetManagedValueGeneric<TKey>(
-                mg_keys->operator[](index)));
-            }
-          }
-          else {
-            NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
-              NULLPTR, getInitialValues, receiveValues);
+          for (int32_t index = 0; index < mg_keys->size(); ++index) {
+            resultKeys->Add(Serializable::GetManagedValueGeneric<TKey>(
+              mg_keys->operator[](index)));
           }
+        }
+        else {
+          NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
+                                    NULLPTR, getInitialValues, receiveValues);
+        }
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      void Region<TKey, TValue>::UnregisterRegex( String^ regex )
+      void Region<TKey, TValue>::UnregisterRegex(String^ regex)
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          ManagedString mg_regex( regex );
-          NativePtr->unregisterRegex( mg_regex.CharPtr );
+          ManagedString mg_regex(regex);
+        NativePtr->unregisterRegex(mg_regex.CharPtr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
@@ -1129,109 +1129,109 @@ namespace Apache
 
       generic<class TKey, class TValue>
       generic<class TResult>
-      ISelectResults<TResult>^ Region<TKey, TValue>::Query( String^ predicate )
+      ISelectResults<TResult>^ Region<TKey, TValue>::Query(String^ predicate)
       {
         //return Query( predicate, DEFAULT_QUERY_RESPONSE_TIMEOUT );
-        ManagedString mg_predicate( predicate );
+        ManagedString mg_predicate(predicate);
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::SelectResultsPtr& nativeptr = NativePtr->query(
-            mg_predicate.CharPtr, DEFAULT_QUERY_RESPONSE_TIMEOUT );
-          if ( nativeptr.ptr( ) == NULL ) return nullptr;
+          mg_predicate.CharPtr, DEFAULT_QUERY_RESPONSE_TIMEOUT);
+        if (nativeptr.ptr() == NULL) return nullptr;
 
-          apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
-            nativeptr.ptr( ) );
-          if ( resultptr == NULL )
-          {
-            apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
-              nativeptr.ptr( ) );
-            if ( structptr == NULL )
-            {
-              return nullptr;
-            }
-            return StructSet<TResult>::Create(structptr);
-          }
-          else
+        apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
+          nativeptr.ptr());
+        if (resultptr == NULL)
+        {
+          apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
+            nativeptr.ptr());
+          if (structptr == NULL)
           {
-            return ResultSet<TResult>::Create(resultptr);
+            return nullptr;
           }
+          return StructSet<TResult>::Create(structptr);
+        }
+        else
+        {
+          return ResultSet<TResult>::Create(resultptr);
+        }
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
 
       generic<class TKey, class TValue>
       generic<class TResult>
-      ISelectResults<TResult>^ Region<TKey, TValue>::Query( String^ predicate, uint32_t timeout )
+      ISelectResults<TResult>^ Region<TKey, TValue>::Query(String^ predicate, uint32_t timeout)
       {
-        ManagedString mg_predicate( predicate );
+        ManagedString mg_predicate(predicate);
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::SelectResultsPtr& nativeptr = NativePtr->query(
-            mg_predicate.CharPtr, timeout );
-          if ( nativeptr.ptr( ) == NULL ) return nullptr;
+          mg_predicate.CharPtr, timeout);
+        if (nativeptr.ptr() == NULL) return nullptr;
 
-          apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
-            nativeptr.ptr( ) );
-          if ( resultptr == NULL )
-          {
-            apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
-              nativeptr.ptr( ) );
-            if ( structptr == NULL )
-            {
-              return nullptr;
-            }
-            return StructSet<TResult>::Create(structptr);
-          }
-          else
+        apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
+          nativeptr.ptr());
+        if (resultptr == NULL)
+        {
+          apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
+            nativeptr.ptr());
+          if (structptr == NULL)
           {
-            return ResultSet<TResult>::Create(resultptr);
+            return nullptr;
           }
+          return StructSet<TResult>::Create(structptr);
+        }
+        else
+        {
+          return ResultSet<TResult>::Create(resultptr);
+        }
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
 
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::ExistsValue( String^ predicate )
+      bool Region<TKey, TValue>::ExistsValue(String^ predicate)
       {
-        return ExistsValue( predicate, DEFAULT_QUERY_RESPONSE_TIMEOUT );
+        return ExistsValue(predicate, DEFAULT_QUERY_RESPONSE_TIMEOUT);
       }
 
       generic<class TKey, class TValue>
-      bool Region<TKey, TValue>::ExistsValue( String^ predicate, uint32_t timeout )
+      bool Region<TKey, TValue>::ExistsValue(String^ predicate, uint32_t timeout)
       {
-        ManagedString mg_predicate( predicate );
+        ManagedString mg_predicate(predicate);
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          return NativePtr->existsValue( mg_predicate.CharPtr, timeout );
+          return NativePtr->existsValue(mg_predicate.CharPtr, timeout);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
 
       generic<class TKey, class TValue>
-      Object^ Region<TKey, TValue>::SelectValue( String^ predicate )
+      Object^ Region<TKey, TValue>::SelectValue(String^ predicate)
       {
-        return SelectValue( predicate, DEFAULT_QUERY_RESPONSE_TIMEOUT );
+        return SelectValue(predicate, DEFAULT_QUERY_RESPONSE_TIMEOUT);
       }
 
       generic<class TKey, class TValue>
-      Object^ Region<TKey, TValue>::SelectValue( String^ predicate, uint32_t timeout )
+      Object^ Region<TKey, TValue>::SelectValue(String^ predicate, uint32_t timeout)
       {
-        ManagedString mg_predicate( predicate );
+        ManagedString mg_predicate(predicate);
 
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
-          apache::geode::client::CacheablePtr& nativeptr( NativePtr->selectValue(
-            mg_predicate.CharPtr, timeout ) );
+          apache::geode::client::CacheablePtr& nativeptr(NativePtr->selectValue(
+          mg_predicate.CharPtr, timeout));
 
-          return Serializable::GetManagedValueGeneric<Object^>(nativeptr);
+        return Serializable::GetManagedValueGeneric<Object^>(nativeptr);
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
       }
-      
+
       generic<class TKey, class TValue>
       ISubscriptionService<TKey>^ Region<TKey, TValue>::GetSubscriptionService()
       {
@@ -1241,9 +1241,9 @@ namespace Apache
       generic<class TKey, class TValue>
       IRegion<TKey, TValue>^ Region<TKey, TValue>::GetLocalView()
       {
-        return ( _NativePtr != nullptr ?
-            gcnew LocalRegion<TKey, TValue>( _NativePtr ) : nullptr );       
+        return (_NativePtr != nullptr ?
+                gcnew LocalRegion<TKey, TValue>(_NativePtr) : nullptr);
+      }
     }  // namespace Client
   }  // namespace Geode
 }  // namespace Apache
- } //namespace 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fc9f1f6f/src/clicache/src/RegionAttributes.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionAttributes.hpp b/src/clicache/src/RegionAttributes.hpp
index dfa3b40..074b044 100644
--- a/src/clicache/src/RegionAttributes.hpp
+++ b/src/clicache/src/RegionAttributes.hpp
@@ -23,7 +23,7 @@
 #include "IGFSerializable.hpp"
 #include "ExpirationAction.hpp"
 #include "DiskPolicyType.hpp"
-#include "GemFireClassIds.hpp"
+#include "GeodeClassIds.hpp"
 
 #include "ICacheLoader.hpp"
 #include "ICacheWriter.hpp"
@@ -68,7 +68,7 @@ namespace Apache
       /// <seealso cref="Region.Attributes" />
       generic <class TKey, class TValue>
       public ref class RegionAttributes sealed
-				: public Client::Internal::SBWrap<apache::geode::client::RegionAttributes>, public IGFSerializable
+        : public Client::Internal::SBWrap<apache::geode::client::RegionAttributes>, public IGFSerializable
       {
       public:
 
@@ -80,7 +80,7 @@ namespace Apache
         /// </returns>
         property Apache::Geode::Client::ICacheLoader<TKey, TValue>^ CacheLoader
         {
-          Apache::Geode::Client::ICacheLoader<TKey, TValue>^ get( );
+          Apache::Geode::Client::ICacheLoader<TKey, TValue>^ get();
         }
 
         /// <summary>
@@ -91,7 +91,7 @@ namespace Apache
         /// </returns>
         property ICacheWriter<TKey, TValue>^ CacheWriter
         {
-          ICacheWriter<TKey, TValue>^ get( );
+          ICacheWriter<TKey, TValue>^ get();
         }
 
         /// <summary>
@@ -102,7 +102,7 @@ namespace Apache
         /// </returns>
         property ICacheListener<TKey, TValue>^ CacheListener
         {
-          ICacheListener<TKey, TValue>^ get( );
+          ICacheListener<TKey, TValue>^ get();
         }
 
         /// <summary>
@@ -113,7 +113,7 @@ namespace Apache
         /// </returns>
         property IPartitionResolver<TKey, TValue>^ PartitionResolver
         {
-          IPartitionResolver<TKey, TValue>^ get( );
+          IPartitionResolver<TKey, TValue>^ get();
         }
 
         /// <summary>
@@ -122,7 +122,7 @@ namespace Apache
         /// <returns>the timeToLive duration for this region, in seconds</returns>
         property int32_t RegionTimeToLive
         {
-          int32_t get( );
+          int32_t get();
         }
 
         /// <summary>
@@ -131,7 +131,7 @@ namespace Apache
         /// <returns>the timeToLive action for this region</returns>
         property ExpirationAction RegionTimeToLiveAction
         {
-          ExpirationAction get( );
+          ExpirationAction get();
         }
 
         /// <summary>
@@ -140,7 +140,7 @@ namespace Apache
         /// <returns>the IdleTimeout duration for this region, in seconds</returns>
         property int32_t RegionIdleTimeout
         {
-          int32_t get( );
+          int32_t get();
         }
 
         /// <summary>
@@ -149,7 +149,7 @@ namespace Apache
         /// <returns>the idleTimeout action for this region</returns>
         property ExpirationAction RegionIdleTimeoutAction
         {
-          ExpirationAction get( );
+          ExpirationAction get();
         }
 
         /// <summary>
@@ -158,7 +158,7 @@ namespace Apache
         /// <returns>the timeToLive duration for entries in this region, in seconds</returns>
         property int32_t EntryTimeToLive
         {
-          int32_t get( );
+          int32_t get();
         }
 
         /// <summary>
@@ -167,7 +167,7 @@ namespace Apache
         /// <returns>the timeToLive action for entries in this region</returns>
         property ExpirationAction EntryTimeToLiveAction
         {
-          ExpirationAction get( );
+          ExpirationAction get();
         }
 
         /// <summary>
@@ -176,7 +176,7 @@ namespace Apache
         /// <returns>the idleTimeout duration for entries in this region, in seconds</returns>
         property int32_t EntryIdleTimeout
         {
-          int32_t get( );
+          int32_t get();
         }
 
         /// <summary>
@@ -185,7 +185,7 @@ namespace Apache
         /// <returns>the idleTimeout action for entries in this region</returns>
         property ExpirationAction EntryIdleTimeoutAction
         {
-          ExpirationAction get( );
+          ExpirationAction get();
         }
 
         /// <summary>
@@ -194,7 +194,7 @@ namespace Apache
         /// <returns>true if caching is enabled</returns>
         property bool CachingEnabled
         {
-          bool get( );
+          bool get();
         }
 
 
@@ -206,7 +206,7 @@ namespace Apache
         /// <returns>the initial capacity</returns>
         property int32_t InitialCapacity
         {
-          int32_t get( );
+          int32_t get();
         }
 
         /// <summary>
@@ -215,7 +215,7 @@ namespace Apache
         /// <returns>the load factor</returns>
         property Single LoadFactor
         {
-          Single get( );
+          Single get();
         }
 
         /// <summary>
@@ -225,7 +225,7 @@ namespace Apache
         /// <seealso cref="AttributesFactory" />
         property int32_t ConcurrencyLevel
         {
-          int32_t get( );
+          int32_t get();
         }
 
         /// <summary>
@@ -235,7 +235,7 @@ namespace Apache
         /// <returns>the maximum LRU size, or 0 for no limit</returns>
         property uint32_t LruEntriesLimit
         {
-          uint32_t get( );
+          uint32_t get();
         }
 
         /// <summary>
@@ -244,7 +244,7 @@ namespace Apache
         /// <returns>the disk policy type, default is null</returns>
         property DiskPolicyType DiskPolicy
         {
-          DiskPolicyType get( );
+          DiskPolicyType get();
         }
 
         /// <summary>
@@ -253,7 +253,7 @@ namespace Apache
         /// <returns>the LRU eviction action</returns>
         property ExpirationAction LruEvictionAction
         {
-          ExpirationAction get( );
+          ExpirationAction get();
         }
 
         /// <summary>
@@ -263,7 +263,7 @@ namespace Apache
         /// <returns>the CacheLoader library path</returns>
         property String^ CacheLoaderLibrary
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -273,7 +273,7 @@ namespace Apache
         /// <returns>the CacheLoader factory function name</returns>
         property String^ CacheLoaderFactory
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -283,7 +283,7 @@ namespace Apache
         /// <returns>the CacheListener library path</returns>
         property String^ CacheListenerLibrary
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -293,7 +293,7 @@ namespace Apache
         /// <returns>the PartitionResolver library path</returns>
         property String^ PartitionResolverLibrary
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -303,7 +303,7 @@ namespace Apache
         /// <returns>the CacheListener factory function name</returns>
         property String^ CacheListenerFactory
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -313,7 +313,7 @@ namespace Apache
         /// <returns>the PartitionResolver factory function name</returns>
         property String^ PartitionResolverFactory
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -323,7 +323,7 @@ namespace Apache
         /// <returns>the CacheWriter library path</returns>
         property String^ CacheWriterLibrary
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -333,7 +333,7 @@ namespace Apache
         /// <returns>the CacheWriter factory function name</returns>
         property String^ CacheWriterFactory
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -341,14 +341,14 @@ namespace Apache
         /// </summary>
         /// <param name="other">attribute object to compare</param>
         /// <returns>true if equal</returns>
-        bool Equals( RegionAttributes<TKey, TValue>^ other );
+        bool Equals(RegionAttributes<TKey, TValue>^ other);
 
         /// <summary>
         /// True if all the attributes are equal to those of <c>other</c>.
         /// </summary>
         /// <param name="other">attribute object to compare</param>
         /// <returns>true if equal</returns>
-        virtual bool Equals( Object^ other ) override;
+        virtual bool Equals(Object^ other) override;
 
         /// <summary>
         /// Throws IllegalStateException if the attributes are not suited for serialization
@@ -356,7 +356,7 @@ namespace Apache
         /// directly instead of providing the library path and factory function.
         /// </summary>
         /// <exception cref="IllegalStateException">if the attributes cannot be serialized</exception>
-        void ValidateSerializableAttributes( );
+        void ValidateSerializableAttributes();
 
         /// <summary>
         /// This method returns the list of endpoints (servername:portnumber) separated by commas.
@@ -364,7 +364,7 @@ namespace Apache
         /// <returns>list of endpoints</returns>
         property String^ Endpoints
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -373,7 +373,7 @@ namespace Apache
         /// <returns>pool name</returns>
         property String^ PoolName
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -382,16 +382,16 @@ namespace Apache
         /// <returns>true if enabled</returns>
         property bool ClientNotificationEnabled
         {
-          bool get( );
+          bool get();
         }
         /// <summary>
         /// True if cloning is enabled for in case of delta.
         /// </summary>
         /// <returns>true if enabled</returns>
 
-        property bool CloningEnabled 
+        property bool CloningEnabled
         {
-          bool get( );
+          bool get();
         }
 
         /// <summary>
@@ -401,7 +401,7 @@ namespace Apache
         /// <returns>the PersistenceManager library path</returns>
         property String^ PersistenceLibrary
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -411,7 +411,7 @@ namespace Apache
         /// <returns>the PersistenceManager factory function name</returns>
         property String^ PersistenceFactory
         {
-          String^ get( );
+          String^ get();
         }
 
         /// <summary>
@@ -420,7 +420,7 @@ namespace Apache
         /// <returns>properties for the PersistenceManager</returns>
         property Properties<String^, String^>^ PersistenceProperties
         {
-          Properties<String^, String^>^ get( );
+          Properties<String^, String^>^ get();
         }
 
         /// <summary>
@@ -430,28 +430,28 @@ namespace Apache
         /// <seealso cref="AttributesFactory" />
         property bool ConcurrencyChecksEnabled
         {
-          bool get( );
+          bool get();
         }
 
         /// <summary>
         /// Serializes this Properties object.
         /// </summary>
         /// <param name="output">the DataOutput stream to use for serialization</param>
-        virtual void ToData( DataOutput^ output );
+        virtual void ToData(DataOutput^ output);
 
         /// <summary>
         /// Deserializes this Properties object.
         /// </summary>
         /// <param name="input">the DataInput stream to use for reading data</param>
         /// <returns>the deserialized Properties object</returns>
-        virtual IGFSerializable^ FromData( DataInput^ input );
+        virtual IGFSerializable^ FromData(DataInput^ input);
 
         /// <summary>
         /// return the size of this object in bytes
         /// </summary>
         virtual property uint32_t ObjectSize
         {
-          virtual uint32_t get( )
+          virtual uint32_t get()
           {
             return 0;  //don't care
           }
@@ -464,9 +464,9 @@ namespace Apache
         /// <seealso cref="../../IGFSerializable.ClassId" />
         virtual property uint32_t ClassId
         {
-          inline virtual uint32_t get( )
+          inline virtual uint32_t get()
           {
-            return GemFireClassIds::RegionAttributes;
+            return GeodeClassIds::RegionAttributes;
           }
         }
 
@@ -481,10 +481,10 @@ namespace Apache
         /// <returns>
         /// The managed wrapper object; null if the native pointer is null.
         /// </returns>
-        inline static RegionAttributes<TKey, TValue>^ Create( apache::geode::client::RegionAttributes* nativeptr )
+        inline static RegionAttributes<TKey, TValue>^ Create(apache::geode::client::RegionAttributes* nativeptr)
         {
-          return ( nativeptr != nullptr ?
-            gcnew RegionAttributes<TKey, TValue>( nativeptr ) : nullptr );
+          return (nativeptr != nullptr ?
+                  gcnew RegionAttributes<TKey, TValue>(nativeptr) : nullptr);
         }
 
 
@@ -494,8 +494,8 @@ namespace Apache
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline RegionAttributes<TKey, TValue>( apache::geode::client::RegionAttributes* nativeptr )
-          : SBWrap( nativeptr ) { }
+        inline RegionAttributes<TKey, TValue>(apache::geode::client::RegionAttributes* nativeptr)
+          : SBWrap(nativeptr) { }
       };
     }  // namespace Client
   }  // namespace Geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/fc9f1f6f/src/clicache/src/ResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultCollector.hpp b/src/clicache/src/ResultCollector.hpp
index d4c1c48..5ff7611 100644
--- a/src/clicache/src/ResultCollector.hpp
+++ b/src/clicache/src/ResultCollector.hpp
@@ -41,10 +41,10 @@ namespace Apache
       /// collect function execution results, default collector
       /// </summary>
      generic<class TResult>
-      public ref class ResultCollector
-        : public Internal::SBWrap<apache::geode::client::ResultCollector>, public IResultCollector<TResult>
-      {
-      public:
+     public ref class ResultCollector
+       : public Internal::SBWrap<apache::geode::client::ResultCollector>, public IResultCollector<TResult>
+     {
+     public:
 
         /// <summary>
         /// add result from a single function execution


Mime
View raw message