geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [19/50] [abbrv] geode git commit: GEODE-2316: Rename namespace gemfire to apache::geode::client.
Date Mon, 23 Jan 2017 19:17:11 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Serializable.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.cpp b/src/clicache/src/Serializable.cpp
index fbe1488..1ded8f3 100644
--- a/src/clicache/src/Serializable.cpp
+++ b/src/clicache/src/Serializable.cpp
@@ -56,7 +56,7 @@ using namespace System::Reflection::Emit;
 using namespace System;
 using namespace System::Collections::Generic;
 using namespace Runtime::InteropServices;
-using namespace gemfire;
+using namespace apache::geode::client;
 
 namespace GemStone
 {
@@ -72,8 +72,8 @@ namespace GemStone
         if (output->IsManagedObject()) {
           output->WriteBytesToUMDataOutput();          
         }
-        gemfire::DataOutput* nativeOutput =
-          GetNativePtr<gemfire::DataOutput>(output);
+        apache::geode::client::DataOutput* nativeOutput =
+          GetNativePtr<apache::geode::client::DataOutput>(output);
         NativePtr->toData(*nativeOutput);
         if (output->IsManagedObject()) {
           output->SetBuffer();          
@@ -86,8 +86,8 @@ namespace GemStone
          if(input->IsManagedObject()) {
           input->AdvanceUMCursor();
         }
-        gemfire::DataInput* nativeInput =
-          GetNativePtr<gemfire::DataInput>(input);
+        apache::geode::client::DataInput* nativeInput =
+          GetNativePtr<apache::geode::client::DataInput>(input);
         AssignSP(NativePtr->fromData(*nativeInput));
         if(input->IsManagedObject()) {
           input->SetBuffer();
@@ -103,9 +103,9 @@ namespace GemStone
       uint32_t GemStone::GemFire::Cache::Generic::Serializable::ClassId::get()
       {
         int8_t typeId = NativePtr->typeId();
-        if (typeId == gemfire::GemfireTypeIdsImpl::CacheableUserData ||
-             typeId == gemfire::GemfireTypeIdsImpl::CacheableUserData2 ||
-             typeId == gemfire::GemfireTypeIdsImpl::CacheableUserData4) {
+        if (typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData ||
+             typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData2 ||
+             typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4) {
           return NativePtr->classId();
         } else {
           return typeId + 0x80000000 + (0x20000000 * NativePtr->DSFID());
@@ -114,7 +114,7 @@ namespace GemStone
 
       String^ GemStone::GemFire::Cache::Generic::Serializable::ToString()
       {
-        gemfire::CacheableStringPtr& cStr = NativePtr->toString();
+        apache::geode::client::CacheableStringPtr& cStr = NativePtr->toString();
         if (cStr->isWideString()) {
           return ManagedString::Get(cStr->asWChar());
         } else {
@@ -219,25 +219,25 @@ namespace GemStone
 
 			int32 Serializable::GetPDXIdForType(const char* poolName, IGFSerializable^ pdxType)
       {
-				gemfire::CacheablePtr kPtr(SafeMSerializableConvertGeneric(pdxType));
-        return gemfire::SerializationRegistry::GetPDXIdForType(poolName, kPtr);
+				apache::geode::client::CacheablePtr kPtr(SafeMSerializableConvertGeneric(pdxType));
+        return apache::geode::client::SerializationRegistry::GetPDXIdForType(poolName, kPtr);
 			}
 
       IGFSerializable^ Serializable::GetPDXTypeById(const char* poolName, int32 typeId)
       {
-				SerializablePtr sPtr = gemfire::SerializationRegistry::GetPDXTypeById(poolName, typeId);
+				SerializablePtr sPtr = apache::geode::client::SerializationRegistry::GetPDXTypeById(poolName, typeId);
         return SafeUMSerializableConvertGeneric(sPtr.ptr());
 			}
 
       int Serializable::GetEnumValue(Internal::EnumInfo^ ei)
       {
-        gemfire::CacheablePtr kPtr(SafeMSerializableConvertGeneric(ei));
-        return gemfire::SerializationRegistry::GetEnumValue(kPtr);
+        apache::geode::client::CacheablePtr kPtr(SafeMSerializableConvertGeneric(ei));
+        return apache::geode::client::SerializationRegistry::GetEnumValue(kPtr);
       }
       
       Internal::EnumInfo^ Serializable::GetEnum(int val)
       {
-        SerializablePtr sPtr = gemfire::SerializationRegistry::GetEnum(val);
+        SerializablePtr sPtr = apache::geode::client::SerializationRegistry::GetEnum(val);
         return (Internal::EnumInfo^)SafeUMSerializableConvertGeneric(sPtr.ptr());
       }
 
@@ -475,13 +475,13 @@ namespace GemStone
       {
 				if(!appDomainEnable)
 				{
-					gemfire::SerializationRegistry::addType(gemfire::GemfireTypeIdsImpl::PDX,
-						&gemfire::PdxManagedCacheableKey::CreateDeserializable );
+					apache::geode::client::SerializationRegistry::addType(apache::geode::client::GemfireTypeIdsImpl::PDX,
+						&apache::geode::client::PdxManagedCacheableKey::CreateDeserializable );
 				}
 				else
 				{
-					gemfire::SerializationRegistry::addType(gemfire::GemfireTypeIdsImpl::PDX,
-						&gemfire::PdxManagedCacheableKeyBytes::CreateDeserializable );
+					apache::geode::client::SerializationRegistry::addType(apache::geode::client::GemfireTypeIdsImpl::PDX,
+						&apache::geode::client::PdxManagedCacheableKeyBytes::CreateDeserializable );
 				}
       }
 
@@ -515,7 +515,7 @@ namespace GemStone
 
         _GF_MG_EXCEPTION_TRY2
 
-          gemfire::Serializable::registerType((gemfire::TypeFactoryMethod)
+          apache::geode::client::Serializable::registerType((apache::geode::client::TypeFactoryMethod)
             System::Runtime::InteropServices::Marshal::
             GetFunctionPointerForDelegate(nativeDelegate).ToPointer());
 
@@ -553,20 +553,20 @@ namespace GemStone
         {
 					if(tmp->ClassId < 0xa0000000)
 					{
-						gemfire::SerializationRegistry::addType(typeId,
-							(gemfire::TypeFactoryMethod)System::Runtime::InteropServices::
+						apache::geode::client::SerializationRegistry::addType(typeId,
+							(apache::geode::client::TypeFactoryMethod)System::Runtime::InteropServices::
 							Marshal::GetFunctionPointerForDelegate(
 							nativeDelegate).ToPointer());
 					}
 					else
 					{//special case for CacheableUndefined type
-							gemfire::SerializationRegistry::addType2(typeId,
-							(gemfire::TypeFactoryMethod)System::Runtime::InteropServices::
+							apache::geode::client::SerializationRegistry::addType2(typeId,
+							(apache::geode::client::TypeFactoryMethod)System::Runtime::InteropServices::
 							Marshal::GetFunctionPointerForDelegate(
 							nativeDelegate).ToPointer());
 					}
 
-        }catch(gemfire::IllegalStateException&)
+        }catch(apache::geode::client::IllegalStateException&)
         {
           //ignore it as this is internal only
         }
@@ -577,7 +577,7 @@ namespace GemStone
         BuiltInDelegatesGeneric->Remove(typeId);
         _GF_MG_EXCEPTION_TRY2
 
-          gemfire::SerializationRegistry::removeType(typeId);
+          apache::geode::client::SerializationRegistry::removeType(typeId);
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -605,7 +605,7 @@ namespace GemStone
       }
 
       generic<class TValue>
-      TValue Serializable::GetManagedValueGeneric(gemfire::SerializablePtr val)
+      TValue Serializable::GetManagedValueGeneric(apache::geode::client::SerializablePtr val)
       {
         if (val == NULLPTR)
         {
@@ -616,7 +616,7 @@ namespace GemStone
 				 //Log::Debug("Serializable::GetManagedValueGeneric typeid = " + typeId);
         switch(typeId)
         {
-        case gemfire::GemfireTypeIds::CacheableByte:
+        case apache::geode::client::GemfireTypeIds::CacheableByte:
           {
 						return (TValue)(int8_t)safe_cast<int8_t>(Serializable::getByte(val));
            /* if (TValue::typeid == System::SByte::typeid) {
@@ -627,31 +627,31 @@ namespace GemStone
             }
             return safe_cast<TValue>(Serializable::getByte(val));*/
           }
-        case gemfire::GemfireTypeIds::CacheableBoolean:
+        case apache::geode::client::GemfireTypeIds::CacheableBoolean:
           {
             return safe_cast<TValue>(Serializable::getBoolean(val));
           }
-        case gemfire::GemfireTypeIds::CacheableWideChar:
+        case apache::geode::client::GemfireTypeIds::CacheableWideChar:
           {
             return safe_cast<TValue>(Serializable::getChar(val));
           }
-        case gemfire::GemfireTypeIds::CacheableDouble:
+        case apache::geode::client::GemfireTypeIds::CacheableDouble:
           {
             return safe_cast<TValue>(Serializable::getDouble(val));
           }
-        case gemfire::GemfireTypeIds::CacheableASCIIString:
-        case gemfire::GemfireTypeIds::CacheableASCIIStringHuge:
-        case gemfire::GemfireTypeIds::CacheableString:
-        case gemfire::GemfireTypeIds::CacheableStringHuge:
+        case apache::geode::client::GemfireTypeIds::CacheableASCIIString:
+        case apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge:
+        case apache::geode::client::GemfireTypeIds::CacheableString:
+        case apache::geode::client::GemfireTypeIds::CacheableStringHuge:
           {
             //TODO: need to look all strings types
             return safe_cast<TValue>(Serializable::getASCIIString(val));
           }
-        case gemfire::GemfireTypeIds::CacheableFloat:
+        case apache::geode::client::GemfireTypeIds::CacheableFloat:
           {
             return safe_cast<TValue>(Serializable::getFloat(val));
           }
-        case gemfire::GemfireTypeIds::CacheableInt16:
+        case apache::geode::client::GemfireTypeIds::CacheableInt16:
           {
            /* if (TValue::typeid == System::Int16::typeid) {
               return (TValue)(int16_t)safe_cast<int16_t>(Serializable::getInt16(val));              
@@ -661,7 +661,7 @@ namespace GemStone
             }*/
             return safe_cast<TValue>(Serializable::getInt16(val));
           }
-        case gemfire::GemfireTypeIds::CacheableInt32:
+        case apache::geode::client::GemfireTypeIds::CacheableInt32:
           {  
            /* if (TValue::typeid == System::Int32::typeid) {
               return (TValue)(int32_t)safe_cast<int32_t>(Serializable::getInt32(val));              
@@ -671,7 +671,7 @@ namespace GemStone
             }  */          
             return safe_cast<TValue>(Serializable::getInt32(val));
           }
-        case gemfire::GemfireTypeIds::CacheableInt64:
+        case apache::geode::client::GemfireTypeIds::CacheableInt64:
           {
             /*if (TValue::typeid == System::Int64::typeid) {
               return (TValue)(int64_t)safe_cast<int64_t>(Serializable::getInt64(val));              
@@ -681,7 +681,7 @@ namespace GemStone
             }*/
             return safe_cast<TValue>(Serializable::getInt64(val));
           }
-					case gemfire::GemfireTypeIds::CacheableDate:
+					case apache::geode::client::GemfireTypeIds::CacheableDate:
           {
 						//TODO::
             GemStone::GemFire::Cache::Generic::CacheableDate^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableDate ^>
@@ -690,16 +690,16 @@ namespace GemStone
             System::DateTime dt(ret->Value.Ticks);
             return safe_cast<TValue>(dt);
           }
-        case gemfire::GemfireTypeIdsImpl::CacheableUserData:
-        case gemfire::GemfireTypeIdsImpl::CacheableUserData2:
-        case gemfire::GemfireTypeIdsImpl::CacheableUserData4:
+        case apache::geode::client::GemfireTypeIdsImpl::CacheableUserData:
+        case apache::geode::client::GemfireTypeIdsImpl::CacheableUserData2:
+        case apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4:
           {
 						//TODO::split 
             IGFSerializable^ ret = SafeUMSerializableConvertGeneric(val.ptr());
             return safe_cast<TValue>(ret);
 						//return TValue();
           }
-        case gemfire::GemfireTypeIdsImpl::PDX:
+        case apache::geode::client::GemfireTypeIdsImpl::PDX:
           {
             IPdxSerializable^ ret = SafeUMSerializablePDXConvert(val.ptr());
 
@@ -712,49 +712,49 @@ namespace GemStone
 
             return safe_cast<TValue>(ret);
           }
-        case gemfire::GemfireTypeIds::CacheableBytes:
+        case apache::geode::client::GemfireTypeIds::CacheableBytes:
           {
             GemStone::GemFire::Cache::Generic::CacheableBytes^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableBytes ^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableBytes^>(val.ptr()));
 
             return safe_cast<TValue>(ret->Value);            
           }
-        case gemfire::GemfireTypeIds::CacheableDoubleArray:
+        case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
           {
             GemStone::GemFire::Cache::Generic::CacheableDoubleArray^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableDoubleArray ^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableDoubleArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableFloatArray:
+        case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
           {
             GemStone::GemFire::Cache::Generic::CacheableFloatArray^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableFloatArray^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableFloatArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableInt16Array:
+        case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
           {
             GemStone::GemFire::Cache::Generic::CacheableInt16Array^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableInt16Array^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableInt16Array^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableInt32Array:
+        case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
           {
             GemStone::GemFire::Cache::Generic::CacheableInt32Array^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableInt32Array^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableInt32Array^>(val.ptr()));
 
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableInt64Array:
+        case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
           {
 						GemStone::GemFire::Cache::Generic::CacheableInt64Array^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableInt64Array^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableInt64Array^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableStringArray:
+        case apache::geode::client::GemfireTypeIds::CacheableStringArray:
           {
             GemStone::GemFire::Cache::Generic::CacheableStringArray^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableStringArray^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableStringArray^>(val.ptr()));
@@ -766,81 +766,81 @@ namespace GemStone
 
             return safe_cast<TValue>(ret->GetValues());
           }
-        case gemfire::GemfireTypeIds::CacheableArrayList://Ilist generic
+        case apache::geode::client::GemfireTypeIds::CacheableArrayList://Ilist generic
           {
             GemStone::GemFire::Cache::Generic::CacheableArrayList^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableArrayList^>
              ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableArrayList^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableLinkedList://LinkedList generic
+        case apache::geode::client::GemfireTypeIds::CacheableLinkedList://LinkedList generic
           {
             GemStone::GemFire::Cache::Generic::CacheableLinkedList^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableLinkedList^>
              ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableLinkedList^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }		  
-        case gemfire::GemfireTypeIds::CacheableHashTable://collection::hashtable
+        case apache::geode::client::GemfireTypeIds::CacheableHashTable://collection::hashtable
           {
             GemStone::GemFire::Cache::Generic::CacheableHashTable^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableHashTable^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableHashTable^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-        case gemfire::GemfireTypeIds::CacheableHashMap://generic dictionary
+        case apache::geode::client::GemfireTypeIds::CacheableHashMap://generic dictionary
           {
            GemStone::GemFire::Cache::Generic::CacheableHashMap^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CacheableHashMap^>
              ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableHashMap^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
           }
-				case gemfire::GemfireTypeIds::CacheableIdentityHashMap:
+				case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
           {
             GemStone::GemFire::Cache::Generic::CacheableIdentityHashMap^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableIdentityHashMap^>
 							( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableIdentityHashMap^>(val.ptr()));            
             return safe_cast<TValue>(ret->Value);
           }
-				 case gemfire::GemfireTypeIds::CacheableHashSet://no need of it, default case should work
+				 case apache::geode::client::GemfireTypeIds::CacheableHashSet://no need of it, default case should work
         {
           GemStone::GemFire::Cache::Generic::CacheableHashSet^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableHashSet^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableHashSet^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
-        case gemfire::GemfireTypeIds::CacheableLinkedHashSet://no need of it, default case should work
+        case apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
           GemStone::GemFire::Cache::Generic::CacheableLinkedHashSet^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableLinkedHashSet^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableLinkedHashSet^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
-				case gemfire::GemfireTypeIds::CacheableFileName:
+				case apache::geode::client::GemfireTypeIds::CacheableFileName:
         {
           GemStone::GemFire::Cache::Generic::CacheableFileName^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableFileName^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableFileName^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
-				 case gemfire::GemfireTypeIds::CacheableObjectArray:
+				 case apache::geode::client::GemfireTypeIds::CacheableObjectArray:
         {
           GemStone::GemFire::Cache::Generic::CacheableObjectArray^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableObjectArray^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableObjectArray^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
-				case gemfire::GemfireTypeIds::CacheableVector://collection::arraylist
+				case apache::geode::client::GemfireTypeIds::CacheableVector://collection::arraylist
         {
           GemStone::GemFire::Cache::Generic::CacheableVector^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableVector^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableVector^>(val.ptr()));
           return safe_cast<TValue>(ret->Value);
         }
-				case gemfire::GemfireTypeIds::CacheableUndefined:
+				case apache::geode::client::GemfireTypeIds::CacheableUndefined:
         {
           GemStone::GemFire::Cache::Generic::CacheableUndefined^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableUndefined^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableUndefined^>(val.ptr()));
           return safe_cast<TValue>(ret);
         }
-        case gemfire::GemfireTypeIds::Struct:
+        case apache::geode::client::GemfireTypeIds::Struct:
         {
           return safe_cast<TValue>(GemStone::GemFire::Cache::Generic::Struct::Create(val.ptr()));
         }
-				case gemfire::GemfireTypeIds::CacheableStack:
+				case apache::geode::client::GemfireTypeIds::CacheableStack:
         {
           GemStone::GemFire::Cache::Generic::CacheableStack^ ret = static_cast<GemStone::GemFire::Cache::Generic::CacheableStack^>
 						( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CacheableStack^>(val.ptr()));
@@ -859,7 +859,7 @@ namespace GemStone
           return safe_cast<TValue>(ret);
         }
           /*  TODO: replace with IDictionary<K, V>
-        case gemfire::GemfireTypeIds::Properties:
+        case apache::geode::client::GemfireTypeIds::Properties:
           {
             GemStone::GemFire::Cache::Generic::Properties^ ret = safe_cast<GemStone::GemFire::Cache::Generic::Properties^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::Properties^>(val.ptr()));
@@ -867,14 +867,14 @@ namespace GemStone
             return safe_cast<TValue>(ret);
           }*/
        
-        case gemfire::GemfireTypeIds::BooleanArray:
+        case apache::geode::client::GemfireTypeIds::BooleanArray:
           {
 						GemStone::GemFire::Cache::Generic::BooleanArray^ ret = safe_cast<GemStone::GemFire::Cache::Generic::BooleanArray^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::BooleanArray^>(val.ptr()));
             
             return safe_cast<TValue>(ret->Value);
 					}
-        case gemfire::GemfireTypeIds::CharArray:
+        case apache::geode::client::GemfireTypeIds::CharArray:
           {
 						GemStone::GemFire::Cache::Generic::CharArray^ ret = safe_cast<GemStone::GemFire::Cache::Generic::CharArray^>
               ( SafeGenericUMSerializableConvert<GemStone::GemFire::Cache::Generic::CharArray^>(val.ptr()));
@@ -894,7 +894,7 @@ namespace GemStone
       }
 
       generic<class TKey>
-      gemfire::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(TKey key)
+      apache::geode::client::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(TKey key)
       {
         //System::Type^ managedType = TKey::typeid;  
         if (key != nullptr) {
@@ -905,7 +905,7 @@ namespace GemStone
       }
 
       generic<class TKey>
-      gemfire::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(TKey key, bool isAciiChar)
+      apache::geode::client::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(TKey key, bool isAciiChar)
       {
         //System::Type^ managedType = TKey::typeid;  
         if (key != nullptr) {
@@ -1032,21 +1032,21 @@ namespace GemStone
       }
       
       generic<class TKey>
-      gemfire::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
+      apache::geode::client::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
         Type^ managedType, TKey key)
       {
         return GetUnmanagedValueGeneric(managedType, key, false);
       }
       
       generic<class TKey>
-      gemfire::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
+      apache::geode::client::CacheableKeyPtr Serializable::GetUnmanagedValueGeneric(
         Type^ managedType, TKey key, bool isAsciiChar)
       {
         Byte typeId = GemStone::GemFire::Cache::Generic::Serializable::GetManagedTypeMappingGeneric(managedType);        
 
         switch(typeId)
         {
-        case gemfire::GemfireTypeIds::CacheableByte: {
+        case apache::geode::client::GemfireTypeIds::CacheableByte: {
 					return Serializable::getCacheableByte((SByte)key);
          /* if( managedType == System::SByte::typeid )
           {
@@ -1057,21 +1057,21 @@ namespace GemStone
             return Serializable::getCacheableByte((Byte)key);
           }*/
         }
-        case gemfire::GemfireTypeIds::CacheableBoolean:
+        case apache::geode::client::GemfireTypeIds::CacheableBoolean:
           return Serializable::getCacheableBoolean((bool)key);
-        case gemfire::GemfireTypeIds::CacheableWideChar:
+        case apache::geode::client::GemfireTypeIds::CacheableWideChar:
           return Serializable::getCacheableWideChar((Char)key);
-        case gemfire::GemfireTypeIds::CacheableDouble:
+        case apache::geode::client::GemfireTypeIds::CacheableDouble:
           return Serializable::getCacheableDouble((double)key);
-        case gemfire::GemfireTypeIds::CacheableASCIIString: {
+        case apache::geode::client::GemfireTypeIds::CacheableASCIIString: {
           if (isAsciiChar)
             return Serializable::getCacheableASCIIString2((String^)key);
           else
             return Serializable::getCacheableASCIIString((String^)key);
                                                             }
-        case gemfire::GemfireTypeIds::CacheableFloat:
+        case apache::geode::client::GemfireTypeIds::CacheableFloat:
           return Serializable::getCacheableFloat((float)key);
-        case gemfire::GemfireTypeIds::CacheableInt16: {
+        case apache::geode::client::GemfireTypeIds::CacheableInt16: {
           /*if( managedType == System::Int16::typeid )
             {      
               return Serializable::getCacheableInt16((int16_t)key);
@@ -1082,7 +1082,7 @@ namespace GemStone
             }*/
           return Serializable::getCacheableInt16((int16_t)key);
          }
-        case gemfire::GemfireTypeIds::CacheableInt32: {
+        case apache::geode::client::GemfireTypeIds::CacheableInt32: {
           /* if( managedType == System::Int32::typeid )
             {      
               return Serializable::getCacheableInt32((int32_t)key);
@@ -1093,7 +1093,7 @@ namespace GemStone
             }*/
 					 return Serializable::getCacheableInt32((int32_t)key);
          }
-        case gemfire::GemfireTypeIds::CacheableInt64: {
+        case apache::geode::client::GemfireTypeIds::CacheableInt64: {
           /*if( managedType == System::Int64::typeid )
             {      
               return Serializable::getCacheableInt64((int64_t)key);
@@ -1104,159 +1104,159 @@ namespace GemStone
             }*/
           return Serializable::getCacheableInt64((int64_t)key);
          }
-        case gemfire::GemfireTypeIds::CacheableBytes:
+        case apache::geode::client::GemfireTypeIds::CacheableBytes:
           {
-						gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableBytes::Create((array<Byte>^)key)));
+						apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableBytes::Create((array<Byte>^)key)));
               return kPtr;
             /*if( managedType == Type::GetType("System.Byte[]") ) {
-              gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableBytes::Create((array<Byte>^)key)));
+              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableBytes::Create((array<Byte>^)key)));
               return kPtr;
             }
             else {
-              gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableBytes::Create(getSByteArray((array<SByte>^)key))));
+              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableBytes::Create(getSByteArray((array<SByte>^)key))));
               return kPtr;
             }*/
           }
-        case gemfire::GemfireTypeIds::CacheableDoubleArray:
+        case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
           {
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableDoubleArray::Create((array<Double>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableDoubleArray::Create((array<Double>^)key)));
             return kPtr;
           }
-        case gemfire::GemfireTypeIds::CacheableFloatArray:
+        case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableFloatArray::Create((array<float>^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableFloatArray::Create((array<float>^)key)));
            return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableInt16Array:
+        case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
         {
-					 gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt16Array::Create((array<Int16>^)key)));
+					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt16Array::Create((array<Int16>^)key)));
             return kPtr;
          /* if( managedType == Type::GetType("System.Int16[]") ) {
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt16Array::Create((array<Int16>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt16Array::Create((array<Int16>^)key)));
             return kPtr;
           }
           else { 
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt16Array::Create(getInt16Array((array<uint16_t>^)key))));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt16Array::Create(getInt16Array((array<uint16_t>^)key))));
             return kPtr;
           }  */          
         }
-        case gemfire::GemfireTypeIds::CacheableInt32Array:
+        case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
         {
-					 gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt32Array::Create((array<Int32>^)key)));
+					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt32Array::Create((array<Int32>^)key)));
             return kPtr;
         /*  if( managedType == Type::GetType("System.Int32[]") ) {
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt32Array::Create((array<Int32>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt32Array::Create((array<Int32>^)key)));
             return kPtr;
           }
           else { 
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt32Array::Create(getInt32Array((array<uint32_t>^)key))));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt32Array::Create(getInt32Array((array<uint32_t>^)key))));
             return kPtr;
           }       */   
         }
-        case gemfire::GemfireTypeIds::CacheableInt64Array:
+        case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
         {
-					gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt64Array::Create((array<Int64>^)key)));
+					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt64Array::Create((array<Int64>^)key)));
             return kPtr;
           /*if( managedType == Type::GetType("System.Int64[]") ) {
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt64Array::Create((array<Int64>^)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt64Array::Create((array<Int64>^)key)));
             return kPtr;
           }
           else { 
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt64Array::Create(getInt64Array((array<uint64_t>^)key))));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableInt64Array::Create(getInt64Array((array<uint64_t>^)key))));
             return kPtr;
           }     */                  
         }
-        case gemfire::GemfireTypeIds::CacheableStringArray:
+        case apache::geode::client::GemfireTypeIds::CacheableStringArray:
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableStringArray::Create((array<String^>^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableStringArray::Create((array<String^>^)key)));
            return kPtr;
         }
-				case gemfire::GemfireTypeIds::CacheableFileName:
+				case apache::geode::client::GemfireTypeIds::CacheableFileName:
         {
-					gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)(GemStone::GemFire::Cache::Generic::CacheableFileName^)key));
+					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)(GemStone::GemFire::Cache::Generic::CacheableFileName^)key));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableHashTable://collection::hashtable
+        case apache::geode::client::GemfireTypeIds::CacheableHashTable://collection::hashtable
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableHashTable::Create((System::Collections::Hashtable^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableHashTable::Create((System::Collections::Hashtable^)key)));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableHashMap://generic dictionary
+        case apache::geode::client::GemfireTypeIds::CacheableHashMap://generic dictionary
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableHashMap::Create((System::Collections::IDictionary^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableHashMap::Create((System::Collections::IDictionary^)key)));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableVector://collection::arraylist
+        case apache::geode::client::GemfireTypeIds::CacheableVector://collection::arraylist
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)CacheableVector::Create((System::Collections::IList^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)CacheableVector::Create((System::Collections::IList^)key)));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableArrayList://generic ilist
+        case apache::geode::client::GemfireTypeIds::CacheableArrayList://generic ilist
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableArrayList::Create((System::Collections::IList^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableArrayList::Create((System::Collections::IList^)key)));
           return kPtr;
         } 
-        case gemfire::GemfireTypeIds::CacheableLinkedList://generic linked list
+        case apache::geode::client::GemfireTypeIds::CacheableLinkedList://generic linked list
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)));
           return kPtr;
         }		
-		case gemfire::GemfireTypeIds::CacheableStack:
+		case apache::geode::client::GemfireTypeIds::CacheableStack:
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert(GemStone::GemFire::Cache::Generic::CacheableStack::Create((System::Collections::ICollection^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(GemStone::GemFire::Cache::Generic::CacheableStack::Create((System::Collections::ICollection^)key)));
           return kPtr;
         }
         case 7: //GemFireClassIds::CacheableManagedObject
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableObject^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableObject^)key));
           return kPtr;
         }
         case 8://GemFireClassIds::CacheableManagedObjectXml
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableObjectXml^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableObjectXml^)key));
           return kPtr;
         }
-				 case gemfire::GemfireTypeIds::CacheableObjectArray:
+				 case apache::geode::client::GemfireTypeIds::CacheableObjectArray:
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableObjectArray^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableObjectArray^)key));
           return kPtr;
         }
-			  case gemfire::GemfireTypeIds::CacheableIdentityHashMap:
+			  case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert(GemStone::GemFire::Cache::Generic::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(GemStone::GemFire::Cache::Generic::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableHashSet://no need of it, default case should work
+        case apache::geode::client::GemfireTypeIds::CacheableHashSet://no need of it, default case should work
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableHashSet^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableHashSet^)key));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableLinkedHashSet://no need of it, default case should work
+        case apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
-          gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableLinkedHashSet^)key));
+          apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((GemStone::GemFire::Cache::Generic::CacheableLinkedHashSet^)key));
           return kPtr;
         }
-        case gemfire::GemfireTypeIds::CacheableDate:
+        case apache::geode::client::GemfireTypeIds::CacheableDate:
           {
-            gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableDate::Create((System::DateTime)key)));
+            apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CacheableDate::Create((System::DateTime)key)));
             return kPtr;
           }
-        case gemfire::GemfireTypeIds::BooleanArray:
+        case apache::geode::client::GemfireTypeIds::BooleanArray:
           {   
-					  gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::BooleanArray::Create((array<bool>^)key)));
+					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::BooleanArray::Create((array<bool>^)key)));
             return kPtr;
 					}
-        case gemfire::GemfireTypeIds::CharArray:
+        case apache::geode::client::GemfireTypeIds::CharArray:
           {
-					  gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CharArray::Create((array<Char>^)key)));
+					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)GemStone::GemFire::Cache::Generic::CharArray::Create((array<Char>^)key)));
             return kPtr;
 					}
         default:
           {
-						gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert(key));
+						apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(key));
             /*IGFSerializable^ ct = safe_cast<IGFSerializable^>(key);
             if(ct != nullptr) {
-              gemfire::CacheablePtr kPtr(SafeGenericMSerializableConvert(ct));
+              apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(ct));
               return kPtr;
             }*/
             //throw gcnew System::Exception("not found typeid");
@@ -1265,7 +1265,7 @@ namespace GemStone
         }
       } //
 
-				String^ Serializable::GetString(gemfire::CacheableStringPtr cStr)//gemfire::CacheableString*
+				String^ Serializable::GetString(apache::geode::client::CacheableStringPtr cStr)//apache::geode::client::CacheableString*
         {
           if (cStr == NULLPTR) {
             return nullptr;
@@ -1281,196 +1281,196 @@ namespace GemStone
         // These are the new static methods to get/put data from c++
 
         //byte
-        Byte Serializable::getByte(gemfire::SerializablePtr nativeptr)
+        Byte Serializable::getByte(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableByte* ci = static_cast<gemfire::CacheableByte*>(nativeptr.ptr());
+          apache::geode::client::CacheableByte* ci = static_cast<apache::geode::client::CacheableByte*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableByte(SByte val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableByte(SByte val)
         {
-          return gemfire::CacheableByte::create(val);
+          return apache::geode::client::CacheableByte::create(val);
         }
 
         //boolean
-        bool Serializable::getBoolean(gemfire::SerializablePtr nativeptr)
+        bool Serializable::getBoolean(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableBoolean* ci = static_cast<gemfire::CacheableBoolean*>(nativeptr.ptr());
+          apache::geode::client::CacheableBoolean* ci = static_cast<apache::geode::client::CacheableBoolean*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableBoolean(bool val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableBoolean(bool val)
         {
-          return gemfire::CacheableBoolean::create(val);
+          return apache::geode::client::CacheableBoolean::create(val);
         }
 
         //widechar
-        Char Serializable::getChar(gemfire::SerializablePtr nativeptr)
+        Char Serializable::getChar(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableWideChar* ci = static_cast<gemfire::CacheableWideChar*>(nativeptr.ptr());
+          apache::geode::client::CacheableWideChar* ci = static_cast<apache::geode::client::CacheableWideChar*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableWideChar(Char val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableWideChar(Char val)
         {
-          return gemfire::CacheableWideChar::create(val);
+          return apache::geode::client::CacheableWideChar::create(val);
         }
 
         //double
-        double Serializable::getDouble(gemfire::SerializablePtr nativeptr)
+        double Serializable::getDouble(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableDouble* ci = static_cast<gemfire::CacheableDouble*>(nativeptr.ptr());
+          apache::geode::client::CacheableDouble* ci = static_cast<apache::geode::client::CacheableDouble*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableDouble(double val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableDouble(double val)
         {
-          return gemfire::CacheableDouble::create(val);
+          return apache::geode::client::CacheableDouble::create(val);
         }
 
         //float
-        float Serializable::getFloat(gemfire::SerializablePtr nativeptr)
+        float Serializable::getFloat(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableFloat* ci = static_cast<gemfire::CacheableFloat*>(nativeptr.ptr());
+          apache::geode::client::CacheableFloat* ci = static_cast<apache::geode::client::CacheableFloat*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableFloat(float val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableFloat(float val)
         {
-          return gemfire::CacheableFloat::create(val);
+          return apache::geode::client::CacheableFloat::create(val);
         }
 
         //int16
-        int16 Serializable::getInt16(gemfire::SerializablePtr nativeptr)
+        int16 Serializable::getInt16(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableInt16* ci = static_cast<gemfire::CacheableInt16*>(nativeptr.ptr());
+          apache::geode::client::CacheableInt16* ci = static_cast<apache::geode::client::CacheableInt16*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableInt16(int val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableInt16(int val)
         {
-          return gemfire::CacheableInt16::create(val);
+          return apache::geode::client::CacheableInt16::create(val);
         }
 
         //int32
-        int32 Serializable::getInt32(gemfire::SerializablePtr nativeptr)
+        int32 Serializable::getInt32(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableInt32* ci = static_cast<gemfire::CacheableInt32*>(nativeptr.ptr());
+          apache::geode::client::CacheableInt32* ci = static_cast<apache::geode::client::CacheableInt32*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableInt32(int32 val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableInt32(int32 val)
         {
-          return gemfire::CacheableInt32::create(val);
+          return apache::geode::client::CacheableInt32::create(val);
         }
 
         //int64
-        int64 Serializable::getInt64(gemfire::SerializablePtr nativeptr)
+        int64 Serializable::getInt64(apache::geode::client::SerializablePtr nativeptr)
         {
-          gemfire::CacheableInt64* ci = static_cast<gemfire::CacheableInt64*>(nativeptr.ptr());
+          apache::geode::client::CacheableInt64* ci = static_cast<apache::geode::client::CacheableInt64*>(nativeptr.ptr());
           return ci->value();
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableInt64(int64 val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableInt64(int64 val)
         {
-          return gemfire::CacheableInt64::create(val);
+          return apache::geode::client::CacheableInt64::create(val);
         }
 
         //cacheable ascii string
-        String^ Serializable::getASCIIString(gemfire::SerializablePtr nativeptr)
+        String^ Serializable::getASCIIString(apache::geode::client::SerializablePtr nativeptr)
         {
-          //gemfire::CacheableString* ci = static_cast<gemfire::CacheableString*>(nativeptr.ptr());          
+          //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());          
           //return GetString(ci);
           return GetString(nativeptr->toString());
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableASCIIString(String^ val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableASCIIString(String^ val)
         {
           return GetCacheableString(val);
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableASCIIString2(String^ val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableASCIIString2(String^ val)
         {
           return GetCacheableString2(val);
         }
 
         //cacheable ascii string huge
-        String^ Serializable::getASCIIStringHuge(gemfire::SerializablePtr nativeptr)
+        String^ Serializable::getASCIIStringHuge(apache::geode::client::SerializablePtr nativeptr)
         {
-          //gemfire::CacheableString* ci = static_cast<gemfire::CacheableString*>(nativeptr.ptr());          
+          //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());          
           //return GetString(ci);
           return GetString(nativeptr->toString());
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableASCIIStringHuge(String^ val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableASCIIStringHuge(String^ val)
         {
           return GetCacheableString(val);
         }
 
         //cacheable string
-        String^ Serializable::getUTFString(gemfire::SerializablePtr nativeptr)
+        String^ Serializable::getUTFString(apache::geode::client::SerializablePtr nativeptr)
         {
-          //gemfire::CacheableString* ci = static_cast<gemfire::CacheableString*>(nativeptr.ptr());          
+          //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());          
           //return GetString(ci);
           return GetString(nativeptr->toString());
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableUTFString(String^ val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableUTFString(String^ val)
         {
           return GetCacheableString(val);
         }
 
         //cacheable string huge
-        String^ Serializable::getUTFStringHuge(gemfire::SerializablePtr nativeptr)
+        String^ Serializable::getUTFStringHuge(apache::geode::client::SerializablePtr nativeptr)
         {
-          //gemfire::CacheableString* ci = static_cast<gemfire::CacheableString*>(nativeptr.ptr());
+          //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());
           //return GetString(ci);
           return GetString(nativeptr->toString());
         }
 
-        gemfire::CacheableKeyPtr Serializable::getCacheableUTFStringHuge(String^ val)
+        apache::geode::client::CacheableKeyPtr Serializable::getCacheableUTFStringHuge(String^ val)
         {
           return GetCacheableString(val);
         }
 
-       gemfire::CacheableStringPtr Serializable::GetCacheableString(String^ value)
+       apache::geode::client::CacheableStringPtr Serializable::GetCacheableString(String^ value)
        {
-          gemfire::CacheableStringPtr cStr;
+          apache::geode::client::CacheableStringPtr cStr;
           size_t len = 0;
           if (value != nullptr) {
             len = value->Length;
             pin_ptr<const wchar_t> pin_value = PtrToStringChars(value);
-            cStr = gemfire::CacheableString::create(pin_value, static_cast<int32_t> (len));
+            cStr = apache::geode::client::CacheableString::create(pin_value, static_cast<int32_t> (len));
           }
           else {
-            cStr = (gemfire::CacheableString*)
-              gemfire::CacheableString::createDeserializable();
+            cStr = (apache::geode::client::CacheableString*)
+              apache::geode::client::CacheableString::createDeserializable();
           }
 
           return cStr;
         }
 
-       gemfire::CacheableStringPtr Serializable::GetCacheableString2(String^ value)
+       apache::geode::client::CacheableStringPtr Serializable::GetCacheableString2(String^ value)
        {
-          gemfire::CacheableStringPtr cStr;
+          apache::geode::client::CacheableStringPtr cStr;
           size_t len = 0;
           if (value != nullptr) {
             len = value->Length;
             const char* chars = 
               (const char*)(Marshal::StringToHGlobalAnsi(value)).ToPointer();
-            cStr = gemfire::CacheableString::create(chars, static_cast<int32_t> (len));
+            cStr = apache::geode::client::CacheableString::create(chars, static_cast<int32_t> (len));
             Marshal::FreeHGlobal(IntPtr((void*)chars));
           }
           else {
-            cStr = (gemfire::CacheableString*)
-              gemfire::CacheableString::createDeserializable();
+            cStr = (apache::geode::client::CacheableString*)
+              apache::geode::client::CacheableString::createDeserializable();
           }
 
           return cStr;
         }
 
        /*
-        static String^ GetString(gemfire::CacheableStringPtr cStr)//gemfire::CacheableString*
+        static String^ GetString(apache::geode::client::CacheableStringPtr cStr)//apache::geode::client::CacheableString*
         {
           if (cStr == NULLPTR) {
             return nullptr;

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Serializable.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.hpp b/src/clicache/src/Serializable.hpp
index 1b5369b..43e9ec9 100644
--- a/src/clicache/src/Serializable.hpp
+++ b/src/clicache/src/Serializable.hpp
@@ -44,13 +44,13 @@ namespace GemStone
         interface class IPdxSerializer;
       /// <summary>
       /// Signature of native function delegates passed to native
-      /// <c>gemfire::Serializable::registerType</c>.
+      /// <c>apache::geode::client::Serializable::registerType</c>.
       /// Such functions should return an empty instance of the type they
       /// represent. The instance will typically be initialized immediately
       /// after creation by a call to native
-      /// <c>gemfire::Serializable::fromData</c>.
+      /// <c>apache::geode::client::Serializable::fromData</c>.
       /// </summary>
-      delegate gemfire::Serializable* TypeFactoryNativeMethodGeneric();
+      delegate apache::geode::client::Serializable* TypeFactoryNativeMethodGeneric();
 
       /// <summary>
       /// Signature of function delegates passed to
@@ -63,13 +63,13 @@ namespace GemStone
       /// </summary>
       public delegate GemStone::GemFire::Cache::Generic::IGFSerializable^ TypeFactoryMethodGeneric();
       /// <summary>
-      /// Delegate to wrap a native <c>gemfire::Serializable</c> type.
+      /// Delegate to wrap a native <c>apache::geode::client::Serializable</c> type.
       /// </summary>
       /// <remarks>
       /// This delegate should return an object of type <c>IGFSerializable</c>
       /// given a native object.
       /// </remarks>
-      delegate GemStone::GemFire::Cache::Generic::IGFSerializable^ WrapperDelegateGeneric(gemfire::Serializable* obj);
+      delegate GemStone::GemFire::Cache::Generic::IGFSerializable^ WrapperDelegateGeneric(apache::geode::client::Serializable* obj);
 
 			/// <summary>
       /// Signature of function delegates passed to
@@ -81,11 +81,11 @@ namespace GemStone
       public delegate GemStone::GemFire::Cache::Generic::IPdxSerializable^ PdxTypeFactoryMethod();
       
       /// <summary>
-      /// This class wraps the native C++ <c>gemfire::Serializable</c> objects
+      /// This class wraps the native C++ <c>apache::geode::client::Serializable</c> objects
       /// as managed <see cref="IGFSerializable" /> objects.
       /// </summary>
       public ref class Serializable
-        : public GemStone::GemFire::Cache::Generic::Internal::SBWrap<gemfire::Serializable>,
+        : public GemStone::GemFire::Cache::Generic::Internal::SBWrap<apache::geode::client::Serializable>,
         public GemStone::GemFire::Cache::Generic::IGFSerializable
       {
       public:
@@ -315,81 +315,81 @@ namespace GemStone
          static Dictionary<String^, PdxTypeFactoryMethod^>^ PdxDelegateMap =
           gcnew Dictionary<String^, PdxTypeFactoryMethod^>();
        
-        static String^ GetString(gemfire::CacheableStringPtr cStr);//gemfire::CacheableString*
+        static String^ GetString(apache::geode::client::CacheableStringPtr cStr);//apache::geode::client::CacheableString*
         
         // These are the new static methods to get/put data from c++
 
         //byte
-        static Byte getByte(gemfire::SerializablePtr nativeptr);
+        static Byte getByte(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableByte(SByte val);
+        static apache::geode::client::CacheableKeyPtr getCacheableByte(SByte val);
         
         //boolean
-        static bool getBoolean(gemfire::SerializablePtr nativeptr);
+        static bool getBoolean(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableBoolean(bool val);
+        static apache::geode::client::CacheableKeyPtr getCacheableBoolean(bool val);
         
         //widechar
-        static Char getChar(gemfire::SerializablePtr nativeptr);
+        static Char getChar(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableWideChar(Char val);
+        static apache::geode::client::CacheableKeyPtr getCacheableWideChar(Char val);
         
         //double
-        static double getDouble(gemfire::SerializablePtr nativeptr);
+        static double getDouble(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableDouble(double val);
+        static apache::geode::client::CacheableKeyPtr getCacheableDouble(double val);
         
         //float
-        static float getFloat(gemfire::SerializablePtr nativeptr);
+        static float getFloat(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableFloat(float val);
+        static apache::geode::client::CacheableKeyPtr getCacheableFloat(float val);
         
         //int16
-        static int16 getInt16(gemfire::SerializablePtr nativeptr);
+        static int16 getInt16(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableInt16(int val);
+        static apache::geode::client::CacheableKeyPtr getCacheableInt16(int val);
         
         //int32
-        static int32 getInt32(gemfire::SerializablePtr nativeptr);
+        static int32 getInt32(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableInt32(int32 val);
+        static apache::geode::client::CacheableKeyPtr getCacheableInt32(int32 val);
         
         //int64
-        static int64 getInt64(gemfire::SerializablePtr nativeptr);
+        static int64 getInt64(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableInt64(int64 val);
+        static apache::geode::client::CacheableKeyPtr getCacheableInt64(int64 val);
         
         //cacheable ascii string
-        static String^ getASCIIString(gemfire::SerializablePtr nativeptr);        
+        static String^ getASCIIString(apache::geode::client::SerializablePtr nativeptr);        
 
-        static gemfire::CacheableKeyPtr getCacheableASCIIString(String^ val);
+        static apache::geode::client::CacheableKeyPtr getCacheableASCIIString(String^ val);
 
-        static gemfire::CacheableKeyPtr getCacheableASCIIString2(String^ val);
+        static apache::geode::client::CacheableKeyPtr getCacheableASCIIString2(String^ val);
         
         //cacheable ascii string huge
-        static String^ getASCIIStringHuge(gemfire::SerializablePtr nativeptr);
+        static String^ getASCIIStringHuge(apache::geode::client::SerializablePtr nativeptr);
         
-        static gemfire::CacheableKeyPtr getCacheableASCIIStringHuge(String^ val);        
+        static apache::geode::client::CacheableKeyPtr getCacheableASCIIStringHuge(String^ val);        
 
         //cacheable string
-        static String^ getUTFString(gemfire::SerializablePtr nativeptr);        
+        static String^ getUTFString(apache::geode::client::SerializablePtr nativeptr);        
 
-        static gemfire::CacheableKeyPtr getCacheableUTFString(String^ val);
+        static apache::geode::client::CacheableKeyPtr getCacheableUTFString(String^ val);
         
 
         //cacheable string huge
-        static String^ getUTFStringHuge(gemfire::SerializablePtr nativeptr);
+        static String^ getUTFStringHuge(apache::geode::client::SerializablePtr nativeptr);
         
 
-        static gemfire::CacheableKeyPtr getCacheableUTFStringHuge(String^ val);
+        static apache::geode::client::CacheableKeyPtr getCacheableUTFStringHuge(String^ val);
         
 
-       static gemfire::CacheableStringPtr GetCacheableString(String^ value);       
+       static apache::geode::client::CacheableStringPtr GetCacheableString(String^ value);       
 
-       static gemfire::CacheableStringPtr GetCacheableString2(String^ value); 
+       static apache::geode::client::CacheableStringPtr GetCacheableString2(String^ value); 
 
        /*
-        static String^ GetString(gemfire::CacheableStringPtr cStr)//gemfire::CacheableString*
+        static String^ GetString(apache::geode::client::CacheableStringPtr cStr)//apache::geode::client::CacheableString*
         {
           if (cStr == NULLPTR) {
             return nullptr;
@@ -416,14 +416,14 @@ namespace GemStone
         /// Default constructor.
         /// </summary>
         inline GemStone::GemFire::Cache::Generic::Serializable()
-          : GemStone::GemFire::Cache::Generic::Internal::SBWrap<gemfire::Serializable>() { }
+          : GemStone::GemFire::Cache::Generic::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 GemStone::GemFire::Cache::Generic::Serializable(gemfire::Serializable* nativeptr)
-          : Generic::Internal::SBWrap<gemfire::Serializable>(nativeptr) { }
+        inline GemStone::GemFire::Cache::Generic::Serializable(apache::geode::client::Serializable* nativeptr)
+          : Generic::Internal::SBWrap<apache::geode::client::Serializable>(nativeptr) { }
 
         /// <summary>
         /// Register an instance factory method for a given type and typeId.
@@ -447,20 +447,20 @@ namespace GemStone
         static void UnregisterTypeGeneric(Byte typeId);
 
         generic<class TValue>
-        static TValue GetManagedValueGeneric(gemfire::SerializablePtr val);
+        static TValue GetManagedValueGeneric(apache::geode::client::SerializablePtr val);
 
         generic<class TKey>
-        static gemfire::CacheableKeyPtr GetUnmanagedValueGeneric(TKey key);
+        static apache::geode::client::CacheableKeyPtr GetUnmanagedValueGeneric(TKey key);
 
         generic<class TKey>
-        static gemfire::CacheableKeyPtr GetUnmanagedValueGeneric(TKey key, bool isAciiChar);
+        static apache::geode::client::CacheableKeyPtr GetUnmanagedValueGeneric(TKey key, bool isAciiChar);
 
         generic<class TKey>
-        static gemfire::CacheableKeyPtr GetUnmanagedValueGeneric(
+        static apache::geode::client::CacheableKeyPtr GetUnmanagedValueGeneric(
           Type^ managedType, TKey key);
 
         generic<class TKey>
-        static gemfire::CacheableKeyPtr GetUnmanagedValueGeneric(
+        static apache::geode::client::CacheableKeyPtr GetUnmanagedValueGeneric(
           Type^ managedType, TKey key, bool isAsciiChar);
 
         /// <summary>
@@ -484,7 +484,7 @@ namespace GemStone
         /// Note the order of preserveSB() and releaseSB(). This handles the
         /// corner case when <c>m_nativeptr</c> is same as <c>nativeptr</c>.
         /// </remarks>
-        inline void AssignSP(gemfire::Serializable* nativeptr)
+        inline void AssignSP(apache::geode::client::Serializable* nativeptr)
         {
           AssignPtr(nativeptr);
         }
@@ -492,7 +492,7 @@ namespace GemStone
         /// <summary>
         /// Used to assign the native Serializable pointer to a new object.
         /// </summary>
-        inline void SetSP(gemfire::Serializable* nativeptr)
+        inline void SetSP(apache::geode::client::Serializable* nativeptr)
         {
           if (nativeptr != nullptr) {
             nativeptr->preserveSB();
@@ -609,7 +609,7 @@ namespace GemStone
 
         /// <summary>
         /// Static method to register a managed wrapper for a native
-        /// <c>gemfire::Serializable</c> type.
+        /// <c>apache::geode::client::Serializable</c> type.
         /// </summary>
         /// <param name="wrapperMethod">
         /// A factory delegate of the managed wrapper class that returns the
@@ -631,7 +631,7 @@ namespace GemStone
         /// Static method to lookup the wrapper delegate for a given typeId.
         /// </summary>
         /// <param name="typeId">
-        /// The typeId of the native <c>gemfire::Serializable</c> type.
+        /// The typeId of the native <c>apache::geode::client::Serializable</c> type.
         /// </param>
         /// <returns>
         /// If a managed wrapper is registered for the given typeId then the
@@ -652,53 +652,53 @@ namespace GemStone
 
           {
           Dictionary<Object^, Object^>^ dic = gcnew Dictionary<Object^, Object^>();
-          ManagedTypeMappingGeneric[dic->GetType()] = gemfire::GemfireTypeIds::CacheableHashMap;
-          ManagedTypeMappingGeneric[dic->GetType()->GetGenericTypeDefinition()] = gemfire::GemfireTypeIds::CacheableHashMap;
+          ManagedTypeMappingGeneric[dic->GetType()] = apache::geode::client::GemfireTypeIds::CacheableHashMap;
+          ManagedTypeMappingGeneric[dic->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableHashMap;
           }
 
           {
           System::Collections::ArrayList^ arr = gcnew System::Collections::ArrayList();
-          ManagedTypeMappingGeneric[arr->GetType()] = gemfire::GemfireTypeIds::CacheableVector;
+          ManagedTypeMappingGeneric[arr->GetType()] = apache::geode::client::GemfireTypeIds::CacheableVector;
           }
 		  
           {
           System::Collections::Generic::LinkedList<Object^>^ linketList = gcnew  System::Collections::Generic::LinkedList<Object^>();
-          ManagedTypeMappingGeneric[linketList->GetType()] = gemfire::GemfireTypeIds::CacheableLinkedList;
-          ManagedTypeMappingGeneric[linketList->GetType()->GetGenericTypeDefinition()] = gemfire::GemfireTypeIds::CacheableLinkedList;
+          ManagedTypeMappingGeneric[linketList->GetType()] = apache::geode::client::GemfireTypeIds::CacheableLinkedList;
+          ManagedTypeMappingGeneric[linketList->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableLinkedList;
           }
 		  
           {
           System::Collections::Generic::IList<Object^>^ iList = gcnew System::Collections::Generic::List<Object^>();
-          ManagedTypeMappingGeneric[iList->GetType()] = gemfire::GemfireTypeIds::CacheableArrayList;
-          ManagedTypeMappingGeneric[iList->GetType()->GetGenericTypeDefinition()] = gemfire::GemfireTypeIds::CacheableArrayList;
+          ManagedTypeMappingGeneric[iList->GetType()] = apache::geode::client::GemfireTypeIds::CacheableArrayList;
+          ManagedTypeMappingGeneric[iList->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableArrayList;
           }
 
           //TODO: Linked list, non generic stack, some other map types and see if more
 
           {
             System::Collections::Generic::Stack<Object^>^ stack = gcnew System::Collections::Generic::Stack<Object^>();
-            ManagedTypeMappingGeneric[stack->GetType()] = gemfire::GemfireTypeIds::CacheableStack;
-            ManagedTypeMappingGeneric[stack->GetType()->GetGenericTypeDefinition()] = gemfire::GemfireTypeIds::CacheableStack;
+            ManagedTypeMappingGeneric[stack->GetType()] = apache::geode::client::GemfireTypeIds::CacheableStack;
+            ManagedTypeMappingGeneric[stack->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableStack;
           }
           {
-            ManagedTypeMappingGeneric[SByte::typeid] = gemfire::GemfireTypeIds::CacheableByte;
-            ManagedTypeMappingGeneric[Boolean::typeid] = gemfire::GemfireTypeIds::CacheableBoolean;
-            ManagedTypeMappingGeneric[Char::typeid] = gemfire::GemfireTypeIds::CacheableWideChar;
-            ManagedTypeMappingGeneric[Double::typeid] = gemfire::GemfireTypeIds::CacheableDouble;
-            ManagedTypeMappingGeneric[String::typeid] = gemfire::GemfireTypeIds::CacheableASCIIString;
-            ManagedTypeMappingGeneric[float::typeid] = gemfire::GemfireTypeIds::CacheableFloat;
-            ManagedTypeMappingGeneric[Int16::typeid] = gemfire::GemfireTypeIds::CacheableInt16;
-            ManagedTypeMappingGeneric[Int32::typeid] = gemfire::GemfireTypeIds::CacheableInt32;
-            ManagedTypeMappingGeneric[Int64::typeid] = gemfire::GemfireTypeIds::CacheableInt64;
-            ManagedTypeMappingGeneric[Type::GetType("System.Byte[]")] = gemfire::GemfireTypeIds::CacheableBytes;
-            ManagedTypeMappingGeneric[Type::GetType("System.Double[]")] = gemfire::GemfireTypeIds::CacheableDoubleArray;
-            ManagedTypeMappingGeneric[Type::GetType("System.Single[]")] = gemfire::GemfireTypeIds::CacheableFloatArray;
-            ManagedTypeMappingGeneric[Type::GetType("System.Int16[]")] = gemfire::GemfireTypeIds::CacheableInt16Array;
-            ManagedTypeMappingGeneric[Type::GetType("System.Int32[]")] = gemfire::GemfireTypeIds::CacheableInt32Array;
-            ManagedTypeMappingGeneric[Type::GetType("System.Int64[]")] = gemfire::GemfireTypeIds::CacheableInt64Array;
-            ManagedTypeMappingGeneric[Type::GetType("System.String[]")] = gemfire::GemfireTypeIds::CacheableStringArray;
-            ManagedTypeMappingGeneric[Type::GetType("System.DateTime")] = gemfire::GemfireTypeIds::CacheableDate;
-            ManagedTypeMappingGeneric[Type::GetType("System.Collections.Hashtable")] = gemfire::GemfireTypeIds::CacheableHashTable;
+            ManagedTypeMappingGeneric[SByte::typeid] = apache::geode::client::GemfireTypeIds::CacheableByte;
+            ManagedTypeMappingGeneric[Boolean::typeid] = apache::geode::client::GemfireTypeIds::CacheableBoolean;
+            ManagedTypeMappingGeneric[Char::typeid] = apache::geode::client::GemfireTypeIds::CacheableWideChar;
+            ManagedTypeMappingGeneric[Double::typeid] = apache::geode::client::GemfireTypeIds::CacheableDouble;
+            ManagedTypeMappingGeneric[String::typeid] = apache::geode::client::GemfireTypeIds::CacheableASCIIString;
+            ManagedTypeMappingGeneric[float::typeid] = apache::geode::client::GemfireTypeIds::CacheableFloat;
+            ManagedTypeMappingGeneric[Int16::typeid] = apache::geode::client::GemfireTypeIds::CacheableInt16;
+            ManagedTypeMappingGeneric[Int32::typeid] = apache::geode::client::GemfireTypeIds::CacheableInt32;
+            ManagedTypeMappingGeneric[Int64::typeid] = apache::geode::client::GemfireTypeIds::CacheableInt64;
+            ManagedTypeMappingGeneric[Type::GetType("System.Byte[]")] = apache::geode::client::GemfireTypeIds::CacheableBytes;
+            ManagedTypeMappingGeneric[Type::GetType("System.Double[]")] = apache::geode::client::GemfireTypeIds::CacheableDoubleArray;
+            ManagedTypeMappingGeneric[Type::GetType("System.Single[]")] = apache::geode::client::GemfireTypeIds::CacheableFloatArray;
+            ManagedTypeMappingGeneric[Type::GetType("System.Int16[]")] = apache::geode::client::GemfireTypeIds::CacheableInt16Array;
+            ManagedTypeMappingGeneric[Type::GetType("System.Int32[]")] = apache::geode::client::GemfireTypeIds::CacheableInt32Array;
+            ManagedTypeMappingGeneric[Type::GetType("System.Int64[]")] = apache::geode::client::GemfireTypeIds::CacheableInt64Array;
+            ManagedTypeMappingGeneric[Type::GetType("System.String[]")] = apache::geode::client::GemfireTypeIds::CacheableStringArray;
+            ManagedTypeMappingGeneric[Type::GetType("System.DateTime")] = apache::geode::client::GemfireTypeIds::CacheableDate;
+            ManagedTypeMappingGeneric[Type::GetType("System.Collections.Hashtable")] = apache::geode::client::GemfireTypeIds::CacheableHashTable;
           }
         }
       };

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Struct.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Struct.cpp b/src/clicache/src/Struct.cpp
index e3a9bb1..6475488 100644
--- a/src/clicache/src/Struct.cpp
+++ b/src/clicache/src/Struct.cpp
@@ -32,44 +32,44 @@ namespace GemStone
     {
       Object^ Struct::default::get( size_t index )
       {
-       /*   return SafeUMSerializableConvertGeneric(static_cast<gemfire::Struct*>(
+       /*   return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
             NativePtr())->operator[](static_cast<int32_t>(index)).ptr());*/
-          return (Serializable::GetManagedValueGeneric<Object^>(static_cast<gemfire::Struct*>(
+          return (Serializable::GetManagedValueGeneric<Object^>(static_cast<apache::geode::client::Struct*>(
             NativePtr())->operator[](static_cast<int32_t>(index))));
       }
 
       Object^ Struct::default::get( String^ fieldName )
       {
         ManagedString mg_fieldName( fieldName );
-        /*return SafeUMSerializableConvertGeneric(static_cast<gemfire::Struct*>(
+        /*return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
             NativePtr())->operator[](mg_fieldName.CharPtr).ptr());*/
 
-        return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<gemfire::Struct*>(
+        return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<apache::geode::client::Struct*>(
             NativePtr())->operator[](mg_fieldName.CharPtr)));
       }
 
       StructSet<Object^>^ Struct::Set::get( )
       {
-        return StructSet</*TResult*/Object^>::Create(static_cast<gemfire::Struct*>(
+        return StructSet</*TResult*/Object^>::Create(static_cast<apache::geode::client::Struct*>(
           NativePtr())->getStructSet().ptr());
       }
 
       
       bool Struct/*<TResult>*/::HasNext( )
       {
-        return static_cast<gemfire::Struct*>(NativePtr())->hasNext();
+        return static_cast<apache::geode::client::Struct*>(NativePtr())->hasNext();
       }
 
       size_t Struct/*<TResult>*/::Length::get( )
       {
-        return static_cast<gemfire::Struct*>(NativePtr())->length();
+        return static_cast<apache::geode::client::Struct*>(NativePtr())->length();
       }
 
       Object^ Struct/*<TResult>*/::Next( )
       {
-        /*return SafeUMSerializableConvertGeneric(static_cast<gemfire::Struct*>(
+        /*return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
           NativePtr())->next().ptr());*/
-        return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<gemfire::Struct*>(
+        return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<apache::geode::client::Struct*>(
           NativePtr())->next()));
       }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Struct.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Struct.hpp b/src/clicache/src/Struct.hpp
index 84d8684..3a2614d 100644
--- a/src/clicache/src/Struct.hpp
+++ b/src/clicache/src/Struct.hpp
@@ -114,18 +114,18 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline GemStone::GemFire::Cache::Generic::Struct/*<TResult>*/( ::gemfire::Serializable* nativeptr )
+        inline GemStone::GemFire::Cache::Generic::Struct/*<TResult>*/( ::apache::geode::client::Serializable* nativeptr )
           : GemStone::GemFire::Cache::Generic::Serializable( nativeptr ) { }
 
         inline GemStone::GemFire::Cache::Generic::Struct/*<TResult>*/(  )
-          : GemStone::GemFire::Cache::Generic::Serializable( ::gemfire::Struct::createDeserializable()) { }
+          : GemStone::GemFire::Cache::Generic::Serializable( ::apache::geode::client::Struct::createDeserializable()) { }
 
       internal:
 
         /// <summary>
         /// Factory function to register wrapper
         /// </summary>
-        inline static GemStone::GemFire::Cache::Generic::IGFSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::gemfire::Serializable* obj )
+        inline static GemStone::GemFire::Cache::Generic::IGFSerializable^ /*Struct^*/ /*<TResult>*/ Create( ::apache::geode::client::Serializable* obj )
         {
           return ( obj != nullptr ?
             gcnew GemStone::GemFire::Cache::Generic::Struct/*<TResult>*/( obj ) : nullptr );

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

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

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/SystemProperties.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SystemProperties.cpp b/src/clicache/src/SystemProperties.cpp
index 838d20f..3b961f4 100644
--- a/src/clicache/src/SystemProperties.cpp
+++ b/src/clicache/src/SystemProperties.cpp
@@ -33,8 +33,8 @@ namespace GemStone
       {
         _GF_MG_EXCEPTION_TRY2
 
-          SetPtr(new gemfire::SystemProperties(gemfire::PropertiesPtr(
-            GetNativePtr<gemfire::Properties>(properties))), true);
+          SetPtr(new apache::geode::client::SystemProperties(apache::geode::client::PropertiesPtr(
+            GetNativePtr<apache::geode::client::Properties>(properties))), true);
 
         _GF_MG_EXCEPTION_CATCH_ALL2
       }
@@ -45,9 +45,9 @@ namespace GemStone
         _GF_MG_EXCEPTION_TRY2
 
           ManagedString mg_configFile( configFile );
-          gemfire::PropertiesPtr propertiesptr(
-            GetNativePtr<gemfire::Properties>( properties ) );
-          SetPtr( new gemfire::SystemProperties( propertiesptr,
+          apache::geode::client::PropertiesPtr propertiesptr(
+            GetNativePtr<apache::geode::client::Properties>( properties ) );
+          SetPtr( new apache::geode::client::SystemProperties( propertiesptr,
             mg_configFile.CharPtr ), true );
 
         _GF_MG_EXCEPTION_CATCH_ALL2

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/SystemProperties.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SystemProperties.hpp b/src/clicache/src/SystemProperties.hpp
index cda50b5..baa9ef6 100644
--- a/src/clicache/src/SystemProperties.hpp
+++ b/src/clicache/src/SystemProperties.hpp
@@ -39,7 +39,7 @@ namespace GemStone
       /// or a gfcpp.properties file.
       /// </summary>
       public ref class SystemProperties sealed
-        : public Internal::UMWrap<gemfire::SystemProperties>
+        : public Internal::UMWrap<apache::geode::client::SystemProperties>
       {
       public:
 
@@ -424,7 +424,7 @@ namespace GemStone
         /// the managed wrapper object, or null if the native pointer is null.
         /// </returns>
         inline static SystemProperties^ Create(
-          gemfire::SystemProperties* nativeptr )
+          apache::geode::client::SystemProperties* nativeptr )
         {
           return ( nativeptr != nullptr ?
             gcnew SystemProperties( nativeptr ) : nullptr );
@@ -437,7 +437,7 @@ namespace GemStone
         /// Private constructor to wrap a native object pointer
         /// </summary>
         /// <param name="nativeptr">The native object pointer</param>
-        inline SystemProperties( gemfire::SystemProperties* nativeptr )
+        inline SystemProperties( apache::geode::client::SystemProperties* nativeptr )
           : UMWrap( nativeptr, false ) { }
       };
       } // end namespace Generic

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/TransactionEvent.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionEvent.cpp b/src/clicache/src/TransactionEvent.cpp
index f0758e2..473de93 100644
--- a/src/clicache/src/TransactionEvent.cpp
+++ b/src/clicache/src/TransactionEvent.cpp
@@ -38,7 +38,7 @@ namespace GemStone
       generic<class TKey, class TValue>
       Cache^ TransactionEvent<TKey, TValue>::Cache::get( )
       {
-        gemfire::CachePtr & nativeptr(
+        apache::geode::client::CachePtr & nativeptr(
           NativePtr->getCache( ) );
 
 				return GemStone::GemFire::Cache::Generic::Cache::Create(
@@ -48,7 +48,7 @@ namespace GemStone
       generic<class TKey, class TValue>
 			GemStone::GemFire::Cache::Generic::TransactionId^ TransactionEvent<TKey, TValue>::TransactionId::get( )
       {
-        gemfire::TransactionIdPtr & nativeptr(
+        apache::geode::client::TransactionIdPtr & nativeptr(
           NativePtr->getTransactionId( ) );
 
 				return GemStone::GemFire::Cache::Generic::TransactionId::Create(
@@ -58,14 +58,14 @@ namespace GemStone
       generic<class TKey, class TValue>
       array<EntryEvent<TKey, TValue>^>^ TransactionEvent<TKey, TValue>::Events::get( )
       {
-        gemfire::VectorOfEntryEvent vee;
+        apache::geode::client::VectorOfEntryEvent vee;
         vee = NativePtr->getEvents();
         array<EntryEvent<TKey, TValue>^>^ events =
           gcnew array<EntryEvent<TKey, TValue>^>( vee.size( ) );
         // Loop through the unmanaged event objects to convert them to the managed generic objects. 
         for( int32_t index = 0; index < vee.size( ); index++ )
         {
-          gemfire::EntryEventPtr& nativeptr( vee[ index ] );
+          apache::geode::client::EntryEventPtr& nativeptr( vee[ index ] );
           EntryEvent<TKey, TValue> entryEvent( nativeptr.ptr( ) );
           events[ index ] = (%entryEvent);
         }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/TransactionEvent.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/TransactionEvent.hpp b/src/clicache/src/TransactionEvent.hpp
index c254c5c..7bdc977 100644
--- a/src/clicache/src/TransactionEvent.hpp
+++ b/src/clicache/src/TransactionEvent.hpp
@@ -55,7 +55,7 @@ namespace GemStone
         /// </summary>
         generic<class TKey, class TValue>
           public ref class TransactionEvent sealed
-            : public Internal::UMWrap<gemfire::TransactionEvent>
+            : public Internal::UMWrap<apache::geode::client::TransactionEvent>
           {
           public:
             /// <summary>
@@ -89,7 +89,7 @@ namespace GemStone
             /// Internal constructor to wrap a native object pointer
             /// </summary>
             /// <param name="nativeptr">The native object pointer</param>
-            inline TransactionEvent( gemfire::TransactionEvent* nativeptr )
+            inline TransactionEvent( apache::geode::client::TransactionEvent* nativeptr )
               : UMWrap( nativeptr, false ) { }
           };
 


Mime
View raw message