geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [2/4] geode git commit: GEODE-2342: Rename GemfireTypeIds class to GeodeTypeIds to match corresponding file name change. Note, this was missed in the intitial commit.
Date Mon, 30 Jan 2017 18:11:25 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/Serializable.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.cpp b/src/clicache/src/Serializable.cpp
index a32792d..fc68cea 100644
--- a/src/clicache/src/Serializable.cpp
+++ b/src/clicache/src/Serializable.cpp
@@ -102,9 +102,9 @@ namespace Apache
       uint32_t Apache::Geode::Client::Serializable::ClassId::get()
       {
         int8_t typeId = NativePtr->typeId();
-        if (typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData ||
-             typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData2 ||
-             typeId == apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4) {
+        if (typeId == apache::geode::client::GeodeTypeIdsImpl::CacheableUserData ||
+             typeId == apache::geode::client::GeodeTypeIdsImpl::CacheableUserData2 ||
+             typeId == apache::geode::client::GeodeTypeIdsImpl::CacheableUserData4) {
           return NativePtr->classId();
         } else {
           return typeId + 0x80000000 + (0x20000000 * NativePtr->DSFID());
@@ -474,12 +474,12 @@ namespace Apache
       {
 				if(!appDomainEnable)
 				{
-					apache::geode::client::SerializationRegistry::addType(apache::geode::client::GemfireTypeIdsImpl::PDX,
+					apache::geode::client::SerializationRegistry::addType(apache::geode::client::GeodeTypeIdsImpl::PDX,
 						&apache::geode::client::PdxManagedCacheableKey::CreateDeserializable );
 				}
 				else
 				{
-					apache::geode::client::SerializationRegistry::addType(apache::geode::client::GemfireTypeIdsImpl::PDX,
+					apache::geode::client::SerializationRegistry::addType(apache::geode::client::GeodeTypeIdsImpl::PDX,
 						&apache::geode::client::PdxManagedCacheableKeyBytes::CreateDeserializable );
 				}
       }
@@ -615,7 +615,7 @@ namespace Apache
 				 //Log::Debug("Serializable::GetManagedValueGeneric typeid = " + typeId);
         switch(typeId)
         {
-        case apache::geode::client::GemfireTypeIds::CacheableByte:
+        case apache::geode::client::GeodeTypeIds::CacheableByte:
           {
 						return (TValue)(int8_t)safe_cast<int8_t>(Serializable::getByte(val));
            /* if (TValue::typeid == System::SByte::typeid) {
@@ -626,31 +626,31 @@ namespace Apache
             }
             return safe_cast<TValue>(Serializable::getByte(val));*/
           }
-        case apache::geode::client::GemfireTypeIds::CacheableBoolean:
+        case apache::geode::client::GeodeTypeIds::CacheableBoolean:
           {
             return safe_cast<TValue>(Serializable::getBoolean(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableWideChar:
+        case apache::geode::client::GeodeTypeIds::CacheableWideChar:
           {
             return safe_cast<TValue>(Serializable::getChar(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableDouble:
+        case apache::geode::client::GeodeTypeIds::CacheableDouble:
           {
             return safe_cast<TValue>(Serializable::getDouble(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableASCIIString:
-        case apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge:
-        case apache::geode::client::GemfireTypeIds::CacheableString:
-        case apache::geode::client::GemfireTypeIds::CacheableStringHuge:
+        case apache::geode::client::GeodeTypeIds::CacheableASCIIString:
+        case apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge:
+        case apache::geode::client::GeodeTypeIds::CacheableString:
+        case apache::geode::client::GeodeTypeIds::CacheableStringHuge:
           {
             //TODO: need to look all strings types
             return safe_cast<TValue>(Serializable::getASCIIString(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableFloat:
+        case apache::geode::client::GeodeTypeIds::CacheableFloat:
           {
             return safe_cast<TValue>(Serializable::getFloat(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableInt16:
+        case apache::geode::client::GeodeTypeIds::CacheableInt16:
           {
            /* if (TValue::typeid == System::Int16::typeid) {
               return (TValue)(int16_t)safe_cast<int16_t>(Serializable::getInt16(val));              
@@ -660,7 +660,7 @@ namespace Apache
             }*/
             return safe_cast<TValue>(Serializable::getInt16(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableInt32:
+        case apache::geode::client::GeodeTypeIds::CacheableInt32:
           {  
            /* if (TValue::typeid == System::Int32::typeid) {
               return (TValue)(int32_t)safe_cast<int32_t>(Serializable::getInt32(val));              
@@ -670,7 +670,7 @@ namespace Apache
             }  */          
             return safe_cast<TValue>(Serializable::getInt32(val));
           }
-        case apache::geode::client::GemfireTypeIds::CacheableInt64:
+        case apache::geode::client::GeodeTypeIds::CacheableInt64:
           {
             /*if (TValue::typeid == System::Int64::typeid) {
               return (TValue)(int64_t)safe_cast<int64_t>(Serializable::getInt64(val));              
@@ -680,7 +680,7 @@ namespace Apache
             }*/
             return safe_cast<TValue>(Serializable::getInt64(val));
           }
-					case apache::geode::client::GemfireTypeIds::CacheableDate:
+					case apache::geode::client::GeodeTypeIds::CacheableDate:
           {
 						//TODO::
             Apache::Geode::Client::CacheableDate^ ret = static_cast<Apache::Geode::Client::CacheableDate ^>
@@ -689,16 +689,16 @@ namespace Apache
             System::DateTime dt(ret->Value.Ticks);
             return safe_cast<TValue>(dt);
           }
-        case apache::geode::client::GemfireTypeIdsImpl::CacheableUserData:
-        case apache::geode::client::GemfireTypeIdsImpl::CacheableUserData2:
-        case apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4:
+        case apache::geode::client::GeodeTypeIdsImpl::CacheableUserData:
+        case apache::geode::client::GeodeTypeIdsImpl::CacheableUserData2:
+        case apache::geode::client::GeodeTypeIdsImpl::CacheableUserData4:
           {
 						//TODO::split 
             IGFSerializable^ ret = SafeUMSerializableConvertGeneric(val.ptr());
             return safe_cast<TValue>(ret);
 						//return TValue();
           }
-        case apache::geode::client::GemfireTypeIdsImpl::PDX:
+        case apache::geode::client::GeodeTypeIdsImpl::PDX:
           {
             IPdxSerializable^ ret = SafeUMSerializablePDXConvert(val.ptr());
 
@@ -711,49 +711,49 @@ namespace Apache
 
             return safe_cast<TValue>(ret);
           }
-        case apache::geode::client::GemfireTypeIds::CacheableBytes:
+        case apache::geode::client::GeodeTypeIds::CacheableBytes:
           {
             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:
+        case apache::geode::client::GeodeTypeIds::CacheableDoubleArray:
           {
             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:
+        case apache::geode::client::GeodeTypeIds::CacheableFloatArray:
           {
             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:
+        case apache::geode::client::GeodeTypeIds::CacheableInt16Array:
           {
             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:
+        case apache::geode::client::GeodeTypeIds::CacheableInt32Array:
           {
             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:
+        case apache::geode::client::GeodeTypeIds::CacheableInt64Array:
           {
 						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:
+        case apache::geode::client::GeodeTypeIds::CacheableStringArray:
           {
             Apache::Geode::Client::CacheableStringArray^ ret = safe_cast<Apache::Geode::Client::CacheableStringArray^>
               ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStringArray^>(val.ptr()));
@@ -765,81 +765,81 @@ namespace Apache
 
             return safe_cast<TValue>(ret->GetValues());
           }
-        case apache::geode::client::GemfireTypeIds::CacheableArrayList://Ilist generic
+        case apache::geode::client::GeodeTypeIds::CacheableArrayList://Ilist generic
           {
             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
+        case apache::geode::client::GeodeTypeIds::CacheableLinkedList://LinkedList generic
           {
             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
+        case apache::geode::client::GeodeTypeIds::CacheableHashTable://collection::hashtable
           {
             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
+        case apache::geode::client::GeodeTypeIds::CacheableHashMap://generic dictionary
           {
            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:
+				case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap:
           {
             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
+				 case apache::geode::client::GeodeTypeIds::CacheableHashSet://no need of it, default case should work
         {
           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
+        case apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
           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:
+				case apache::geode::client::GeodeTypeIds::CacheableFileName:
         {
           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:
+				 case apache::geode::client::GeodeTypeIds::CacheableObjectArray:
         {
           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
+				case apache::geode::client::GeodeTypeIds::CacheableVector://collection::arraylist
         {
           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:
+				case apache::geode::client::GeodeTypeIds::CacheableUndefined:
         {
           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:
+        case apache::geode::client::GeodeTypeIds::Struct:
         {
           return safe_cast<TValue>(Apache::Geode::Client::Struct::Create(val.ptr()));
         }
-				case apache::geode::client::GemfireTypeIds::CacheableStack:
+				case apache::geode::client::GeodeTypeIds::CacheableStack:
         {
           Apache::Geode::Client::CacheableStack^ ret = static_cast<Apache::Geode::Client::CacheableStack^>
 						( SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStack^>(val.ptr()));
@@ -858,7 +858,7 @@ namespace Apache
           return safe_cast<TValue>(ret);
         }
           /*  TODO: replace with IDictionary<K, V>
-        case apache::geode::client::GemfireTypeIds::Properties:
+        case apache::geode::client::GeodeTypeIds::Properties:
           {
             Apache::Geode::Client::Properties^ ret = safe_cast<Apache::Geode::Client::Properties^>
               ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Properties^>(val.ptr()));
@@ -866,14 +866,14 @@ namespace Apache
             return safe_cast<TValue>(ret);
           }*/
        
-        case apache::geode::client::GemfireTypeIds::BooleanArray:
+        case apache::geode::client::GeodeTypeIds::BooleanArray:
           {
 						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:
+        case apache::geode::client::GeodeTypeIds::CharArray:
           {
 						Apache::Geode::Client::CharArray^ ret = safe_cast<Apache::Geode::Client::CharArray^>
               ( SafeGenericUMSerializableConvert<Apache::Geode::Client::CharArray^>(val.ptr()));
@@ -1045,7 +1045,7 @@ namespace Apache
 
         switch(typeId)
         {
-        case apache::geode::client::GemfireTypeIds::CacheableByte: {
+        case apache::geode::client::GeodeTypeIds::CacheableByte: {
 					return Serializable::getCacheableByte((SByte)key);
          /* if( managedType == System::SByte::typeid )
           {
@@ -1056,21 +1056,21 @@ namespace Apache
             return Serializable::getCacheableByte((Byte)key);
           }*/
         }
-        case apache::geode::client::GemfireTypeIds::CacheableBoolean:
+        case apache::geode::client::GeodeTypeIds::CacheableBoolean:
           return Serializable::getCacheableBoolean((bool)key);
-        case apache::geode::client::GemfireTypeIds::CacheableWideChar:
+        case apache::geode::client::GeodeTypeIds::CacheableWideChar:
           return Serializable::getCacheableWideChar((Char)key);
-        case apache::geode::client::GemfireTypeIds::CacheableDouble:
+        case apache::geode::client::GeodeTypeIds::CacheableDouble:
           return Serializable::getCacheableDouble((double)key);
-        case apache::geode::client::GemfireTypeIds::CacheableASCIIString: {
+        case apache::geode::client::GeodeTypeIds::CacheableASCIIString: {
           if (isAsciiChar)
             return Serializable::getCacheableASCIIString2((String^)key);
           else
             return Serializable::getCacheableASCIIString((String^)key);
                                                             }
-        case apache::geode::client::GemfireTypeIds::CacheableFloat:
+        case apache::geode::client::GeodeTypeIds::CacheableFloat:
           return Serializable::getCacheableFloat((float)key);
-        case apache::geode::client::GemfireTypeIds::CacheableInt16: {
+        case apache::geode::client::GeodeTypeIds::CacheableInt16: {
           /*if( managedType == System::Int16::typeid )
             {      
               return Serializable::getCacheableInt16((int16_t)key);
@@ -1081,7 +1081,7 @@ namespace Apache
             }*/
           return Serializable::getCacheableInt16((int16_t)key);
          }
-        case apache::geode::client::GemfireTypeIds::CacheableInt32: {
+        case apache::geode::client::GeodeTypeIds::CacheableInt32: {
           /* if( managedType == System::Int32::typeid )
             {      
               return Serializable::getCacheableInt32((int32_t)key);
@@ -1092,7 +1092,7 @@ namespace Apache
             }*/
 					 return Serializable::getCacheableInt32((int32_t)key);
          }
-        case apache::geode::client::GemfireTypeIds::CacheableInt64: {
+        case apache::geode::client::GeodeTypeIds::CacheableInt64: {
           /*if( managedType == System::Int64::typeid )
             {      
               return Serializable::getCacheableInt64((int64_t)key);
@@ -1103,7 +1103,7 @@ namespace Apache
             }*/
           return Serializable::getCacheableInt64((int64_t)key);
          }
-        case apache::geode::client::GemfireTypeIds::CacheableBytes:
+        case apache::geode::client::GeodeTypeIds::CacheableBytes:
           {
 						apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key)));
               return kPtr;
@@ -1116,17 +1116,17 @@ namespace Apache
               return kPtr;
             }*/
           }
-        case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
+        case apache::geode::client::GeodeTypeIds::CacheableDoubleArray:
           {
             apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableDoubleArray::Create((array<Double>^)key)));
             return kPtr;
           }
-        case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
+        case apache::geode::client::GeodeTypeIds::CacheableFloatArray:
         {
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableFloatArray::Create((array<float>^)key)));
            return kPtr;
         }
-        case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
+        case apache::geode::client::GeodeTypeIds::CacheableInt16Array:
         {
 					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key)));
             return kPtr;
@@ -1139,7 +1139,7 @@ namespace Apache
             return kPtr;
           }  */          
         }
-        case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
+        case apache::geode::client::GeodeTypeIds::CacheableInt32Array:
         {
 					 apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key)));
             return kPtr;
@@ -1152,7 +1152,7 @@ namespace Apache
             return kPtr;
           }       */   
         }
-        case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
+        case apache::geode::client::GeodeTypeIds::CacheableInt64Array:
         {
 					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key)));
             return kPtr;
@@ -1165,42 +1165,42 @@ namespace Apache
             return kPtr;
           }     */                  
         }
-        case apache::geode::client::GemfireTypeIds::CacheableStringArray:
+        case apache::geode::client::GeodeTypeIds::CacheableStringArray:
         {
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableStringArray::Create((array<String^>^)key)));
            return kPtr;
         }
-				case apache::geode::client::GemfireTypeIds::CacheableFileName:
+				case apache::geode::client::GeodeTypeIds::CacheableFileName:
         {
 					apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)(Apache::Geode::Client::CacheableFileName^)key));
           return kPtr;
         }
-        case apache::geode::client::GemfireTypeIds::CacheableHashTable://collection::hashtable
+        case apache::geode::client::GeodeTypeIds::CacheableHashTable://collection::hashtable
         {
           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
+        case apache::geode::client::GeodeTypeIds::CacheableHashMap://generic dictionary
         {
           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
+        case apache::geode::client::GeodeTypeIds::CacheableVector://collection::arraylist
         {
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)CacheableVector::Create((System::Collections::IList^)key)));
           return kPtr;
         }
-        case apache::geode::client::GemfireTypeIds::CacheableArrayList://generic ilist
+        case apache::geode::client::GeodeTypeIds::CacheableArrayList://generic ilist
         {
           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
+        case apache::geode::client::GeodeTypeIds::CacheableLinkedList://generic linked list
         {
           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:
+		case apache::geode::client::GeodeTypeIds::CacheableStack:
         {
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert(Apache::Geode::Client::CacheableStack::Create((System::Collections::ICollection^)key)));
           return kPtr;
@@ -1215,37 +1215,37 @@ namespace Apache
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectXml^)key));
           return kPtr;
         }
-				 case apache::geode::client::GemfireTypeIds::CacheableObjectArray:
+				 case apache::geode::client::GeodeTypeIds::CacheableObjectArray:
         {
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableObjectArray^)key));
           return kPtr;
         }
-			  case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
+			  case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap:
         {
           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
+        case apache::geode::client::GeodeTypeIds::CacheableHashSet://no need of it, default case should work
         {
           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
+        case apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet://no need of it, default case should work
         {
           apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((Apache::Geode::Client::CacheableLinkedHashSet^)key));
           return kPtr;
         }
-        case apache::geode::client::GemfireTypeIds::CacheableDate:
+        case apache::geode::client::GeodeTypeIds::CacheableDate:
           {
             apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CacheableDate::Create((System::DateTime)key)));
             return kPtr;
           }
-        case apache::geode::client::GemfireTypeIds::BooleanArray:
+        case apache::geode::client::GeodeTypeIds::BooleanArray:
           {   
 					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::BooleanArray::Create((array<bool>^)key)));
             return kPtr;
 					}
-        case apache::geode::client::GemfireTypeIds::CharArray:
+        case apache::geode::client::GeodeTypeIds::CharArray:
           {
 					  apache::geode::client::CacheablePtr kPtr(SafeGenericMSerializableConvert((IGFSerializable^)Apache::Geode::Client::CharArray::Create((array<Char>^)key)));
             return kPtr;

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/Serializable.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.hpp b/src/clicache/src/Serializable.hpp
index 5eaec44..778a439 100644
--- a/src/clicache/src/Serializable.hpp
+++ b/src/clicache/src/Serializable.hpp
@@ -651,53 +651,53 @@ namespace Apache
 
           {
           Dictionary<Object^, Object^>^ dic = gcnew Dictionary<Object^, Object^>();
-          ManagedTypeMappingGeneric[dic->GetType()] = apache::geode::client::GemfireTypeIds::CacheableHashMap;
-          ManagedTypeMappingGeneric[dic->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableHashMap;
+          ManagedTypeMappingGeneric[dic->GetType()] = apache::geode::client::GeodeTypeIds::CacheableHashMap;
+          ManagedTypeMappingGeneric[dic->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GeodeTypeIds::CacheableHashMap;
           }
 
           {
           System::Collections::ArrayList^ arr = gcnew System::Collections::ArrayList();
-          ManagedTypeMappingGeneric[arr->GetType()] = apache::geode::client::GemfireTypeIds::CacheableVector;
+          ManagedTypeMappingGeneric[arr->GetType()] = apache::geode::client::GeodeTypeIds::CacheableVector;
           }
 		  
           {
           System::Collections::Generic::LinkedList<Object^>^ linketList = gcnew  System::Collections::Generic::LinkedList<Object^>();
-          ManagedTypeMappingGeneric[linketList->GetType()] = apache::geode::client::GemfireTypeIds::CacheableLinkedList;
-          ManagedTypeMappingGeneric[linketList->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableLinkedList;
+          ManagedTypeMappingGeneric[linketList->GetType()] = apache::geode::client::GeodeTypeIds::CacheableLinkedList;
+          ManagedTypeMappingGeneric[linketList->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GeodeTypeIds::CacheableLinkedList;
           }
 		  
           {
           System::Collections::Generic::IList<Object^>^ iList = gcnew System::Collections::Generic::List<Object^>();
-          ManagedTypeMappingGeneric[iList->GetType()] = apache::geode::client::GemfireTypeIds::CacheableArrayList;
-          ManagedTypeMappingGeneric[iList->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableArrayList;
+          ManagedTypeMappingGeneric[iList->GetType()] = apache::geode::client::GeodeTypeIds::CacheableArrayList;
+          ManagedTypeMappingGeneric[iList->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GeodeTypeIds::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()] = apache::geode::client::GemfireTypeIds::CacheableStack;
-            ManagedTypeMappingGeneric[stack->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GemfireTypeIds::CacheableStack;
+            ManagedTypeMappingGeneric[stack->GetType()] = apache::geode::client::GeodeTypeIds::CacheableStack;
+            ManagedTypeMappingGeneric[stack->GetType()->GetGenericTypeDefinition()] = apache::geode::client::GeodeTypeIds::CacheableStack;
           }
           {
-            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;
+            ManagedTypeMappingGeneric[SByte::typeid] = apache::geode::client::GeodeTypeIds::CacheableByte;
+            ManagedTypeMappingGeneric[Boolean::typeid] = apache::geode::client::GeodeTypeIds::CacheableBoolean;
+            ManagedTypeMappingGeneric[Char::typeid] = apache::geode::client::GeodeTypeIds::CacheableWideChar;
+            ManagedTypeMappingGeneric[Double::typeid] = apache::geode::client::GeodeTypeIds::CacheableDouble;
+            ManagedTypeMappingGeneric[String::typeid] = apache::geode::client::GeodeTypeIds::CacheableASCIIString;
+            ManagedTypeMappingGeneric[float::typeid] = apache::geode::client::GeodeTypeIds::CacheableFloat;
+            ManagedTypeMappingGeneric[Int16::typeid] = apache::geode::client::GeodeTypeIds::CacheableInt16;
+            ManagedTypeMappingGeneric[Int32::typeid] = apache::geode::client::GeodeTypeIds::CacheableInt32;
+            ManagedTypeMappingGeneric[Int64::typeid] = apache::geode::client::GeodeTypeIds::CacheableInt64;
+            ManagedTypeMappingGeneric[Type::GetType("System.Byte[]")] = apache::geode::client::GeodeTypeIds::CacheableBytes;
+            ManagedTypeMappingGeneric[Type::GetType("System.Double[]")] = apache::geode::client::GeodeTypeIds::CacheableDoubleArray;
+            ManagedTypeMappingGeneric[Type::GetType("System.Single[]")] = apache::geode::client::GeodeTypeIds::CacheableFloatArray;
+            ManagedTypeMappingGeneric[Type::GetType("System.Int16[]")] = apache::geode::client::GeodeTypeIds::CacheableInt16Array;
+            ManagedTypeMappingGeneric[Type::GetType("System.Int32[]")] = apache::geode::client::GeodeTypeIds::CacheableInt32Array;
+            ManagedTypeMappingGeneric[Type::GetType("System.Int64[]")] = apache::geode::client::GeodeTypeIds::CacheableInt64Array;
+            ManagedTypeMappingGeneric[Type::GetType("System.String[]")] = apache::geode::client::GeodeTypeIds::CacheableStringArray;
+            ManagedTypeMappingGeneric[Type::GetType("System.DateTime")] = apache::geode::client::GeodeTypeIds::CacheableDate;
+            ManagedTypeMappingGeneric[Type::GetType("System.Collections.Hashtable")] = apache::geode::client::GeodeTypeIds::CacheableHashTable;
           }
         }
       };

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/ManagedCacheableDelta.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableDelta.cpp b/src/clicache/src/impl/ManagedCacheableDelta.cpp
index e8d563c..e15ae26 100644
--- a/src/clicache/src/impl/ManagedCacheableDelta.cpp
+++ b/src/clicache/src/impl/ManagedCacheableDelta.cpp
@@ -119,13 +119,13 @@ namespace apache
             return (int8_t)((classId - 0x80000000) % 0x20000000);
           }
           else if (classId <= 0x7F) {
-            return (int8_t)GemfireTypeIdsImpl::CacheableUserData;
+            return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
           }
           else if (classId <= 0x7FFF) {
-            return (int8_t)GemfireTypeIdsImpl::CacheableUserData2;
+            return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
           }
           else {
-            return (int8_t)GemfireTypeIdsImpl::CacheableUserData4;
+            return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
           }
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp b/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
index 64c9b95..d356521 100644
--- a/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
+++ b/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
@@ -115,13 +115,13 @@ namespace apache
             return (int8_t)((classId - 0x80000000) % 0x20000000);
           }
           else if (classId <= 0x7F) {
-            return (int8_t)GemfireTypeIdsImpl::CacheableUserData;
+            return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
           }
           else if (classId <= 0x7FFF) {
-            return (int8_t)GemfireTypeIdsImpl::CacheableUserData2;
+            return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
           }
           else {
-            return (int8_t)GemfireTypeIdsImpl::CacheableUserData4;
+            return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
           }
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/ManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableKey.cpp b/src/clicache/src/impl/ManagedCacheableKey.cpp
index 5bf418c..ae11bb1 100644
--- a/src/clicache/src/impl/ManagedCacheableKey.cpp
+++ b/src/clicache/src/impl/ManagedCacheableKey.cpp
@@ -122,13 +122,13 @@ namespace apache
         }
         else if (m_classId <= 0x7F) {
           //Apache::Geode::Client::Log::Debug("ManagedCacheableKeyGeneric::typeId inin"); 
-          return (int8_t)GemfireTypeIdsImpl::CacheableUserData;
+          return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
         }
         else if (m_classId <= 0x7FFF) {
-          return (int8_t)GemfireTypeIdsImpl::CacheableUserData2;
+          return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
         }
         else {
-          return (int8_t)GemfireTypeIdsImpl::CacheableUserData4;
+          return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp b/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
index afd9219..ec792db 100644
--- a/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
+++ b/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
@@ -121,13 +121,13 @@ namespace apache
             return (int8_t)((classId - 0x80000000) % 0x20000000);
           }
           else if (classId <= 0x7F) {
-            return (int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData;
+            return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData;
           }
           else if (classId <= 0x7FFF) {
-            return (int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData2;
+            return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData2;
           }
           else {
-            return (int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4;
+            return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData4;
           }
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/PdxFieldType.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxFieldType.cpp b/src/clicache/src/impl/PdxFieldType.cpp
index 790cd5b..083aa7a 100644
--- a/src/clicache/src/impl/PdxFieldType.cpp
+++ b/src/clicache/src/impl/PdxFieldType.cpp
@@ -167,7 +167,7 @@ namespace Apache
   
            case PdxTypes::SHORT:
            case PdxTypes::CHAR:
-            //case apache::geode::client::GemfireTypeIds::CacheableChar: //TODO
+            //case apache::geode::client::GeodeTypeIds::CacheableChar: //TODO
               return GemFireClassIds::CHAR_SIZE;
   
            case PdxTypes::INT:

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/PdxInstanceImpl.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.hpp b/src/clicache/src/impl/PdxInstanceImpl.hpp
index 2d4152e..41b71be 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.hpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.hpp
@@ -49,8 +49,8 @@ namespace Apache
          static array<SByte>^ Float_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
          static array<SByte>^ Double_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
          static array<SByte>^ Date_DefaultBytes = gcnew array<SByte>{-1, -1, -1, -1, -1, -1, -1, -1};
-         static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{apache::geode::client::GemfireTypeIds::CacheableNullString};
-         static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{apache::geode::client::GemfireTypeIds::NullObj};
+         static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::CacheableNullString};
+         static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::NullObj};
          static array<SByte>^ NULL_ARRAY_DefaultBytes = gcnew array<SByte>{-1};
 
          static PdxFieldType^ Default_PdxFieldType = gcnew PdxFieldType("default", "default", -1,

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/PdxManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKey.cpp b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
index 6349402..0512b89 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKey.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
@@ -114,15 +114,15 @@ namespace apache
           return (int8_t)((m_classId - 0x80000000) % 0x20000000);
           }
           else if (m_classId <= 0x7F) {
-          return (int8_t)GemfireTypeIdsImpl::CacheableUserData;
+          return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
           }
           else if (m_classId <= 0x7FFF) {
-          return (int8_t)GemfireTypeIdsImpl::CacheableUserData2;
+          return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
           }
           else {
-          return (int8_t)GemfireTypeIdsImpl::CacheableUserData4;
+          return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
           }*/
-        return (int8_t)GemfireTypeIdsImpl::PDX;
+        return (int8_t)GeodeTypeIdsImpl::PDX;
       }
 
       int8_t PdxManagedCacheableKey::DSFID() const

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
index 4990e17..112d92d 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
@@ -124,13 +124,13 @@ namespace apache
         //    return (int8_t)((classId - 0x80000000) % 0x20000000);
         //  }
         //  else if (classId <= 0x7F) {
-        //    return (int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData;
+        //    return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData;
         //  }
         //  else if (classId <= 0x7FFF) {
-        //    return (int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData2;
+        //    return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData2;
         //  }
         //  else {
-        //    return (int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4;
+        //    return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData4;
         //  }
         //}
         //catch (Apache::Geode::Client::GemFireException^ ex) {
@@ -139,7 +139,7 @@ namespace apache
         //catch (System::Exception^ ex) {
         //  Apache::Geode::Client::GemFireException::ThrowNative(ex);
         //}
-        return (int8_t)GemfireTypeIdsImpl::PDX;
+        return (int8_t)GeodeTypeIdsImpl::PDX;
       }
 
       int8_t PdxManagedCacheableKeyBytes::DSFID() const

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp b/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
index a9b9dca..d8e541a 100644
--- a/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
+++ b/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
@@ -282,8 +282,8 @@ namespace Apache
 
         void PdxReaderWithTypeCollector::ReadCollection( String^ fieldName, System::Collections::IList^ obj)
         {
-					checkType(fieldName, apache::geode::client::GemfireTypeIds::CacheableArrayList, "Collection");
-          m_newPdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Collection", apache::geode::client::GemfireTypeIds::CacheableArrayList);
+					checkType(fieldName, apache::geode::client::GeodeTypeIds::CacheableArrayList, "Collection");
+          m_newPdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Collection", apache::geode::client::GeodeTypeIds::CacheableArrayList);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
           if(position != -1)
           {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/impl/PdxWriterWithTypeCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxWriterWithTypeCollector.cpp b/src/clicache/src/impl/PdxWriterWithTypeCollector.cpp
index 4a5de65..1c8f55f 100644
--- a/src/clicache/src/impl/PdxWriterWithTypeCollector.cpp
+++ b/src/clicache/src/impl/PdxWriterWithTypeCollector.cpp
@@ -216,7 +216,7 @@ namespace Apache
 
           IPdxWriter^ PdxWriterWithTypeCollector::WriteCollection( String^ fieldName, System::Collections::IList^ obj)
           {
-            m_pdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Collection", apache::geode::client::GemfireTypeIds::CacheableArrayList);
+            m_pdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Collection", apache::geode::client::GeodeTypeIds::CacheableArrayList);
             PdxLocalWriter::WriteCollection(fieldName, obj);            
             return this;
           }

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheableBuiltins.hpp b/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
index 4071761..1bf14d7 100644
--- a/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
+++ b/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
@@ -385,8 +385,8 @@ class CacheableContainerType : public Cacheable, public TBase {
   extern const char tName_##k[];                                          \
   extern const char tStr_##k[];                                           \
   TEMPLATE_EXPORT                                                         \
-  CacheableKeyType<p, GemfireTypeIds::k, tName_##k, tStr_##k, sz>;        \
-  typedef CacheableKeyType<p, GemfireTypeIds::k, tName_##k, tStr_##k, sz> \
+  CacheableKeyType<p, GeodeTypeIds::k, tName_##k, tStr_##k, sz>;        \
+  typedef CacheableKeyType<p, GeodeTypeIds::k, tName_##k, tStr_##k, sz> \
       _##k;                                                               \
   class CPPCACHE_EXPORT k;                                                \
   typedef SharedPtr<k> k##Ptr;
@@ -412,10 +412,10 @@ class CacheableContainerType : public Cacheable, public TBase {
   inline CacheablePtr createValue(const p value) { return k::create(value); }
 
 #define _GF_CACHEABLE_ARRAY_TYPE_DEF_(p, c)                 \
-  TEMPLATE_EXPORT CacheableArrayType<p, GemfireTypeIds::c>; \
-  typedef CacheableArrayType<p, GemfireTypeIds::c> _##c;    \
+  TEMPLATE_EXPORT CacheableArrayType<p, GeodeTypeIds::c>; \
+  typedef CacheableArrayType<p, GeodeTypeIds::c> _##c;    \
   class CPPCACHE_EXPORT c;                                  \
-  typedef SharedArrayPtr<p, GemfireTypeIds::c> c##Ptr;
+  typedef SharedArrayPtr<p, GeodeTypeIds::c> c##Ptr;
 
 // use a class instead of typedef for bug #283
 #define _GF_CACHEABLE_ARRAY_TYPE_(p, c)                                        \
@@ -459,8 +459,8 @@ class CacheableContainerType : public Cacheable, public TBase {
   };
 
 #define _GF_CACHEABLE_CONTAINER_TYPE_DEF_(p, c)                 \
-  TEMPLATE_EXPORT CacheableContainerType<p, GemfireTypeIds::c>; \
-  typedef CacheableContainerType<p, GemfireTypeIds::c> _##c;    \
+  TEMPLATE_EXPORT CacheableContainerType<p, GeodeTypeIds::c>; \
+  typedef CacheableContainerType<p, GeodeTypeIds::c> _##c;    \
   class CPPCACHE_EXPORT c;                                      \
   typedef SharedPtr<c> c##Ptr;
 

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/include/gfcpp/CacheableEnum.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheableEnum.hpp b/src/cppcache/include/gfcpp/CacheableEnum.hpp
index 72eece5..aa88c30 100644
--- a/src/cppcache/include/gfcpp/CacheableEnum.hpp
+++ b/src/cppcache/include/gfcpp/CacheableEnum.hpp
@@ -86,7 +86,7 @@ class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
   */
   virtual int8_t typeId() const {
     // return 0;
-    return static_cast<int8_t>(GemfireTypeIds::CacheableEnum);
+    return static_cast<int8_t>(GeodeTypeIds::CacheableEnum);
   }
 
   /**

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/include/gfcpp/CacheableString.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheableString.hpp b/src/cppcache/include/gfcpp/CacheableString.hpp
index 478d4e8..1193552 100644
--- a/src/cppcache/include/gfcpp/CacheableString.hpp
+++ b/src/cppcache/include/gfcpp/CacheableString.hpp
@@ -31,10 +31,10 @@ namespace apache {
 namespace geode {
 namespace client {
 
-#define GF_STRING (int8_t) GemfireTypeIds::CacheableASCIIString
-#define GF_STRING_HUGE (int8_t) GemfireTypeIds::CacheableASCIIStringHuge
-#define GF_WIDESTRING (int8_t) GemfireTypeIds::CacheableString
-#define GF_WIDESTRING_HUGE (int8_t) GemfireTypeIds::CacheableStringHuge
+#define GF_STRING (int8_t) GeodeTypeIds::CacheableASCIIString
+#define GF_STRING_HUGE (int8_t) GeodeTypeIds::CacheableASCIIStringHuge
+#define GF_WIDESTRING (int8_t) GeodeTypeIds::CacheableString
+#define GF_WIDESTRING_HUGE (int8_t) GeodeTypeIds::CacheableStringHuge
 
 /**
  * Implement a immutable C string wrapper that can serve as a distributable
@@ -85,13 +85,13 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    * type to create and deserialize into.
    *
    * For a <code>CacheableString</code> this shall return
-   * <code>GemfireTypeIds::CacheableNullString</code> if the underlying
-   * string is null, <code>GemfireTypeIds::CacheableASCIIString</code>
+   * <code>GeodeTypeIds::CacheableNullString</code> if the underlying
+   * string is null, <code>GeodeTypeIds::CacheableASCIIString</code>
    * if the underlying string is a char*, and
-   * <code>GemfireTypeIds::CacheableString</code> if it is a wchar_t*.
+   * <code>GeodeTypeIds::CacheableString</code> if it is a wchar_t*.
    * For strings larger than 64K it will return
-   * <code>GemfireTypeIds::CacheableASCIIStringHuge</code> and
-   * <code>GemfireTypeIds::CacheableStringHuge</code> for char* and wchar_t*
+   * <code>GeodeTypeIds::CacheableASCIIStringHuge</code> and
+   * <code>GeodeTypeIds::CacheableStringHuge</code> for char* and wchar_t*
    * respectively.
    */
   virtual int8_t typeId() const;

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/include/gfcpp/DataInput.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/DataInput.hpp b/src/cppcache/include/gfcpp/DataInput.hpp
index 40553c5..f094921 100644
--- a/src/cppcache/include/gfcpp/DataInput.hpp
+++ b/src/cppcache/include/gfcpp/DataInput.hpp
@@ -625,28 +625,28 @@ class CPPCACHE_EXPORT DataInput {
     int8_t typeId = 0;
     read(&typeId);
     int64_t compId = typeId;
-    if (compId == GemfireTypeIds::NullObj) {
+    if (compId == GeodeTypeIds::NullObj) {
       csPtr = NULLPTR;
-    } else if (compId == GemfireTypeIds::CacheableNullString) {
+    } else if (compId == GeodeTypeIds::CacheableNullString) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializable()));
     } else if (compId ==
-               apache::geode::client::GemfireTypeIds::CacheableASCIIString) {
+               apache::geode::client::GeodeTypeIds::CacheableASCIIString) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializable()));
       csPtr.ptr()->fromData(*this);
-    } else if (compId == apache::geode::client::GemfireTypeIds::
+    } else if (compId == apache::geode::client::GeodeTypeIds::
                              CacheableASCIIStringHuge) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializableHuge()));
       csPtr.ptr()->fromData(*this);
     } else if (compId ==
-               apache::geode::client::GemfireTypeIds::CacheableString) {
+               apache::geode::client::GeodeTypeIds::CacheableString) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createUTFDeserializable()));
       csPtr.ptr()->fromData(*this);
     } else if (compId ==
-               apache::geode::client::GemfireTypeIds::CacheableStringHuge) {
+               apache::geode::client::GeodeTypeIds::CacheableStringHuge) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createUTFDeserializableHuge()));
       csPtr.ptr()->fromData(*this);
@@ -743,26 +743,26 @@ class CPPCACHE_EXPORT DataInput {
     read(&typeId);
 
     // Check for NULL String
-    if (typeId == GemfireTypeIds::CacheableNullString) {
+    if (typeId == GeodeTypeIds::CacheableNullString) {
       *value = NULL;
       return;
     }
     /*
-    if (typeId == GemfireTypeIds::CacheableString) {
+    if (typeId == GeodeTypeIds::CacheableString) {
       readUTF(value);
     } else {
       readUTFHuge(value);
     }
     */
-    if (typeId == static_cast<int8_t>(GemfireTypeIds::CacheableASCIIString) ||
-        typeId == static_cast<int8_t>(GemfireTypeIds::CacheableString)) {
+    if (typeId == static_cast<int8_t>(GeodeTypeIds::CacheableASCIIString) ||
+        typeId == static_cast<int8_t>(GeodeTypeIds::CacheableString)) {
       // readUTF( value);
       readASCII(value);
       // m_len = shortLen;
     } else if (typeId == static_cast<int8_t>(
-                             GemfireTypeIds::CacheableASCIIStringHuge) ||
+                             GeodeTypeIds::CacheableASCIIStringHuge) ||
                typeId ==
-                   static_cast<int8_t>(GemfireTypeIds::CacheableStringHuge)) {
+                   static_cast<int8_t>(GeodeTypeIds::CacheableStringHuge)) {
       // readUTFHuge( value);
       readASCIIHuge(value);
     } else {
@@ -776,18 +776,18 @@ class CPPCACHE_EXPORT DataInput {
     read(&typeId);
 
     // Check for NULL String
-    if (typeId == GemfireTypeIds::CacheableNullString) {
+    if (typeId == GeodeTypeIds::CacheableNullString) {
       *value = NULL;
       return;
     }
 
-    if (typeId == static_cast<int8_t>(GemfireTypeIds::CacheableASCIIString) ||
-        typeId == static_cast<int8_t>(GemfireTypeIds::CacheableString)) {
+    if (typeId == static_cast<int8_t>(GeodeTypeIds::CacheableASCIIString) ||
+        typeId == static_cast<int8_t>(GeodeTypeIds::CacheableString)) {
       readUTF(value);
     } else if (typeId == static_cast<int8_t>(
-                             GemfireTypeIds::CacheableASCIIStringHuge) ||
+                             GeodeTypeIds::CacheableASCIIStringHuge) ||
                typeId ==
-                   static_cast<int8_t>(GemfireTypeIds::CacheableStringHuge)) {
+                   static_cast<int8_t>(GeodeTypeIds::CacheableStringHuge)) {
       readUTFHuge(value);
     } else {
       throw IllegalArgumentException(

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/include/gfcpp/GeodeTypeIds.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/GeodeTypeIds.hpp b/src/cppcache/include/gfcpp/GeodeTypeIds.hpp
index bdff092..3d95daa 100644
--- a/src/cppcache/include/gfcpp/GeodeTypeIds.hpp
+++ b/src/cppcache/include/gfcpp/GeodeTypeIds.hpp
@@ -14,14 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef _GEMFIRE_GEMFIRETYPEIDS_HPP_
-#define _GEMFIRE_GEMFIRETYPEIDS_HPP_
+#ifndef _GEODE_GEODETYPEIDS_HPP_
+#define _GEODE_GEODETYPEIDS_HPP_
 
 namespace apache {
 namespace geode {
 namespace client {
 
-class GemfireTypeIds {
+class GeodeTypeIds {
  public:
   // User visible IDs here
   // Internal IDs are in GeodeTypeIds.hpp
@@ -29,7 +29,7 @@ class GemfireTypeIds {
   enum IdValues {
     // Do not use IDs 5 and 6 which are used by .NET
     // ManagedObject and ManagedObjectXml. If those are
-    // required then change those in GemfireTypeIdsM.hpp
+    // required then change those in GeodeTypeIdsM.hpp
 
     // keep the following in alphabetical order please.
     EnumInfo = 9,

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp b/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
index 0d8ecc4..d5636fa 100644
--- a/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
+++ b/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
@@ -162,16 +162,16 @@ inline uint32_t crc32Array(const TPRIM* arr, uint32_t len) {
 }
 
 inline bool isContainerTypeId(int8_t typeId) {
-  return (typeId == GemfireTypeIds::CacheableObjectArray) ||
-         (typeId == GemfireTypeIds::CacheableVector) ||
-         (typeId == GemfireTypeIds::CacheableHashMap) ||
-         (typeId == GemfireTypeIds::CacheableHashSet) ||
-         (typeId == GemfireTypeIds::CacheableStack) ||
-         (typeId == GemfireTypeIds::CacheableArrayList) ||
-         (typeId == GemfireTypeIds::CacheableHashTable) ||
-         (typeId == GemfireTypeIds::CacheableIdentityHashMap) ||
-         (typeId == GemfireTypeIds::CacheableLinkedHashSet) ||
-         (typeId == GemfireTypeIds::CacheableLinkedList);
+  return (typeId == GeodeTypeIds::CacheableObjectArray) ||
+         (typeId == GeodeTypeIds::CacheableVector) ||
+         (typeId == GeodeTypeIds::CacheableHashMap) ||
+         (typeId == GeodeTypeIds::CacheableHashSet) ||
+         (typeId == GeodeTypeIds::CacheableStack) ||
+         (typeId == GeodeTypeIds::CacheableArrayList) ||
+         (typeId == GeodeTypeIds::CacheableHashTable) ||
+         (typeId == GeodeTypeIds::CacheableIdentityHashMap) ||
+         (typeId == GeodeTypeIds::CacheableLinkedHashSet) ||
+         (typeId == GeodeTypeIds::CacheableLinkedList);
 }
 }  // namespace CacheableHelper
 
@@ -710,18 +710,18 @@ class CacheableHashMapTypeWrapper : public CacheableWrapper {
         if (CacheableHelper::isContainerTypeId(*valIter)) {
           continue;
         }
-        if ((*valIter == GemfireTypeIds::CacheableASCIIStringHuge ||
-             *valIter == GemfireTypeIds::CacheableStringHuge) &&
-            !(*keyIter == GemfireTypeIds::CacheableBoolean)) {
+        if ((*valIter == GeodeTypeIds::CacheableASCIIStringHuge ||
+             *valIter == GeodeTypeIds::CacheableStringHuge) &&
+            !(*keyIter == GeodeTypeIds::CacheableBoolean)) {
           continue;
         }
-        if ((*keyIter == GemfireTypeIds::CacheableASCIIStringHuge ||
-             *keyIter == GemfireTypeIds::CacheableStringHuge) &&
-            !(*valIter == GemfireTypeIds::CacheableBoolean)) {
+        if ((*keyIter == GeodeTypeIds::CacheableASCIIStringHuge ||
+             *keyIter == GeodeTypeIds::CacheableStringHuge) &&
+            !(*valIter == GeodeTypeIds::CacheableBoolean)) {
           continue;
         }
         // null object does not work on server side during deserialization
-        if (*valIter == GemfireTypeIds::CacheableNullString) {
+        if (*valIter == GeodeTypeIds::CacheableNullString) {
           continue;
         }
 
@@ -1202,110 +1202,110 @@ void registerBuiltins(bool isRegisterFileName = false) {
   srand(getpid() + static_cast<int>(time(0)));
 
   // Register the builtin cacheable keys
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableBoolean,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableBoolean,
                                         "CacheableBoolean",
                                         CacheableBooleanWrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableByte,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableByte,
                                         "CacheableByte",
                                         CacheableByteWrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableDouble,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableDouble,
                                         "CacheableDouble",
                                         CacheableDoubleWrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableDate,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableDate,
                                         "CacheableDate",
                                         CacheableDateWrapper::create, true);
   if (isRegisterFileName) {
 #ifdef _WIN32
     // TODO: windows requires some serious tweaking to get this to work
     CacheableWrapperFactory::registerType(
-        GemfireTypeIds::CacheableFileName, "CacheableFileName",
+        GeodeTypeIds::CacheableFileName, "CacheableFileName",
         CacheableFileNameWrapper::create, true);
 #endif
   }
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableFloat,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableFloat,
                                         "CacheableFloat",
                                         CacheableFloatWrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableInt16,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableInt16,
                                         "CacheableInt16",
                                         CacheableInt16Wrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableInt32,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableInt32,
                                         "CacheableInt32",
                                         CacheableInt32Wrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableInt64,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableInt64,
                                         "CacheableInt64",
                                         CacheableInt64Wrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableASCIIString,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableASCIIString,
                                         "CacheableString",
                                         CacheableStringWrapper::create, true);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableString, "CacheableUnicodeString",
+      GeodeTypeIds::CacheableString, "CacheableUnicodeString",
       CacheableUnicodeStringWrapper::create, true);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableASCIIStringHuge, "CacheableHugeString",
+      GeodeTypeIds::CacheableASCIIStringHuge, "CacheableHugeString",
       CacheableHugeStringWrapper::create, true);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableStringHuge, "CacheableHugeUnicodeString",
+      GeodeTypeIds::CacheableStringHuge, "CacheableHugeUnicodeString",
       CacheableHugeUnicodeStringWrapper::create, true);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableWideChar,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableWideChar,
                                         "CacheableWideChar",
                                         CacheableWideCharWrapper::create, true);
 
   // Register other builtin cacheables
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableHashMap,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableHashMap,
                                         "CacheableHashMap",
                                         CacheableHashMapWrapper::create, false);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableHashSet,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableHashSet,
                                         "CacheableHashSet",
                                         CacheableHashSetWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableHashTable, "CacheableHashTable",
+      GeodeTypeIds::CacheableHashTable, "CacheableHashTable",
       CacheableHashTableWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableIdentityHashMap, "CacheableIdentityHashMap",
+      GeodeTypeIds::CacheableIdentityHashMap, "CacheableIdentityHashMap",
       CacheableIdentityHashMapWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableLinkedHashSet, "CacheableLinkedHashSet",
+      GeodeTypeIds::CacheableLinkedHashSet, "CacheableLinkedHashSet",
       CacheableLinkedHashSetWrapper::create, false);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableBytes,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableBytes,
                                         "CacheableBytes",
                                         CacheableBytesWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableDoubleArray, "CacheableDoubleArray",
+      GeodeTypeIds::CacheableDoubleArray, "CacheableDoubleArray",
       CacheableDoubleArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableFloatArray, "CacheableFloatArray",
+      GeodeTypeIds::CacheableFloatArray, "CacheableFloatArray",
       CacheableFloatArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableInt16Array, "CacheableInt16Array",
+      GeodeTypeIds::CacheableInt16Array, "CacheableInt16Array",
       CacheableInt16ArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableInt32Array, "CacheableInt32Array",
+      GeodeTypeIds::CacheableInt32Array, "CacheableInt32Array",
       CacheableInt32ArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableInt64Array, "CacheableInt64Array",
+      GeodeTypeIds::CacheableInt64Array, "CacheableInt64Array",
       CacheableInt64ArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableNullString, "CacheableNullString",
+      GeodeTypeIds::CacheableNullString, "CacheableNullString",
       CacheableNullStringWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableObjectArray, "CacheableObjectArray",
+      GeodeTypeIds::CacheableObjectArray, "CacheableObjectArray",
       CacheableObjectArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableStringArray, "CacheableStringArray",
+      GeodeTypeIds::CacheableStringArray, "CacheableStringArray",
       CacheableStringArrayWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableUndefined, "CacheableUndefined",
+      GeodeTypeIds::CacheableUndefined, "CacheableUndefined",
       CacheableUndefinedWrapper::create, false);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableVector,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableVector,
                                         "CacheableVector",
                                         CacheableVectorWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableArrayList, "CacheableArrayList",
+      GeodeTypeIds::CacheableArrayList, "CacheableArrayList",
       CacheableArrayListWrapper::create, false);
   CacheableWrapperFactory::registerType(
-      GemfireTypeIds::CacheableLinkedList, "CacheableLinkedList",
+      GeodeTypeIds::CacheableLinkedList, "CacheableLinkedList",
       CacheableLinkedListWrapper::create, false);
-  CacheableWrapperFactory::registerType(GemfireTypeIds::CacheableStack,
+  CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableStack,
                                         "CacheableStack",
                                         CacheableStackWrapper::create, false);
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/integration-test/ThinClientHeapLRU.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/ThinClientHeapLRU.hpp b/src/cppcache/integration-test/ThinClientHeapLRU.hpp
index 208567e..036f2d2 100644
--- a/src/cppcache/integration-test/ThinClientHeapLRU.hpp
+++ b/src/cppcache/integration-test/ThinClientHeapLRU.hpp
@@ -117,9 +117,9 @@ void createOnekEntries() {
   RegionPtr dataReg = getHelper()->getRegion(regionNames[0]);
   for (int i = 0; i < 2048; i++) {
     CacheableWrapper* tmpkey =
-        CacheableWrapperFactory::createInstance(GemfireTypeIds::CacheableInt32);
+        CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableInt32);
     CacheableWrapper* tmpval =
-        CacheableWrapperFactory::createInstance(GemfireTypeIds::CacheableBytes);
+        CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableBytes);
     tmpkey->initKey(i, 32);
     tmpval->initRandomValue(1024);
     ASSERT(tmpkey->getCacheable() != NULLPTR, "tmpkey->getCacheable() is NULL");

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/integration-test/testSerialization.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testSerialization.cpp b/src/cppcache/integration-test/testSerialization.cpp
index 9d10d92..af8e9d2 100644
--- a/src/cppcache/integration-test/testSerialization.cpp
+++ b/src/cppcache/integration-test/testSerialization.cpp
@@ -208,16 +208,16 @@ DUNIT_TASK(NoDist, OtherTypeInMemory)
     ASSERT(copy->classId() == g_classIdToReturn, "unexpected classId");
     if (copy->classId() > 0xFFFF) {
       ASSERT(
-          copy->typeId() == GemfireTypeIdsImpl::CacheableUserData4,
-          "typeId should be equal to GemfireTypeIdsImpl::CacheableUserData4.");
+          copy->typeId() == GeodeTypeIdsImpl::CacheableUserData4,
+          "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData4.");
     } else if (copy->classId() > 0xFF) {
       ASSERT(
-          copy->typeId() == GemfireTypeIdsImpl::CacheableUserData2,
-          "typeId should be equal to GemfireTypeIdsImpl::CacheableUserData2.");
+          copy->typeId() == GeodeTypeIdsImpl::CacheableUserData2,
+          "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData2.");
     } else {
       ASSERT(
-          copy->typeId() == GemfireTypeIdsImpl::CacheableUserData,
-          "typeId should be equal to GemfireTypeIdsImpl::CacheableUserData.");
+          copy->typeId() == GeodeTypeIdsImpl::CacheableUserData,
+          "typeId should be equal to GeodeTypeIdsImpl::CacheableUserData.");
     }
     ASSERT(copy != ot, "expected different instance.");
     ASSERT(copy->m_struct.a == 1, "a == 1");

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/integration-test/testThinClientHeapLRU.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/testThinClientHeapLRU.cpp b/src/cppcache/integration-test/testThinClientHeapLRU.cpp
index f9095a9..3224322 100644
--- a/src/cppcache/integration-test/testThinClientHeapLRU.cpp
+++ b/src/cppcache/integration-test/testThinClientHeapLRU.cpp
@@ -44,9 +44,9 @@ void createOnekEntries() {
   RegionPtr dataReg = getHelper()->getRegion(_regionNames[0]);
   for (int i = 0; i < 2048; i++) {
     CacheableWrapper* tmpkey =
-        CacheableWrapperFactory::createInstance(GemfireTypeIds::CacheableInt32);
+        CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableInt32);
     CacheableWrapper* tmpval =
-        CacheableWrapperFactory::createInstance(GemfireTypeIds::CacheableBytes);
+        CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableBytes);
     tmpkey->initKey(i, 32);
     tmpval->initRandomValue(1024);
     ASSERT(tmpkey->getCacheable() != NULLPTR, "tmpkey->getCacheable() is NULL");

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/BucketServerLocation.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/BucketServerLocation.hpp b/src/cppcache/src/BucketServerLocation.hpp
index 71f66c2..a87cf42 100644
--- a/src/cppcache/src/BucketServerLocation.hpp
+++ b/src/cppcache/src/BucketServerLocation.hpp
@@ -135,7 +135,7 @@ class BucketServerLocation : public ServerLocation {
   }
 
   int8_t DSFID() const {
-    return static_cast<int8_t>(GemfireTypeIdsImpl::FixedIDByte);  // Never used
+    return static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte);  // Never used
   }
 
   int32_t classId() const {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheFactory.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheFactory.cpp b/src/cppcache/src/CacheFactory.cpp
index 92e9a6f..151c65e 100644
--- a/src/cppcache/src/CacheFactory.cpp
+++ b/src/cppcache/src/CacheFactory.cpp
@@ -252,11 +252,11 @@ CachePtr CacheFactory::create() {
     }
   }
 
-  SerializationRegistry::addType(GemfireTypeIdsImpl::PDX,
+  SerializationRegistry::addType(GeodeTypeIdsImpl::PDX,
                                  PdxInstantiator::createDeserializable);
-  SerializationRegistry::addType(GemfireTypeIds::CacheableEnum,
+  SerializationRegistry::addType(GeodeTypeIds::CacheableEnum,
                                  PdxEnumInstantiator::createDeserializable);
-  SerializationRegistry::addType(GemfireTypeIds::PdxType,
+  SerializationRegistry::addType(GeodeTypeIds::PdxType,
                                  PdxType::CreateDeserializable);
   PdxTypeRegistry::setPdxIgnoreUnreadFields(cache->getPdxIgnoreUnreadFields());
   PdxTypeRegistry::setPdxReadSerialized(cache->getPdxReadSerialized());

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableDate.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableDate.cpp b/src/cppcache/src/CacheableDate.cpp
index d01dd24..602b5f9 100644
--- a/src/cppcache/src/CacheableDate.cpp
+++ b/src/cppcache/src/CacheableDate.cpp
@@ -56,10 +56,10 @@ Serializable* CacheableDate::createDeserializable() {
 
 int32_t CacheableDate::classId() const { return 0; }
 
-int8_t CacheableDate::typeId() const { return GemfireTypeIds::CacheableDate; }
+int8_t CacheableDate::typeId() const { return GeodeTypeIds::CacheableDate; }
 
 bool CacheableDate::operator==(const CacheableKey& other) const {
-  if (other.typeId() != GemfireTypeIds::CacheableDate) {
+  if (other.typeId() != GeodeTypeIds::CacheableDate) {
     return false;
   }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableEnum.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableEnum.cpp b/src/cppcache/src/CacheableEnum.cpp
index 1d4d0df..b9aa12a 100644
--- a/src/cppcache/src/CacheableEnum.cpp
+++ b/src/cppcache/src/CacheableEnum.cpp
@@ -42,7 +42,7 @@ CacheableEnum::CacheableEnum(const char* enumClassName, const char* enumName,
 void CacheableEnum::toData(apache::geode::client::DataOutput& output) const {
   int enumVal = PdxHelper::getEnumValue(m_enumClassName->asChar(),
                                         m_enumName->asChar(), m_ordinal);
-  output.write(static_cast<int8_t>(GemfireTypeIds::CacheableEnum));
+  output.write(static_cast<int8_t>(GeodeTypeIds::CacheableEnum));
   output.write(int8_t(enumVal >> 24));
   output.writeArrayLen(enumVal & 0xFFFFFF);
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableFileName.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableFileName.cpp b/src/cppcache/src/CacheableFileName.cpp
index a3dc779..aa9948c 100644
--- a/src/cppcache/src/CacheableFileName.cpp
+++ b/src/cppcache/src/CacheableFileName.cpp
@@ -40,7 +40,7 @@ Serializable* CacheableFileName::fromData(DataInput& input) {
 int32_t CacheableFileName::classId() const { return 0; }
 
 int8_t CacheableFileName::typeId() const {
-  return GemfireTypeIds::CacheableFileName;
+  return GeodeTypeIds::CacheableFileName;
 }
 
 uint32_t CacheableFileName::hashcode() const {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableObjectArray.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableObjectArray.cpp b/src/cppcache/src/CacheableObjectArray.cpp
index 44bf3cc..9dbbb73 100644
--- a/src/cppcache/src/CacheableObjectArray.cpp
+++ b/src/cppcache/src/CacheableObjectArray.cpp
@@ -28,8 +28,8 @@ namespace client {
 void CacheableObjectArray::toData(DataOutput& output) const {
   int32_t len = size();
   output.writeArrayLen(len);
-  output.write(static_cast<int8_t>(GemfireTypeIdsImpl::Class));
-  output.write(static_cast<int8_t>(GemfireTypeIds::CacheableASCIIString));
+  output.write(static_cast<int8_t>(GeodeTypeIdsImpl::Class));
+  output.write(static_cast<int8_t>(GeodeTypeIds::CacheableASCIIString));
   output.writeASCII("java.lang.Object");
   for (Iterator iter = begin(); iter != end(); ++iter) {
     output.writeObject(*iter);
@@ -58,7 +58,7 @@ Serializable* CacheableObjectArray::fromData(DataInput& input) {
 int32_t CacheableObjectArray::classId() const { return 0; }
 
 int8_t CacheableObjectArray::typeId() const {
-  return GemfireTypeIds::CacheableObjectArray;
+  return GeodeTypeIds::CacheableObjectArray;
 }
 
 uint32_t CacheableObjectArray::objectSize() const {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableObjectPartList.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableObjectPartList.cpp b/src/cppcache/src/CacheableObjectPartList.cpp
index 750a0de..034657a 100644
--- a/src/cppcache/src/CacheableObjectPartList.cpp
+++ b/src/cppcache/src/CacheableObjectPartList.cpp
@@ -126,11 +126,11 @@ Serializable* CacheableObjectPartList::fromData(DataInput& input) {
 int32_t CacheableObjectPartList::classId() const { return 0; }
 
 int8_t CacheableObjectPartList::typeId() const {
-  return GemfireTypeIdsImpl::CacheableObjectPartList;
+  return GeodeTypeIdsImpl::CacheableObjectPartList;
 }
 
 int8_t CacheableObjectPartList::DSFID() const {
-  return GemfireTypeIdsImpl::FixedIDByte;
+  return GeodeTypeIdsImpl::FixedIDByte;
 }
 
 uint32_t CacheableObjectPartList::objectSize() const { return 0; }

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableToken.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableToken.cpp b/src/cppcache/src/CacheableToken.cpp
index 833c7f3..e4a290f 100644
--- a/src/cppcache/src/CacheableToken.cpp
+++ b/src/cppcache/src/CacheableToken.cpp
@@ -81,7 +81,7 @@ Serializable* CacheableToken::fromData(DataInput& input) {
 int32_t CacheableToken::classId() const { return 0; }
 
 int8_t CacheableToken::typeId() const {
-  return static_cast<int8_t>(GemfireTypeIdsImpl::CacheableToken);
+  return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableToken);
 }
 
 //------ ctor

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CacheableUndefined.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableUndefined.cpp b/src/cppcache/src/CacheableUndefined.cpp
index 551a1ce..d47f606 100644
--- a/src/cppcache/src/CacheableUndefined.cpp
+++ b/src/cppcache/src/CacheableUndefined.cpp
@@ -31,11 +31,11 @@ Serializable* CacheableUndefined::fromData(DataInput& input) { return this; }
 int32_t CacheableUndefined::classId() const { return 0; }
 
 int8_t CacheableUndefined::typeId() const {
-  return GemfireTypeIds::CacheableUndefined;
+  return GeodeTypeIds::CacheableUndefined;
 }
 
 int8_t CacheableUndefined::DSFID() const {
-  return GemfireTypeIdsImpl::FixedIDByte;
+  return GeodeTypeIdsImpl::FixedIDByte;
 }
 
 uint32_t CacheableUndefined::objectSize() const { return 0; }

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/CachedDeserializableHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CachedDeserializableHelper.hpp b/src/cppcache/src/CachedDeserializableHelper.hpp
index e054470..64217e0 100644
--- a/src/cppcache/src/CachedDeserializableHelper.hpp
+++ b/src/cppcache/src/CachedDeserializableHelper.hpp
@@ -67,7 +67,7 @@ class CachedDeserializableHelper : public Cacheable,
    */
   inline static Serializable* createForPreferBytesDeserializable() {
     return new CachedDeserializableHelper(
-        GemfireTypeIdsImpl::PreferBytesCachedDeserializable);
+        GeodeTypeIdsImpl::PreferBytesCachedDeserializable);
   }
 
   /**
@@ -75,7 +75,7 @@ class CachedDeserializableHelper : public Cacheable,
    */
   inline static Serializable* createForVmCachedDeserializable() {
     return new CachedDeserializableHelper(
-        GemfireTypeIdsImpl::VmCachedDeserializable);
+        GeodeTypeIdsImpl::VmCachedDeserializable);
   }
 
   /**
@@ -89,7 +89,7 @@ class CachedDeserializableHelper : public Cacheable,
    * Return the data serializable fixed ID size type for internal use.
    * @since GFE 5.7
    */
-  virtual int8_t DSFID() const { return GemfireTypeIdsImpl::FixedIDByte; }
+  virtual int8_t DSFID() const { return GeodeTypeIdsImpl::FixedIDByte; }
 
   int32_t classId() const { return 0; }
 };

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/ClientConnectionRequest.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientConnectionRequest.cpp b/src/cppcache/src/ClientConnectionRequest.cpp
index 57f8849..5b95ac1 100644
--- a/src/cppcache/src/ClientConnectionRequest.cpp
+++ b/src/cppcache/src/ClientConnectionRequest.cpp
@@ -33,7 +33,7 @@ Serializable* ClientConnectionRequest::fromData(DataInput& input) {
 }
 uint32_t ClientConnectionRequest::objectSize() const { return 0; }
 int8_t ClientConnectionRequest::typeId() const {
-  return static_cast<int8_t>(GemfireTypeIdsImpl::ClientConnectionRequest);
+  return static_cast<int8_t>(GeodeTypeIdsImpl::ClientConnectionRequest);
 }
 void ClientConnectionRequest::writeSetOfServerLocation(
     DataOutput& output) const {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/ClientConnectionResponse.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientConnectionResponse.cpp b/src/cppcache/src/ClientConnectionResponse.cpp
index 3f72ade..7d1f8bd 100644
--- a/src/cppcache/src/ClientConnectionResponse.cpp
+++ b/src/cppcache/src/ClientConnectionResponse.cpp
@@ -26,7 +26,7 @@ ClientConnectionResponse* ClientConnectionResponse::fromData(DataInput& input) {
   return this;
 }
 int8_t ClientConnectionResponse::typeId() const {
-  return static_cast<int8_t>(GemfireTypeIdsImpl::ClientConnectionResponse);
+  return static_cast<int8_t>(GeodeTypeIdsImpl::ClientConnectionResponse);
 }
 uint32_t ClientConnectionResponse::objectSize() const {
   return (m_server.objectSize());

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/cppcache/src/ClientHealthStats.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientHealthStats.cpp b/src/cppcache/src/ClientHealthStats.cpp
index 3ee38f9..fc3f07f 100644
--- a/src/cppcache/src/ClientHealthStats.cpp
+++ b/src/cppcache/src/ClientHealthStats.cpp
@@ -51,10 +51,10 @@ Serializable* ClientHealthStats::createDeserializable() {
 int32_t ClientHealthStats::classId() const { return 0; }
 
 int8_t ClientHealthStats::DSFID() const {
-  return static_cast<int8_t>(GemfireTypeIdsImpl::FixedIDByte);
+  return static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte);
 }
 int8_t ClientHealthStats::typeId() const {
-  return static_cast<int8_t>(GemfireTypeIdsImpl::ClientHealthStats);
+  return static_cast<int8_t>(GeodeTypeIdsImpl::ClientHealthStats);
 }
 
 ClientHealthStats::ClientHealthStats()


Mime
View raw message