geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [31/50] [abbrv] geode git commit: GEODE-2316: Removed namespace Apache.Geode.Client.Generic.
Date Mon, 23 Jan 2017 19:17:23 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Serializable.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.cpp b/src/clicache/src/Serializable.cpp
index ff46f25..6acaeb3 100644
--- a/src/clicache/src/Serializable.cpp
+++ b/src/clicache/src/Serializable.cpp
@@ -64,10 +64,9 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
-      void Apache::Geode::Client::Generic::Serializable::ToData(
-        Apache::Geode::Client::Generic::DataOutput^ output)
+
+      void Apache::Geode::Client::Serializable::ToData(
+        Apache::Geode::Client::DataOutput^ output)
       {
         if (output->IsManagedObject()) {
           output->WriteBytesToUMDataOutput();          
@@ -79,9 +78,9 @@ namespace Generic
           output->SetBuffer();          
         }
       }
-      Apache::Geode::Client::Generic::IGFSerializable^
-        Apache::Geode::Client::Generic::Serializable::FromData(
-        Apache::Geode::Client::Generic::DataInput^ input)
+      Apache::Geode::Client::IGFSerializable^
+        Apache::Geode::Client::Serializable::FromData(
+        Apache::Geode::Client::DataInput^ input)
       {
          if(input->IsManagedObject()) {
           input->AdvanceUMCursor();
@@ -95,12 +94,12 @@ namespace Generic
         return this;
       }
 
-      uint32_t Apache::Geode::Client::Generic::Serializable::ObjectSize::get()
+      uint32_t Apache::Geode::Client::Serializable::ObjectSize::get()
       {
         return NativePtr->objectSize();
       }
 
-      uint32_t Apache::Geode::Client::Generic::Serializable::ClassId::get()
+      uint32_t Apache::Geode::Client::Serializable::ClassId::get()
       {
         int8_t typeId = NativePtr->typeId();
         if (typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData ||
@@ -112,7 +111,7 @@ namespace Generic
         }
       }
 
-      String^ Apache::Geode::Client::Generic::Serializable::ToString()
+      String^ Apache::Geode::Client::Serializable::ToString()
       {
         apache::geode::client::CacheableStringPtr& cStr = NativePtr->toString();
         if (cStr->isWideString()) {
@@ -122,99 +121,99 @@ namespace Generic
         }
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (Byte value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (Byte value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^) CacheableByte::Create(value);
+        return (Apache::Geode::Client::Serializable^) CacheableByte::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (bool value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (bool value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableBoolean::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableBoolean::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<bool>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<bool>^ value)
       {
-       // return (Apache::Geode::Client::Generic::Serializable^)Apache::Geode::Client::Generic::CacheableBooleanArray::Create(value);
+       // return (Apache::Geode::Client::Serializable^)Apache::Geode::Client::CacheableBooleanArray::Create(value);
 				//TODO:split
 				return nullptr;
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<Byte>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<Byte>^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableBytes::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableBytes::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (Char value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (Char value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableCharacter::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableCharacter::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<Char>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<Char>^ value)
       {
-        //return (Apache::Geode::Client::Generic::Serializable^)Apache::Geode::Client::Generic::CacheableCharArray::Create(value);
+        //return (Apache::Geode::Client::Serializable^)Apache::Geode::Client::CacheableCharArray::Create(value);
 				//TODO:split
 				return nullptr;
 
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (Double value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (Double value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableDouble::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableDouble::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<Double>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<Double>^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableDoubleArray::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableDoubleArray::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (Single value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (Single value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableFloat::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableFloat::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<Single>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<Single>^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableFloatArray::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableFloatArray::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (int16_t value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (int16_t value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableInt16::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableInt16::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<int16_t>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<int16_t>^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableInt16Array::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableInt16Array::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (int32_t value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (int32_t value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableInt32::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableInt32::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<int32_t>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<int32_t>^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableInt32Array::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableInt32Array::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (int64_t value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (int64_t value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableInt64::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableInt64::Create(value);
       }
 
       /*Apache::Geode::Client::*/Serializable::operator /*Apache::Geode::Client::*/Serializable^ (array<int64_t>^ value)
       {
-				return (Apache::Geode::Client::Generic::Serializable^)Apache::Geode::Client::Generic::CacheableInt64Array::Create(value);
+				return (Apache::Geode::Client::Serializable^)Apache::Geode::Client::CacheableInt64Array::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (String^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (String^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableString::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableString::Create(value);
       }
 
-      Apache::Geode::Client::Generic::Serializable::operator Apache::Geode::Client::Generic::Serializable^ (array<String^>^ value)
+      Apache::Geode::Client::Serializable::operator Apache::Geode::Client::Serializable^ (array<String^>^ value)
       {
-        return (Apache::Geode::Client::Generic::Serializable^)CacheableStringArray::Create(value);
+        return (Apache::Geode::Client::Serializable^)CacheableStringArray::Create(value);
       }
 
 			int32 Serializable::GetPDXIdForType(const char* poolName, IGFSerializable^ pdxType)
@@ -485,7 +484,7 @@ namespace Generic
 				}
       }
 
-      void Apache::Geode::Client::Generic::Serializable::RegisterTypeGeneric(TypeFactoryMethodGeneric^ creationMethod)
+      void Apache::Geode::Client::Serializable::RegisterTypeGeneric(TypeFactoryMethodGeneric^ creationMethod)
       {
         if (creationMethod == nullptr) {
           throw gcnew IllegalArgumentException("Serializable.RegisterType(): "
@@ -522,7 +521,7 @@ namespace Generic
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
 
-      void Apache::Geode::Client::Generic::Serializable::RegisterTypeGeneric(Byte typeId,
+      void Apache::Geode::Client::Serializable::RegisterTypeGeneric(Byte typeId,
         TypeFactoryMethodGeneric^ creationMethod, Type^ type)
       {
         if (creationMethod == nullptr) {
@@ -572,7 +571,7 @@ namespace Generic
         }
       }
 
-      void Apache::Geode::Client::Generic::Serializable::UnregisterTypeGeneric(Byte typeId)
+      void Apache::Geode::Client::Serializable::UnregisterTypeGeneric(Byte typeId)
       {
         BuiltInDelegatesGeneric->Remove(typeId);
         _GF_MG_EXCEPTION_TRY2
@@ -582,7 +581,7 @@ namespace Generic
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
 
-      void Apache::Geode::Client::Generic::Serializable::RegisterWrapperGeneric(
+      void Apache::Geode::Client::Serializable::RegisterWrapperGeneric(
         WrapperDelegateGeneric^ wrapperMethod, Byte typeId, System::Type^ type)
       {
         if (typeId < 0 || typeId > WrapperEndGeneric)
@@ -594,7 +593,7 @@ namespace Generic
 				ManagedTypeMappingGeneric[type] = typeId;
       }
 
-      void Apache::Geode::Client::Generic::Serializable::UnregisterNativesGeneric()
+      void Apache::Geode::Client::Serializable::UnregisterNativesGeneric()
       {
         BuiltInDelegatesGeneric->Clear();
         for (Byte typeId = 0; typeId <= WrapperEndGeneric; ++typeId) {
@@ -684,8 +683,8 @@ namespace Generic
 					case apache::geode::client::GemfireTypeIds::CacheableDate:
           {
 						//TODO::
-            Apache::Geode::Client::Generic::CacheableDate^ ret = static_cast<Apache::Geode::Client::Generic::CacheableDate ^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableDate^>(val.ptr()));
+            Apache::Geode::Client::CacheableDate^ ret = static_cast<Apache::Geode::Client::CacheableDate ^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableDate^>(val.ptr()));
 
             System::DateTime dt(ret->Value.Ticks);
             return safe_cast<TValue>(dt);
@@ -714,50 +713,50 @@ namespace Generic
           }
         case apache::geode::client::GemfireTypeIds::CacheableBytes:
           {
-            Apache::Geode::Client::Generic::CacheableBytes^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableBytes ^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableBytes^>(val.ptr()));
+            Apache::Geode::Client::CacheableBytes^ ret = safe_cast<Apache::Geode::Client::CacheableBytes ^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableBytes^>(val.ptr()));
 
             return safe_cast<TValue>(ret->Value);            
           }
         case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
           {
-            Apache::Geode::Client::Generic::CacheableDoubleArray^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableDoubleArray ^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableDoubleArray^>(val.ptr()));
+            Apache::Geode::Client::CacheableDoubleArray^ ret = safe_cast<Apache::Geode::Client::CacheableDoubleArray ^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableDoubleArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
           {
-            Apache::Geode::Client::Generic::CacheableFloatArray^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableFloatArray^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableFloatArray^>(val.ptr()));
+            Apache::Geode::Client::CacheableFloatArray^ ret = safe_cast<Apache::Geode::Client::CacheableFloatArray^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableFloatArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
           {
-            Apache::Geode::Client::Generic::CacheableInt16Array^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableInt16Array^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableInt16Array^>(val.ptr()));
+            Apache::Geode::Client::CacheableInt16Array^ ret = safe_cast<Apache::Geode::Client::CacheableInt16Array^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt16Array^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
           {
-            Apache::Geode::Client::Generic::CacheableInt32Array^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableInt32Array^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableInt32Array^>(val.ptr()));
+            Apache::Geode::Client::CacheableInt32Array^ ret = safe_cast<Apache::Geode::Client::CacheableInt32Array^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt32Array^>(val.ptr()));
 
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
           {
-						Apache::Geode::Client::Generic::CacheableInt64Array^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableInt64Array^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableInt64Array^>(val.ptr()));
+						Apache::Geode::Client::CacheableInt64Array^ ret = safe_cast<Apache::Geode::Client::CacheableInt64Array^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt64Array^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableStringArray:
           {
-            Apache::Geode::Client::Generic::CacheableStringArray^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableStringArray^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableStringArray^>(val.ptr()));
+            Apache::Geode::Client::CacheableStringArray^ ret = safe_cast<Apache::Geode::Client::CacheableStringArray^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStringArray^>(val.ptr()));
                         
            /* array<String^>^ str = gcnew array<String^>(ret->GetValues()->Length);
             for(int i=0; i<ret->GetValues()->Length; i++ ) {
@@ -768,123 +767,123 @@ namespace Generic
           }
         case apache::geode::client::GemfireTypeIds::CacheableArrayList://Ilist generic
           {
-            Apache::Geode::Client::Generic::CacheableArrayList^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableArrayList^>
-             ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableArrayList^>(val.ptr()));
+            Apache::Geode::Client::CacheableArrayList^ ret = safe_cast<Apache::Geode::Client::CacheableArrayList^>
+             ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableArrayList^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableLinkedList://LinkedList generic
           {
-            Apache::Geode::Client::Generic::CacheableLinkedList^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableLinkedList^>
-             ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableLinkedList^>(val.ptr()));
+            Apache::Geode::Client::CacheableLinkedList^ ret = safe_cast<Apache::Geode::Client::CacheableLinkedList^>
+             ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableLinkedList^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }		  
         case apache::geode::client::GemfireTypeIds::CacheableHashTable://collection::hashtable
           {
-            Apache::Geode::Client::Generic::CacheableHashTable^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableHashTable^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableHashTable^>(val.ptr()));
+            Apache::Geode::Client::CacheableHashTable^ ret = safe_cast<Apache::Geode::Client::CacheableHashTable^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashTable^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
         case apache::geode::client::GemfireTypeIds::CacheableHashMap://generic dictionary
           {
-           Apache::Geode::Client::Generic::CacheableHashMap^ ret = safe_cast<Apache::Geode::Client::Generic::CacheableHashMap^>
-             ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableHashMap^>(val.ptr()));
+           Apache::Geode::Client::CacheableHashMap^ ret = safe_cast<Apache::Geode::Client::CacheableHashMap^>
+             ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashMap^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
 				case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
           {
-            Apache::Geode::Client::Generic::CacheableIdentityHashMap^ ret = static_cast<Apache::Geode::Client::Generic::CacheableIdentityHashMap^>
-							( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableIdentityHashMap^>(val.ptr()));            
+            Apache::Geode::Client::CacheableIdentityHashMap^ ret = static_cast<Apache::Geode::Client::CacheableIdentityHashMap^>
+							( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableIdentityHashMap^>(val.ptr()));            
             return safe_cast<TValue>(ret->Value);
           }
 				 case apache::geode::client::GemfireTypeIds::CacheableHashSet://no need of it, default case should work
         {
-          Apache::Geode::Client::Generic::CacheableHashSet^ ret = static_cast<Apache::Geode::Client::Generic::CacheableHashSet^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableHashSet^>(val.ptr()));
+          Apache::Geode::Client::CacheableHashSet^ ret = static_cast<Apache::Geode::Client::CacheableHashSet^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashSet^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
         case apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
-          Apache::Geode::Client::Generic::CacheableLinkedHashSet^ ret = static_cast<Apache::Geode::Client::Generic::CacheableLinkedHashSet^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableLinkedHashSet^>(val.ptr()));
+          Apache::Geode::Client::CacheableLinkedHashSet^ ret = static_cast<Apache::Geode::Client::CacheableLinkedHashSet^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableLinkedHashSet^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
 				case apache::geode::client::GemfireTypeIds::CacheableFileName:
         {
-          Apache::Geode::Client::Generic::CacheableFileName^ ret = static_cast<Apache::Geode::Client::Generic::CacheableFileName^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableFileName^>(val.ptr()));
+          Apache::Geode::Client::CacheableFileName^ ret = static_cast<Apache::Geode::Client::CacheableFileName^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableFileName^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
 				 case apache::geode::client::GemfireTypeIds::CacheableObjectArray:
         {
-          Apache::Geode::Client::Generic::CacheableObjectArray^ ret = static_cast<Apache::Geode::Client::Generic::CacheableObjectArray^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableObjectArray^>(val.ptr()));
+          Apache::Geode::Client::CacheableObjectArray^ ret = static_cast<Apache::Geode::Client::CacheableObjectArray^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObjectArray^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
 				case apache::geode::client::GemfireTypeIds::CacheableVector://collection::arraylist
         {
-          Apache::Geode::Client::Generic::CacheableVector^ ret = static_cast<Apache::Geode::Client::Generic::CacheableVector^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableVector^>(val.ptr()));
+          Apache::Geode::Client::CacheableVector^ ret = static_cast<Apache::Geode::Client::CacheableVector^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableVector^>(val.ptr()));
           return safe_cast<TValue>(ret->Value);
         }
 				case apache::geode::client::GemfireTypeIds::CacheableUndefined:
         {
-          Apache::Geode::Client::Generic::CacheableUndefined^ ret = static_cast<Apache::Geode::Client::Generic::CacheableUndefined^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableUndefined^>(val.ptr()));
+          Apache::Geode::Client::CacheableUndefined^ ret = static_cast<Apache::Geode::Client::CacheableUndefined^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableUndefined^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
         case apache::geode::client::GemfireTypeIds::Struct:
         {
-          return safe_cast<TValue>(Apache::Geode::Client::Generic::Struct::Create(val.ptr()));
+          return safe_cast<TValue>(Apache::Geode::Client::Struct::Create(val.ptr()));
         }
 				case apache::geode::client::GemfireTypeIds::CacheableStack:
         {
-          Apache::Geode::Client::Generic::CacheableStack^ ret = static_cast<Apache::Geode::Client::Generic::CacheableStack^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableStack^>(val.ptr()));
+          Apache::Geode::Client::CacheableStack^ ret = static_cast<Apache::Geode::Client::CacheableStack^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStack^>(val.ptr()));
           return safe_cast<TValue>(ret->Value);
         }
         case 7: //GemFireClassIds::CacheableManagedObject
         {
-          Apache::Geode::Client::Generic::CacheableObject^ ret = static_cast<Apache::Geode::Client::Generic::CacheableObject^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableObject^>(val.ptr()));
+          Apache::Geode::Client::CacheableObject^ ret = static_cast<Apache::Geode::Client::CacheableObject^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObject^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
         case 8://GemFireClassIds::CacheableManagedObjectXml
         {
-          Apache::Geode::Client::Generic::CacheableObjectXml^ ret = static_cast<Apache::Geode::Client::Generic::CacheableObjectXml^>
-						( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CacheableObjectXml^>(val.ptr()));
+          Apache::Geode::Client::CacheableObjectXml^ ret = static_cast<Apache::Geode::Client::CacheableObjectXml^>
+						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObjectXml^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
           /*  TODO: replace with IDictionary<K, V>
         case apache::geode::client::GemfireTypeIds::Properties:
           {
-            Apache::Geode::Client::Generic::Properties^ ret = safe_cast<Apache::Geode::Client::Generic::Properties^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::Properties^>(val.ptr()));
+            Apache::Geode::Client::Properties^ ret = safe_cast<Apache::Geode::Client::Properties^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Properties^>(val.ptr()));
             
             return safe_cast<TValue>(ret);
           }*/
        
         case apache::geode::client::GemfireTypeIds::BooleanArray:
           {
-						Apache::Geode::Client::Generic::BooleanArray^ ret = safe_cast<Apache::Geode::Client::Generic::BooleanArray^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::BooleanArray^>(val.ptr()));
+						Apache::Geode::Client::BooleanArray^ ret = safe_cast<Apache::Geode::Client::BooleanArray^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::BooleanArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
 					}
         case apache::geode::client::GemfireTypeIds::CharArray:
           {
-						Apache::Geode::Client::Generic::CharArray^ ret = safe_cast<Apache::Geode::Client::Generic::CharArray^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::CharArray^>(val.ptr()));
+						Apache::Geode::Client::CharArray^ ret = safe_cast<Apache::Geode::Client::CharArray^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CharArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
 					}
         case 0://UserFunctionExecutionException unregistered
           {            
-						Apache::Geode::Client::Generic::UserFunctionExecutionException^ ret = static_cast<Apache::Geode::Client::Generic::UserFunctionExecutionException^>
-              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Generic::UserFunctionExecutionException^>(val.ptr()));            
+						Apache::Geode::Client::UserFunctionExecutionException^ ret = static_cast<Apache::Geode::Client::UserFunctionExecutionException^>
+              ( SafeGenericUMSerializableConvert<Apache::Geode::Client::UserFunctionExecutionException^>(val.ptr()));            
             return safe_cast<TValue>(ret);
 					}
         default:
@@ -1042,7 +1041,7 @@ namespace Generic
       apache::geode::client::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
         Type^ managedType, TKey key, bool isAsciiChar)
       {
-        Byte typeId = Apache::Geode::Client::Generic::Serializable::GetManagedTypeMappingGeneric(managedType);        
+        Byte typeId = Apache::Geode::Client::Serializable::GetManagedTypeMappingGeneric(managedType);        
 
         switch(typeId)
         {
@@ -1106,84 +1105,84 @@ namespace Generic
          }
         case apache::geode::client::GemfireTypeIds::CacheableBytes:
           {
-						apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableBytes::Create((array<Byte>^)key)));
+						apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key)));
               return kPtr;
             /*if( managedType == Type::GetType("System.Byte[]") ) {
-              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableBytes::Create((array<Byte>^)key)));
+              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key)));
               return kPtr;
             }
             else {
-              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableBytes::Create(getSByteArray((array<SByte>^)key))));
+              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableBytes::Create(getSByteArray((array<SByte>^)key))));
               return kPtr;
             }*/
           }
         case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
           {
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableDoubleArray::Create((array<Double>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableDoubleArray::Create((array<Double>^)key)));
             return kPtr;
           }
         case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableFloatArray::Create((array<float>^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableFloatArray::Create((array<float>^)key)));
            return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
         {
-					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt16Array::Create((array<Int16>^)key)));
+					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key)));
             return kPtr;
          /* if( managedType == Type::GetType("System.Int16[]") ) {
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt16Array::Create((array<Int16>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key)));
             return kPtr;
           }
           else { 
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt16Array::Create(getInt16Array((array<uint16_t>^)key))));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt16Array::Create(getInt16Array((array<uint16_t>^)key))));
             return kPtr;
           }  */          
         }
         case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
         {
-					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt32Array::Create((array<Int32>^)key)));
+					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key)));
             return kPtr;
         /*  if( managedType == Type::GetType("System.Int32[]") ) {
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt32Array::Create((array<Int32>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key)));
             return kPtr;
           }
           else { 
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt32Array::Create(getInt32Array((array<uint32_t>^)key))));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt32Array::Create(getInt32Array((array<uint32_t>^)key))));
             return kPtr;
           }       */   
         }
         case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
         {
-					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt64Array::Create((array<Int64>^)key)));
+					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key)));
             return kPtr;
           /*if( managedType == Type::GetType("System.Int64[]") ) {
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt64Array::Create((array<Int64>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key)));
             return kPtr;
           }
           else { 
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableInt64Array::Create(getInt64Array((array<uint64_t>^)key))));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt64Array::Create(getInt64Array((array<uint64_t>^)key))));
             return kPtr;
           }     */                  
         }
         case apache::geode::client::GemfireTypeIds::CacheableStringArray:
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableStringArray::Create((array<String^>^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableStringArray::Create((array<String^>^)key)));
            return kPtr;
         }
 				case apache::geode::client::GemfireTypeIds::CacheableFileName:
         {
-					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)(Apache::Geode::Client::Generic::CacheableFileName^)key));
+					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)(Apache::Geode::Client::CacheableFileName^)key));
           return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableHashTable://collection::hashtable
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableHashTable::Create((System::Collections::Hashtable^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableHashTable::Create((System::Collections::Hashtable^)key)));
           return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableHashMap://generic dictionary
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableHashMap::Create((System::Collections::IDictionary^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableHashMap::Create((System::Collections::IDictionary^)key)));
           return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableVector://collection::arraylist
@@ -1193,62 +1192,62 @@ namespace Generic
         }
         case apache::geode::client::GemfireTypeIds::CacheableArrayList://generic ilist
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableArrayList::Create((System::Collections::IList^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableArrayList::Create((System::Collections::IList^)key)));
           return kPtr;
         } 
         case apache::geode::client::GemfireTypeIds::CacheableLinkedList://generic linked list
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)));
           return kPtr;
         }		
 		case apache::geode::client::GemfireTypeIds::CacheableStack:
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::Generic::CacheableStack::Create((System::Collections::ICollection^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableStack::Create((System::Collections::ICollection^)key)));
           return kPtr;
         }
         case 7: //GemFireClassIds::CacheableManagedObject
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::Generic::CacheableObject^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObject^)key));
           return kPtr;
         }
         case 8://GemFireClassIds::CacheableManagedObjectXml
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::Generic::CacheableObjectXml^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectXml^)key));
           return kPtr;
         }
 				 case apache::geode::client::GemfireTypeIds::CacheableObjectArray:
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::Generic::CacheableObjectArray^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectArray^)key));
           return kPtr;
         }
 			  case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::Generic::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)));
           return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableHashSet://no need of it, default case should work
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::Generic::CacheableHashSet^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableHashSet^)key));
           return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
-          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::Generic::CacheableLinkedHashSet^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableLinkedHashSet^)key));
           return kPtr;
         }
         case apache::geode::client::GemfireTypeIds::CacheableDate:
           {
-            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CacheableDate::Create((System::DateTime)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableDate::Create((System::DateTime)key)));
             return kPtr;
           }
         case apache::geode::client::GemfireTypeIds::BooleanArray:
           {   
-					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::BooleanArray::Create((array<bool>^)key)));
+					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::BooleanArray::Create((array<bool>^)key)));
             return kPtr;
 					}
         case apache::geode::client::GemfireTypeIds::CharArray:
           {
-					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::Generic::CharArray::Create((array<Char>^)key)));
+					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CharArray::Create((array<Char>^)key)));
             return kPtr;
 					}
         default:
@@ -1522,9 +1521,8 @@ namespace Generic
             dArray[index] = sArray[index];
           }          
           return dArray;
-        }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-      } // end namespace Generic
-    }
-  }
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Serializable.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.hpp b/src/clicache/src/Serializable.hpp
index 503dba5..5eaec44 100644
--- a/src/clicache/src/Serializable.hpp
+++ b/src/clicache/src/Serializable.hpp
@@ -38,8 +38,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
 				interface class IPdxSerializable;
         interface class IPdxSerializer;
       /// <summary>
@@ -61,7 +60,7 @@ namespace Generic
       /// <c>DelegateWrapper.NativeDelegate</c> method by a call to
       /// <see cref="IGFSerializable.FromData" />.
       /// </summary>
-      public delegate Apache::Geode::Client::Generic::IGFSerializable^ TypeFactoryMethodGeneric();
+      public delegate Apache::Geode::Client::IGFSerializable^ TypeFactoryMethodGeneric();
       /// <summary>
       /// Delegate to wrap a native <c>apache::geode::client::Serializable</c> type.
       /// </summary>
@@ -69,7 +68,7 @@ namespace Generic
       /// This delegate should return an object of type <c>IGFSerializable</c>
       /// given a native object.
       /// </remarks>
-      delegate Apache::Geode::Client::Generic::IGFSerializable^ WrapperDelegateGeneric(apache::geode::client::Serializable* obj);
+      delegate Apache::Geode::Client::IGFSerializable^ WrapperDelegateGeneric(apache::geode::client::Serializable* obj);
 
 			/// <summary>
       /// Signature of function delegates passed to
@@ -78,15 +77,15 @@ namespace Generic
       /// New instance will be created during de-serialization of Pdx Types
       /// <see cref="IPdxSerializable" />.
       /// </summary>
-      public delegate Apache::Geode::Client::Generic::IPdxSerializable^ PdxTypeFactoryMethod();
+      public delegate Apache::Geode::Client::IPdxSerializable^ PdxTypeFactoryMethod();
       
       /// <summary>
       /// This class wraps the native C++ <c>apache::geode::client::Serializable</c> objects
       /// as managed <see cref="IGFSerializable" /> objects.
       /// </summary>
       public ref class Serializable
-        : public Apache::Geode::Client::Generic::Internal::SBWrap<apache::geode::client::Serializable>,
-        public Apache::Geode::Client::Generic::IGFSerializable
+        : public Apache::Geode::Client::Internal::SBWrap<apache::geode::client::Serializable>,
+        public Apache::Geode::Client::IGFSerializable
       {
       public:
         /// <summary>
@@ -95,7 +94,7 @@ namespace Generic
         /// <param name="output">
         /// the DataOutput object to use for serializing the object
         /// </param>
-        virtual void ToData(Apache::Geode::Client::Generic::DataOutput^ output);
+        virtual void ToData(Apache::Geode::Client::DataOutput^ output);
 
         /// <summary>
         /// Deserializes the native (C++) object -- returns an instance of the
@@ -105,8 +104,8 @@ namespace Generic
         /// the DataInput stream to use for reading the object data
         /// </param>
         /// <returns>the deserialized object</returns>
-        virtual Apache::Geode::Client::Generic::IGFSerializable^
-          FromData(Apache::Geode::Client::Generic::DataInput^ input);
+        virtual Apache::Geode::Client::IGFSerializable^
+          FromData(Apache::Geode::Client::DataInput^ input);
         
         /// <summary>
         /// return the size of this object in bytes
@@ -141,85 +140,85 @@ namespace Generic
         /// Implicit conversion operator from a boolean
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (bool value);
+        static operator Apache::Geode::Client::Serializable^ (bool value);
 
         /// <summary>
         /// Implicit conversion operator from a byte
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (Byte value);
+        static operator Apache::Geode::Client::Serializable^ (Byte value);
 
         /// <summary>
         /// Implicit conversion operator from an array of bytes
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<Byte>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<Byte>^ value);
 
         /// <summary>
         /// Implicit conversion operator from an boolean array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<bool>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<bool>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a double
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (Double value);
+        static operator Apache::Geode::Client::Serializable^ (Double value);
 
         /// <summary>
         /// Implicit conversion operator from a double array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<Double>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<Double>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a float
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (Single value);
+        static operator Apache::Geode::Client::Serializable^ (Single value);
 
         /// <summary>
         /// Implicit conversion operator from a float array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<Single>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<Single>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a 16-bit integer
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (int16_t value);
+        static operator Apache::Geode::Client::Serializable^ (int16_t value);
 
         /// <summary>
         /// Implicit conversion operator from a character
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (Char value);
+        static operator Apache::Geode::Client::Serializable^ (Char value);
 
         /// <summary>
         /// Implicit conversion operator from a character array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<Char>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<Char>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a 16-bit integer array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<int16_t>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<int16_t>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a 32-bit integer
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (int32_t value);
+        static operator Apache::Geode::Client::Serializable^ (int32_t value);
 
         /// <summary>
         /// Implicit conversion operator from a 32-bit integer array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<int32_t>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<int32_t>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a 64-bit integer
@@ -231,19 +230,19 @@ namespace Generic
         /// Implicit conversion operator from a 64-bit integer array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<int64_t>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<int64_t>^ value);
 
         /// <summary>
         /// Implicit conversion operator from a string
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (String^ value);
+        static operator Apache::Geode::Client::Serializable^ (String^ value);
 
         /// <summary>
         /// Implicit conversion operator from a string array
         /// to a <c>Serializable</c>.
         /// </summary>
-        static operator Apache::Geode::Client::Generic::Serializable^ (array<String^>^ value);
+        static operator Apache::Geode::Client::Serializable^ (array<String^>^ value);
 
         /// <summary>
         /// Register an instance factory method for a given type.
@@ -415,15 +414,15 @@ namespace Generic
         /// <summary>
         /// Default constructor.
         /// </summary>
-        inline Apache::Geode::Client::Generic::Serializable()
-          : Apache::Geode::Client::Generic::Internal::SBWrap<apache::geode::client::Serializable>() { }
+        inline Apache::Geode::Client::Serializable()
+          : Apache::Geode::Client::Internal::SBWrap<apache::geode::client::Serializable>() { }
 
         /// <summary>
         /// Internal constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Apache::Geode::Client::Generic::Serializable(apache::geode::client::Serializable* nativeptr)
-          : Generic::Internal::SBWrap<apache::geode::client::Serializable>(nativeptr) { }
+        inline Apache::Geode::Client::Serializable(apache::geode::client::Serializable* nativeptr)
+          : Client::Internal::SBWrap<apache::geode::client::Serializable>(nativeptr) { }
 
         /// <summary>
         /// Register an instance factory method for a given type and typeId.
@@ -574,8 +573,8 @@ namespace Generic
         
         static array<Type^>^ singleIntTypeA = gcnew array<Type^>{ Int32::typeid };
 
-        static Type^ createNewObjectDelegateType = Type::GetType("Apache.Geode.Client.Generic.Serializable+CreateNewObjectDelegate");
-        static Type^ createNewObjectArrayDelegateType = Type::GetType("Apache.Geode.Client.Generic.Serializable+CreateNewObjectArrayDelegate");
+        static Type^ createNewObjectDelegateType = Type::GetType("Apache.Geode.Client.Serializable+CreateNewObjectDelegate");
+        static Type^ createNewObjectArrayDelegateType = Type::GetType("Apache.Geode.Client.Serializable+CreateNewObjectArrayDelegate");
 
         static array<Type^>^ singleIntType = gcnew array<Type^>(1){Int32::typeid};
 
@@ -702,7 +701,7 @@ namespace Generic
           }
         }
       };
-      } // end namespace Generic
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StatisticDescriptor.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StatisticDescriptor.cpp b/src/clicache/src/StatisticDescriptor.cpp
index bd8da29..e809117 100644
--- a/src/clicache/src/StatisticDescriptor.cpp
+++ b/src/clicache/src/StatisticDescriptor.cpp
@@ -28,8 +28,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
 
       int32_t StatisticDescriptor::ID::get( )
       {
@@ -59,8 +57,8 @@ namespace Generic
       String^ StatisticDescriptor::Unit::get( )
       {
         return ManagedString::Get( NativePtr->getUnit() );
-      }
-    }
-  }
-} } //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+ } //namespace 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StatisticDescriptor.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StatisticDescriptor.hpp b/src/clicache/src/StatisticDescriptor.hpp
index 4603d24..0949f76 100644
--- a/src/clicache/src/StatisticDescriptor.hpp
+++ b/src/clicache/src/StatisticDescriptor.hpp
@@ -29,8 +29,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       /// <summary>
       /// A class that describes an individual statistic whose value is updated by an
       /// application and may be archived by GemFire. These descriptions are gathered
@@ -123,7 +122,8 @@ namespace Generic
            inline StatisticDescriptor( apache::geode::statistics::StatisticDescriptor* nativeptr )
            : UMWrap( nativeptr, false ) { }
        };      
-    }
-  }
-} } //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Statistics.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Statistics.cpp b/src/clicache/src/Statistics.cpp
index ed4ce34..62289e8 100644
--- a/src/clicache/src/Statistics.cpp
+++ b/src/clicache/src/Statistics.cpp
@@ -33,8 +33,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       void Statistics::Close()
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
@@ -292,8 +291,8 @@ namespace Generic
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           return NativePtr->incDouble((char*)mg_name.CharPtr,delta);
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
-      }
-    }
-  }
-} } //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+ } //namespace 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Statistics.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Statistics.hpp b/src/clicache/src/Statistics.hpp
index 17726df..f855042 100644
--- a/src/clicache/src/Statistics.hpp
+++ b/src/clicache/src/Statistics.hpp
@@ -31,8 +31,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       ref class StatisticDescriptor;
       ref class StatisticsType;
 
@@ -534,12 +533,8 @@ namespace Generic
           : UMWrapN( nativeptr, false ) { }
 
       };
-    }
-  }
-}
-
-
-
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
- } //namespace 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StatisticsFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StatisticsFactory.cpp b/src/clicache/src/StatisticsFactory.cpp
index 47ddff6..ac04c7c 100644
--- a/src/clicache/src/StatisticsFactory.cpp
+++ b/src/clicache/src/StatisticsFactory.cpp
@@ -34,8 +34,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       StatisticsFactory^ StatisticsFactory::GetExistingInstance()
       {
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
@@ -249,10 +248,10 @@ namespace Generic
       int64_t StatisticsFactory::ID::get( )
       {
         return  NativePtr->getId();
-      }
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 
  } //namespace 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StatisticsFactory.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StatisticsFactory.hpp b/src/clicache/src/StatisticsFactory.hpp
index 29ad272..e2a01dd 100644
--- a/src/clicache/src/StatisticsFactory.hpp
+++ b/src/clicache/src/StatisticsFactory.hpp
@@ -32,8 +32,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       ref class StatisticDescriptor;
       ref class StatisticsType;
       ref class Statistics; 
@@ -261,7 +260,8 @@ namespace Generic
            inline StatisticsFactory( apache::geode::statistics::StatisticsFactory* nativeptr )
            : UMWrap( nativeptr, false ) { }
       };
-    }
-  }
-} } //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StatisticsType.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StatisticsType.cpp b/src/clicache/src/StatisticsType.cpp
index 76928cc..34cda8d 100644
--- a/src/clicache/src/StatisticsType.cpp
+++ b/src/clicache/src/StatisticsType.cpp
@@ -32,8 +32,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       String^ StatisticsType::Name::get()
       {
         return ManagedString::Get( NativePtr->getName() );
@@ -78,9 +77,9 @@ namespace Generic
       int32_t StatisticsType::DescriptorsCount::get()
       {
         return NativePtr->getDescriptorsCount();
-      }
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
  } //namespace 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StatisticsType.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StatisticsType.hpp b/src/clicache/src/StatisticsType.hpp
index aed23e0..d3e6e37 100644
--- a/src/clicache/src/StatisticsType.hpp
+++ b/src/clicache/src/StatisticsType.hpp
@@ -30,8 +30,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       ref class StatisticDescriptor;
 
       /// <summary>
@@ -133,10 +132,8 @@ namespace Generic
           : UMWrap( nativeptr, false ) { }
 
       };
-    }
-  }
-}
-
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
- } //namespace 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Struct.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Struct.cpp b/src/clicache/src/Struct.cpp
index 782521a..a9cea00 100644
--- a/src/clicache/src/Struct.cpp
+++ b/src/clicache/src/Struct.cpp
@@ -30,8 +30,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       Object^ Struct::default::get( size_t index )
       {
        /*   return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
@@ -73,9 +72,8 @@ namespace Generic
           NativePtr())->next().ptr());*/
         return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<apache::geode::client::Struct*>(
           NativePtr())->next()));
-      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-    }
-  }
-}
  } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Struct.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Struct.hpp b/src/clicache/src/Struct.hpp
index e86430c..14df082 100644
--- a/src/clicache/src/Struct.hpp
+++ b/src/clicache/src/Struct.hpp
@@ -30,8 +30,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       generic<class TResult>
       ref class StructSet;
 
@@ -45,7 +44,7 @@ namespace Generic
       /// </remarks>
       //generic<class TResult>
       public ref class Struct sealed
-        : public Apache::Geode::Client::Generic::Serializable
+        : public Apache::Geode::Client::Serializable
       {
       public:
 
@@ -55,9 +54,9 @@ namespace Generic
         /// <returns>
         /// The value of the field or null if index is out of bounds.
         /// </returns>
-        property /*Apache::Geode::Client::Generic::IGFSerializable^*//*TResult*/ Object^ GFINDEXER( size_t )
+        property /*Apache::Geode::Client::IGFSerializable^*//*TResult*/ Object^ GFINDEXER( size_t )
         {
-          /*Apache::Geode::Client::Generic::IGFSerializable^*/ /*TResult*/ Object^ get( size_t index );
+          /*Apache::Geode::Client::IGFSerializable^*/ /*TResult*/ Object^ get( size_t index );
         }
 
         /// <summary>
@@ -67,9 +66,9 @@ namespace Generic
         /// <exception cref="IllegalArgumentException">
         /// if the field name is not found.
         /// </exception>
-        property /*Apache::Geode::Client::Generic::IGFSerializable^*//*TResult*/Object^ GFINDEXER( String^ )
+        property /*Apache::Geode::Client::IGFSerializable^*//*TResult*/Object^ GFINDEXER( String^ )
         {
-          /*Apache::Geode::Client::Generic::IGFSerializable^*//*TResult*/Object^ get( String^ fieldName );
+          /*Apache::Geode::Client::IGFSerializable^*//*TResult*/Object^ get( String^ fieldName );
         }
 
         /// <summary>
@@ -78,9 +77,9 @@ namespace Generic
         /// <returns>
         /// A reference to the parent <c>StructSet</c> of this <c>Struct</c>.
         /// </returns>
-        property Apache::Geode::Client::Generic::StructSet</*TResult*/Object^>^ Set
+        property Apache::Geode::Client::StructSet</*TResult*/Object^>^ Set
         {
-          Apache::Geode::Client::Generic::StructSet</*TResult*/Object^>^ get( );
+          Apache::Geode::Client::StructSet</*TResult*/Object^>^ get( );
         }
 
         /// <summary>
@@ -106,7 +105,7 @@ namespace Generic
         /// A reference to the next item in the <c>Struct</c>
         /// or null if no more available.
         /// </returns>
-        /*Apache::Geode::Client::Generic::IGFSerializable^*//*TResult*/Object^ Next( );
+        /*Apache::Geode::Client::IGFSerializable^*//*TResult*/Object^ Next( );
 
 
       private:
@@ -115,32 +114,32 @@ namespace Generic
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline Apache::Geode::Client::Generic::Struct/*<TResult>*/( ::apache::geode::client::Serializable* nativeptr )
-          : Apache::Geode::Client::Generic::Serializable( nativeptr ) { }
+        inline Apache::Geode::Client::Struct/*<TResult>*/( ::apache::geode::client::Serializable* nativeptr )
+          : Apache::Geode::Client::Serializable( nativeptr ) { }
 
-        inline Apache::Geode::Client::Generic::Struct/*<TResult>*/(  )
-          : Apache::Geode::Client::Generic::Serializable( ::apache::geode::client::Struct::createDeserializable()) { }
+        inline Apache::Geode::Client::Struct/*<TResult>*/(  )
+          : Apache::Geode::Client::Serializable( ::apache::geode::client::Struct::createDeserializable()) { }
 
       internal:
 
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        inline static Apache::Geode::Client::Generic::IGFSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::apache::geode::client::Serializable* obj )
+        inline static Apache::Geode::Client::IGFSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::apache::geode::client::Serializable* obj )
         {
           return ( obj != nullptr ?
-            gcnew Apache::Geode::Client::Generic::Struct/*<TResult>*/( obj ) : nullptr );
+            gcnew Apache::Geode::Client::Struct/*<TResult>*/( obj ) : nullptr );
           /*return ( obj != nullptr ?
             gcnew Struct( obj ) : nullptr );*/
         }
 
-        inline static Apache::Geode::Client::Generic::IGFSerializable^ CreateDeserializable( )
+        inline static Apache::Geode::Client::IGFSerializable^ CreateDeserializable( )
         {
-          return gcnew Apache::Geode::Client::Generic::Struct/*<TResult>*/(  ) ;
+          return gcnew Apache::Geode::Client::Struct/*<TResult>*/(  ) ;
           //return gcnew Struct(  ) ;
         }
       };
-    }
-  }
-}
-} //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+ //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StructSet.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StructSet.cpp b/src/clicache/src/StructSet.cpp
index a7b5e67..9fa2f1d 100644
--- a/src/clicache/src/StructSet.cpp
+++ b/src/clicache/src/StructSet.cpp
@@ -29,8 +29,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
 
       generic<class TResult>
       bool StructSet<TResult>::IsModifiable::get( )
@@ -45,7 +43,7 @@ namespace Generic
       }
 
       generic<class TResult>
-      /*Apache::Geode::Client::Generic::IGFSerializable^*/ TResult StructSet<TResult>::default::get( size_t index )
+      /*Apache::Geode::Client::IGFSerializable^*/ TResult StructSet<TResult>::default::get( size_t index )
       {
         //return SafeUMSerializableConvertGeneric((NativePtr->operator[](static_cast<int32_t>(index))).ptr());
         return Serializable::GetManagedValueGeneric<TResult>((NativePtr->operator[](static_cast<int32_t>(index))));
@@ -60,7 +58,7 @@ namespace Generic
       }
 
       generic<class TResult>
-      System::Collections::Generic::IEnumerator</*Apache::Geode::Client::Generic::IGFSerializable^*/TResult>^
+      System::Collections::Generic::IEnumerator</*Apache::Geode::Client::IGFSerializable^*/TResult>^
         StructSet<TResult>::GetEnumerator( )
       {
         return GetIterator( );
@@ -88,9 +86,8 @@ namespace Generic
       String^ StructSet<TResult>::GetFieldName( size_t index )
       {
         return ManagedString::Get( NativePtr->getFieldName( static_cast<int32_t> (index) ) );
-      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-    }
-  }
-}
  } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/StructSet.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StructSet.hpp b/src/clicache/src/StructSet.hpp
index 18bb30f..9200bb7 100644
--- a/src/clicache/src/StructSet.hpp
+++ b/src/clicache/src/StructSet.hpp
@@ -31,8 +31,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       interface class IGFSerializable;
 
       generic<class TResult>
@@ -74,9 +73,9 @@ namespace Generic
         /// if the index is out of bounds.
         /// </exception>
         /// <returns>Item at the given index.</returns>
-        virtual property /*Apache::Geode::Client::Generic::IGFSerializable^*/TResult GFINDEXER( size_t )
+        virtual property /*Apache::Geode::Client::IGFSerializable^*/TResult GFINDEXER( size_t )
         {
-          virtual /*Apache::Geode::Client::Generic::IGFSerializable^*/TResult get( size_t index );
+          virtual /*Apache::Geode::Client::IGFSerializable^*/TResult get( size_t index );
         }
 
         /// <summary>
@@ -123,7 +122,7 @@ namespace Generic
         /// A <c>System.Collections.Generic.IEnumerator</c> that
         /// can be used to iterate through the <c>StructSet</c>.
         /// </returns>
-        virtual System::Collections::Generic::IEnumerator</*Apache::Geode::Client::Generic::IGFSerializable^*/TResult>^
+        virtual System::Collections::Generic::IEnumerator</*Apache::Geode::Client::IGFSerializable^*/TResult>^
           GetEnumerator( );
 
         // End Region: IEnumerable<IGFSerializable^> Members
@@ -157,8 +156,7 @@ namespace Generic
         inline StructSet(apache::geode::client::StructSet* nativeptr)
           : SBWrap(nativeptr) { }
       };
-
-    }
-  }
-}
-} //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+ //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/SystemProperties.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SystemProperties.cpp b/src/clicache/src/SystemProperties.cpp
index dc9cd00..cecc773 100644
--- a/src/clicache/src/SystemProperties.cpp
+++ b/src/clicache/src/SystemProperties.cpp
@@ -27,8 +27,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       SystemProperties::SystemProperties( Properties<String^, String^>^ properties )
       {
         _GF_MG_EXCEPTION_TRY2
@@ -238,9 +237,8 @@ namespace Generic
        bool SystemProperties::OnClientDisconnectClearPdxTypeIds::get( )
       {
         return NativePtr->onClientDisconnectClearPdxTypeIds( );
-      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-      } // end namespace Generic
-    }
-  }
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/SystemProperties.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SystemProperties.hpp b/src/clicache/src/SystemProperties.hpp
index 9b61e0c..6273a42 100644
--- a/src/clicache/src/SystemProperties.hpp
+++ b/src/clicache/src/SystemProperties.hpp
@@ -31,8 +31,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       /// <summary>
       /// A class for internal use, that encapsulates the properties that can be
       /// set through <see cref="DistributedSystem.Connect" />
@@ -440,7 +439,7 @@ namespace Generic
         inline SystemProperties( apache::geode::client::SystemProperties* nativeptr )
           : UMWrap( nativeptr, false ) { }
       };
-      } // end namespace Generic
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/TransactionEvent.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionEvent.cpp b/src/clicache/src/TransactionEvent.cpp
index 0787fc4..e95dcca 100644
--- a/src/clicache/src/TransactionEvent.cpp
+++ b/src/clicache/src/TransactionEvent.cpp
@@ -26,7 +26,7 @@
 
 
 using namespace System;
-using namespace Apache::Geode::Client::Generic;
+using namespace Apache::Geode::Client;
 
 
 namespace Apache
@@ -35,25 +35,24 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       generic<class TKey, class TValue>
       Cache^ TransactionEvent<TKey, TValue>::Cache::get( )
       {
         apache::geode::client::CachePtr & nativeptr(
           NativePtr->getCache( ) );
 
-				return Apache::Geode::Client::Generic::Cache::Create(
+				return Apache::Geode::Client::Cache::Create(
           nativeptr.ptr( ) );
       }
       
       generic<class TKey, class TValue>
-			Apache::Geode::Client::Generic::TransactionId^ TransactionEvent<TKey, TValue>::TransactionId::get( )
+			Apache::Geode::Client::TransactionId^ TransactionEvent<TKey, TValue>::TransactionId::get( )
       {
         apache::geode::client::TransactionIdPtr & nativeptr(
           NativePtr->getTransactionId( ) );
 
-				return Apache::Geode::Client::Generic::TransactionId::Create(
+				return Apache::Geode::Client::TransactionId::Create(
           nativeptr.ptr( ) );
       }
     
@@ -72,10 +71,9 @@ namespace Generic
           events[ index ] = (%entryEvent);
         }
         return events;
-      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-    }
-  }
-}
  } //namespace 
 #endif
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/TransactionEvent.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionEvent.hpp b/src/clicache/src/TransactionEvent.hpp
index 4e38554..68630b9 100644
--- a/src/clicache/src/TransactionEvent.hpp
+++ b/src/clicache/src/TransactionEvent.hpp
@@ -32,8 +32,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
 				ref class TransactionId;
 				ref class Cache;
 
@@ -51,9 +50,9 @@ namespace Generic
             /// <summary>
             /// Gets the transaction id for this transaction.
             /// </summary>
-						property Apache::Geode::Client::Generic::TransactionId^ TransactionId
+						property Apache::Geode::Client::TransactionId^ TransactionId
             {
-							Apache::Geode::Client::Generic::TransactionId^ get( );
+							Apache::Geode::Client::TransactionId^ get( );
             }
 
          		/// <summary>
@@ -69,9 +68,9 @@ namespace Generic
             /// <summary>
             /// Gets the Cache for this transaction event
             /// </summary>
-						property Apache::Geode::Client::Generic::Cache^ Cache
+						property Apache::Geode::Client::Cache^ Cache
             {
-              Apache::Geode::Client::Generic::Cache^ get( );
+              Apache::Geode::Client::Cache^ get( );
             }
 
           internal:
@@ -82,9 +81,8 @@ namespace Generic
             inline TransactionEvent( apache::geode::client::TransactionEvent* nativeptr )
               : UMWrap( nativeptr, false ) { }
           };
-
-      }
-    }
-  }
-} //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+ //namespace 
 #endif
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/TransactionId.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionId.hpp b/src/clicache/src/TransactionId.hpp
index 4375f1b..35e6637 100644
--- a/src/clicache/src/TransactionId.hpp
+++ b/src/clicache/src/TransactionId.hpp
@@ -29,8 +29,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
         /// <summary>
         /// This class encapsulates Id of a transaction.
         /// </summary>
@@ -54,8 +53,7 @@ namespace Generic
           inline TransactionId( apache::geode::client::TransactionId* nativeptr )
             : SBWrap( nativeptr ) { }
         };
-      }
-
-    }
-  }
-} //namespace 
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+ //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/TransactionListenerAdapter.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionListenerAdapter.hpp b/src/clicache/src/TransactionListenerAdapter.hpp
index f098a4b..613263a 100644
--- a/src/clicache/src/TransactionListenerAdapter.hpp
+++ b/src/clicache/src/TransactionListenerAdapter.hpp
@@ -27,8 +27,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
 
       /// <summary>
       /// Utility class that implements all methods in <c>ITransactionListener</c>
@@ -37,18 +35,18 @@ namespace Generic
       /// </summary>
       generic<class TKey, class TValue>
       public ref class TransactionListenerAdapter
-        : public Apache::Geode::Client::Generic::ITransactionListener<TKey, TValue>
+        : public Apache::Geode::Client::ITransactionListener<TKey, TValue>
       {
       public:
-        virtual void AfterCommit(Apache::Geode::Client::Generic::TransactionEvent<TKey, TValue>^ te)
+        virtual void AfterCommit(Apache::Geode::Client::TransactionEvent<TKey, TValue>^ te)
         {
         }
 
-	      virtual void AfterFailedCommit(Apache::Geode::Client::Generic::TransactionEvent<TKey, TValue>^ te)
+	      virtual void AfterFailedCommit(Apache::Geode::Client::TransactionEvent<TKey, TValue>^ te)
         {
         }
 
-	      virtual void AfterRollback(Apache::Geode::Client::Generic::TransactionEvent<TKey, TValue>^ te)
+	      virtual void AfterRollback(Apache::Geode::Client::TransactionEvent<TKey, TValue>^ te)
         {
         }
     
@@ -56,9 +54,8 @@ namespace Generic
         {
         }
       };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-    }
-  }
-}
- } //namespace 
 #endif
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/TransactionWriterAdapte.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionWriterAdapte.hpp b/src/clicache/src/TransactionWriterAdapte.hpp
index e3fcd66..ac3f2fd 100644
--- a/src/clicache/src/TransactionWriterAdapte.hpp
+++ b/src/clicache/src/TransactionWriterAdapte.hpp
@@ -27,8 +27,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
 
       /// <summary>
       /// Utility class that implements all methods in <c>ITransactionWriter</c>
@@ -36,16 +34,15 @@ namespace Generic
       /// </summary>
       generic<class TKey, class TValue>
       public ref class TransactionWriterAdapter
-        : public Apache::Geode::Client::Generic::ITransactionWriter<TKey, TValue>
+        : public Apache::Geode::Client::ITransactionWriter<TKey, TValue>
       {
       public:
         virtual void BeforeCommit(TransactionEvent<TKey, TValue>^ te)
         {
         }
       };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-    }
-  }
-}
- } //namespace 
 #endif
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/UserFunctionExecutionException.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/UserFunctionExecutionException.cpp b/src/clicache/src/UserFunctionExecutionException.cpp
index 33bf8a6..4b07135 100644
--- a/src/clicache/src/UserFunctionExecutionException.cpp
+++ b/src/clicache/src/UserFunctionExecutionException.cpp
@@ -27,8 +27,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
         // IGFSerializable methods
 
         void UserFunctionExecutionException::ToData( DataOutput^ output )
@@ -69,9 +68,9 @@ namespace Generic
             return CacheableString::GetString( value.ptr( ) );          
 
           _GF_MG_EXCEPTION_CATCH_ALL2
-        }
-      }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/UserFunctionExecutionException.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/UserFunctionExecutionException.hpp b/src/clicache/src/UserFunctionExecutionException.hpp
index 69c35fd..938675b 100644
--- a/src/clicache/src/UserFunctionExecutionException.hpp
+++ b/src/clicache/src/UserFunctionExecutionException.hpp
@@ -32,8 +32,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
         /// <summary>
         /// UserFunctionExecutionException class is used to encapsulate gemfire sendException in case of Function execution. 
         /// </summary>
@@ -127,9 +126,8 @@ namespace Generic
           inline UserFunctionExecutionException( apache::geode::client::UserFunctionExecutionException* nativeptr )
             : SBWrap( nativeptr ) { }
         };
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-      }
-    }
-  }
-}
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/Utils.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Utils.cpp b/src/clicache/src/Utils.cpp
index abc6c8b..40dccdf 100644
--- a/src/clicache/src/Utils.cpp
+++ b/src/clicache/src/Utils.cpp
@@ -26,8 +26,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-			{
 
     MethodInfo^ Utils::LoadMethod( String^ assemblyName,
       String^ typeName, String^ methodName)
@@ -71,8 +69,8 @@ namespace Generic
     int32_t Utils::LastError::get( )
     {
        return apache::geode::client::Utils::getLastError( );
-    }
-			}
-	 }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/gf_defs.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/gf_defs.hpp b/src/clicache/src/gf_defs.hpp
index 7152952..f3cdb55 100644
--- a/src/clicache/src/gf_defs.hpp
+++ b/src/clicache/src/gf_defs.hpp
@@ -41,7 +41,7 @@
 /// @namespace Apache::Geode::Client
 /// This namespace contains all the GemFire .NET API classes and enumerations.
 
-/// @namespace Apache::Geode::Client::Generic
+/// @namespace Apache::Geode::Client
 /// This namespace contains all the GemFire .NET Generics API classes and enumerations.
 
 /// @namespace Apache::Geode::Client::Internal

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/AppDomainContext.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/AppDomainContext.cpp b/src/clicache/src/impl/AppDomainContext.cpp
index 85cedd1..42d7403 100644
--- a/src/clicache/src/impl/AppDomainContext.cpp
+++ b/src/clicache/src/impl/AppDomainContext.cpp
@@ -23,11 +23,11 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic {
+
 apache::geode::client::AppDomainContext* createAppDomainContext() {
   return new AppDomainContext();
-}
-}
-}
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/AppDomainContext.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/AppDomainContext.hpp b/src/clicache/src/impl/AppDomainContext.hpp
index 9171ce4..7c0e185 100644
--- a/src/clicache/src/impl/AppDomainContext.hpp
+++ b/src/clicache/src/impl/AppDomainContext.hpp
@@ -27,7 +27,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic {
 
 using namespace System;
 
@@ -68,8 +67,7 @@ private:
 };
 
 apache::geode::client::AppDomainContext* createAppDomainContext();
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-}
-}
-}
-}

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/AuthenticatedCache.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/AuthenticatedCache.cpp b/src/clicache/src/impl/AuthenticatedCache.cpp
index c234b8d..0feee84 100644
--- a/src/clicache/src/impl/AuthenticatedCache.cpp
+++ b/src/clicache/src/impl/AuthenticatedCache.cpp
@@ -33,8 +33,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       bool AuthenticatedCache::IsClosed::get( )
       {
         return NativePtr->isClosed( );
@@ -59,17 +58,17 @@ namespace Generic
           apache::geode::client::RegionPtr& nativeptr(
             NativePtr->getRegion( mg_path.CharPtr ) );
 
-          return Generic::Region<TKey, TValue>::Create( nativeptr.ptr( ) );
+          return Client::Region<TKey, TValue>::Create( nativeptr.ptr( ) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
       
       generic<class TKey, class TResult>
-      Generic::QueryService<TKey, TResult>^ AuthenticatedCache::GetQueryService( )
+      Client::QueryService<TKey, TResult>^ AuthenticatedCache::GetQueryService( )
       {
         _GF_MG_EXCEPTION_TRY2
 
-          return Generic::QueryService<TKey, TResult>::Create( NativePtr->getQueryService( ).ptr( ) );
+          return Client::QueryService<TKey, TResult>::Create( NativePtr->getQueryService( ).ptr( ) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -85,7 +84,7 @@ namespace Generic
         for( int32_t index = 0; index < vrr.size( ); index++ )
         {
           apache::geode::client::RegionPtr& nativeptr( vrr[ index ] );
-          rootRegions[ index ] = Generic::Region<TKey, TValue>::Create( nativeptr.ptr( ) );
+          rootRegions[ index ] = Client::Region<TKey, TValue>::Create( nativeptr.ptr( ) );
         }
         return rootRegions;
       }
@@ -93,9 +92,8 @@ namespace Generic
        IPdxInstanceFactory^ AuthenticatedCache::CreatePdxInstanceFactory(String^ className)
         {
           return gcnew Internal::PdxInstanceFactoryImpl(className);;
-        }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-      } // end namespace Generic
-    }
-  }
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/AuthenticatedCache.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/AuthenticatedCache.hpp b/src/clicache/src/impl/AuthenticatedCache.hpp
index 9681474..bca3537 100644
--- a/src/clicache/src/impl/AuthenticatedCache.hpp
+++ b/src/clicache/src/impl/AuthenticatedCache.hpp
@@ -34,8 +34,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
 
       //ref class DistributedSystem;
       //ref class Region;
@@ -162,7 +160,7 @@ namespace Generic
         inline AuthenticatedCache( apache::geode::client::RegionService* nativeptr )
           : SBWrap( nativeptr ) { }
       };
-      } // end namespace Generic
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+


Mime
View raw message