geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [3/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:26 GMT
GEODE-2342: Rename GemfireTypeIds class to GeodeTypeIds to match corresponding file name change. Note, this was missed in the intitial commit.


Project: http://git-wip-us.apache.org/repos/asf/geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode/commit/49cc4f26
Tree: http://git-wip-us.apache.org/repos/asf/geode/tree/49cc4f26
Diff: http://git-wip-us.apache.org/repos/asf/geode/diff/49cc4f26

Branch: refs/heads/next-gen-native-client-software-grant
Commit: 49cc4f2643b5d097e43c615c5522135a6431fca2
Parents: 63d531e
Author: Mike Martell <mmartell@pivotal.io>
Authored: Wed Jan 25 11:11:46 2017 -0800
Committer: Jacob Barrett <jbarrett@pivotal.io>
Committed: Mon Jan 30 10:07:41 2017 -0800

----------------------------------------------------------------------
 examples/dist/cacheRunner/CacheRunner.cpp       |  16 +-
 examples/dist/cacheRunner/TestCacheCallback.cpp |   4 +-
 src/clicache/src/CacheFactory.cpp               |   2 +-
 src/clicache/src/CacheableFileName.cpp          |   6 +-
 src/clicache/src/CacheableObjectArray.cpp       |   8 +-
 src/clicache/src/DataInput.cpp                  | 100 +++++-----
 src/clicache/src/DataOutput.cpp                 | 102 +++++-----
 src/clicache/src/DistributedSystem.cpp          | 190 +++++++++----------
 src/clicache/src/GemFireClassIds.hpp            |  82 ++++----
 src/clicache/src/Properties.cpp                 |   4 +-
 src/clicache/src/Serializable.cpp               | 150 +++++++--------
 src/clicache/src/Serializable.hpp               |  54 +++---
 src/clicache/src/impl/ManagedCacheableDelta.cpp |   6 +-
 .../src/impl/ManagedCacheableDeltaBytes.cpp     |   6 +-
 src/clicache/src/impl/ManagedCacheableKey.cpp   |   6 +-
 .../src/impl/ManagedCacheableKeyBytes.cpp       |   6 +-
 src/clicache/src/impl/PdxFieldType.cpp          |   2 +-
 src/clicache/src/impl/PdxInstanceImpl.hpp       |   4 +-
 .../src/impl/PdxManagedCacheableKey.cpp         |   8 +-
 .../src/impl/PdxManagedCacheableKeyBytes.cpp    |   8 +-
 .../src/impl/PdxReaderWithTypeCollector.cpp     |   4 +-
 .../src/impl/PdxWriterWithTypeCollector.cpp     |   2 +-
 .../include/gfcpp/CacheableBuiltins.hpp         |  14 +-
 src/cppcache/include/gfcpp/CacheableEnum.hpp    |   2 +-
 src/cppcache/include/gfcpp/CacheableString.hpp  |  18 +-
 src/cppcache/include/gfcpp/DataInput.hpp        |  34 ++--
 src/cppcache/include/gfcpp/GeodeTypeIds.hpp     |   8 +-
 .../BuiltinCacheableWrappers.hpp                | 100 +++++-----
 .../integration-test/ThinClientHeapLRU.hpp      |   4 +-
 .../integration-test/testSerialization.cpp      |  12 +-
 .../integration-test/testThinClientHeapLRU.cpp  |   4 +-
 src/cppcache/src/BucketServerLocation.hpp       |   2 +-
 src/cppcache/src/CacheFactory.cpp               |   6 +-
 src/cppcache/src/CacheableDate.cpp              |   4 +-
 src/cppcache/src/CacheableEnum.cpp              |   2 +-
 src/cppcache/src/CacheableFileName.cpp          |   2 +-
 src/cppcache/src/CacheableObjectArray.cpp       |   6 +-
 src/cppcache/src/CacheableObjectPartList.cpp    |   4 +-
 src/cppcache/src/CacheableToken.cpp             |   2 +-
 src/cppcache/src/CacheableUndefined.cpp         |   4 +-
 src/cppcache/src/CachedDeserializableHelper.hpp |   6 +-
 src/cppcache/src/ClientConnectionRequest.cpp    |   2 +-
 src/cppcache/src/ClientConnectionResponse.cpp   |   2 +-
 src/cppcache/src/ClientHealthStats.cpp          |   4 +-
 src/cppcache/src/ClientProxyMembershipID.cpp    |  14 +-
 src/cppcache/src/ClientProxyMembershipID.hpp    |   4 +-
 src/cppcache/src/ClientReplacementRequest.cpp   |   2 +-
 src/cppcache/src/DiskStoreId.hpp                |   2 +-
 src/cppcache/src/DiskVersionTag.hpp             |   2 +-
 src/cppcache/src/EnumInfo.cpp                   |   2 +-
 src/cppcache/src/EnumInfo.hpp                   |   2 +-
 src/cppcache/src/EventId.cpp                    |   2 +-
 src/cppcache/src/EventId.hpp                    |   2 +-
 src/cppcache/src/FarSideEntryOp.cpp             |   8 +-
 .../src/FixedPartitionAttributesImpl.hpp        |   2 +-
 .../src/GatewayEventCallbackArgument.hpp        |   4 +-
 .../src/GatewaySenderEventCallbackArgument.hpp  |   4 +-
 src/cppcache/src/GeodeTypeIdsImpl.hpp           |   6 +-
 src/cppcache/src/GetAllServersRequest.hpp       |   4 +-
 src/cppcache/src/GetAllServersResponse.hpp      |   4 +-
 src/cppcache/src/LocatorListRequest.cpp         |   2 +-
 src/cppcache/src/LocatorListResponse.cpp        |   2 +-
 src/cppcache/src/PdxEnumInstantiator.cpp        |   2 +-
 src/cppcache/src/PdxFieldType.cpp               |   4 +-
 src/cppcache/src/PdxInstanceImpl.cpp            |  34 ++--
 src/cppcache/src/PdxInstantiator.cpp            |   2 +-
 src/cppcache/src/PdxLocalWriter.cpp             |  34 ++--
 src/cppcache/src/PdxReaderWithTypeCollector.cpp |   4 +-
 src/cppcache/src/PdxSerializable.cpp            |   2 +-
 src/cppcache/src/PdxType.cpp                    |   8 +-
 src/cppcache/src/PdxType.hpp                    |   2 +-
 src/cppcache/src/Properties.cpp                 |   2 +-
 src/cppcache/src/QueueConnectionRequest.cpp     |   6 +-
 src/cppcache/src/QueueConnectionResponse.cpp    |   2 +-
 src/cppcache/src/RegionAttributes.cpp           |   2 +-
 src/cppcache/src/Serializable.cpp               |   8 +-
 src/cppcache/src/SerializationRegistry.cpp      |  28 +--
 src/cppcache/src/SerializationRegistry.hpp      |  20 +-
 src/cppcache/src/ServerLocation.hpp             |   2 +-
 src/cppcache/src/ServerLocationRequest.cpp      |   4 +-
 src/cppcache/src/ServerLocationResponse.hpp     |   2 +-
 src/cppcache/src/Struct.cpp                     |   6 +-
 src/cppcache/src/TXCommitMessage.cpp            |   8 +-
 src/cppcache/src/TcrConnection.cpp              |   8 +-
 src/cppcache/src/TcrMessage.cpp                 |  44 ++---
 src/cppcache/src/TcrMessage.hpp                 |  12 +-
 src/cppcache/src/ThinClientRegion.cpp           |  34 ++--
 src/cppcache/src/VersionTag.cpp                 |   2 +-
 .../src/VersionedCacheableObjectPartList.cpp    |   4 +-
 89 files changed, 683 insertions(+), 683 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/examples/dist/cacheRunner/CacheRunner.cpp
----------------------------------------------------------------------
diff --git a/examples/dist/cacheRunner/CacheRunner.cpp b/examples/dist/cacheRunner/CacheRunner.cpp
index e2edc37..513b5b6 100644
--- a/examples/dist/cacheRunner/CacheRunner.cpp
+++ b/examples/dist/cacheRunner/CacheRunner.cpp
@@ -1347,7 +1347,7 @@ void CacheRunner::printEntry(CacheableKeyPtr& sKey, CacheablePtr& valueBytes)
    if (valueBytes != NULLPTR) {
      int8_t typeId = valueBytes->typeId();
      std::string objType;
-     if (typeId == GemfireTypeIds::CacheableBytes) {
+     if (typeId == GeodeTypeIds::CacheableBytes) {
        objType = "Bytes: ";
        CacheableBytesPtr cBytePtr = staticCast<CacheableBytesPtr>( valueBytes );
        const uint8_t* bytType = cBytePtr->value();
@@ -1361,13 +1361,13 @@ void CacheRunner::printEntry(CacheableKeyPtr& sKey, CacheablePtr& valueBytes)
      else {
        switch (typeId)
        {
-         case GemfireTypeIds::CacheableASCIIString: objType = "String: "; break;
-         case GemfireTypeIds::CacheableInt16: objType = "Int16: "; break;
-         case GemfireTypeIds::CacheableInt32: objType = "Int32: "; break;
-         case GemfireTypeIds::CacheableInt64: objType = "Int64: "; break;
-         case GemfireTypeIds::CacheableDouble: objType = "Double: "; break;
-         case GemfireTypeIds::CacheableFloat: objType = "Float: "; break;
-         case GemfireTypeIds::CacheableByte: objType = "Byte: "; break;
+         case GeodeTypeIds::CacheableASCIIString: objType = "String: "; break;
+         case GeodeTypeIds::CacheableInt16: objType = "Int16: "; break;
+         case GeodeTypeIds::CacheableInt32: objType = "Int32: "; break;
+         case GeodeTypeIds::CacheableInt64: objType = "Int64: "; break;
+         case GeodeTypeIds::CacheableDouble: objType = "Double: "; break;
+         case GeodeTypeIds::CacheableFloat: objType = "Float: "; break;
+         case GeodeTypeIds::CacheableByte: objType = "Byte: "; break;
          default: objType = ""; break;
        }
        sValue = objType + valueBytes->toString()->asChar();

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/examples/dist/cacheRunner/TestCacheCallback.cpp
----------------------------------------------------------------------
diff --git a/examples/dist/cacheRunner/TestCacheCallback.cpp b/examples/dist/cacheRunner/TestCacheCallback.cpp
index 62469fc..6de3dfb 100644
--- a/examples/dist/cacheRunner/TestCacheCallback.cpp
+++ b/examples/dist/cacheRunner/TestCacheCallback.cpp
@@ -94,7 +94,7 @@ std::string TestCacheCallback::printEntryValue(CacheablePtr& valueBytes)
 
    if (valueBytes != NULLPTR) {
      int32_t id = valueBytes->typeId();
-     if (id == GemfireTypeIds::CacheableBytes) {
+     if (id == GeodeTypeIds::CacheableBytes) {
        cBytePtr = staticCast<CacheableBytesPtr>(valueBytes);
        const uint8_t* bytType = cBytePtr->value();
        const uint32_t len = cBytePtr->length();
@@ -104,7 +104,7 @@ std::string TestCacheCallback::printEntryValue(CacheablePtr& valueBytes)
        std::string byteType(buff);
        sValue = byteType;
      }
-     else if (id == GemfireTypeIds::CacheableInt32) {
+     else if (id == GeodeTypeIds::CacheableInt32) {
        cIntPtr= staticCast<CacheableInt32Ptr>(valueBytes);
        int32_t intval = cIntPtr->value();
        int len = sizeof(intval);

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/CacheFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheFactory.cpp b/src/clicache/src/CacheFactory.cpp
index 10602cf..6cd7c68 100644
--- a/src/clicache/src/CacheFactory.cpp
+++ b/src/clicache/src/CacheFactory.cpp
@@ -85,7 +85,7 @@ namespace Apache
           SafeConvertClassGeneric::SetAppDomainEnabled(appDomainEnable);
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::PdxType,
+              apache::geode::client::GeodeTypeIds::PdxType,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::Internal::PdxType::CreateDeserializable),
               nullptr);
 

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/CacheableFileName.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableFileName.cpp b/src/clicache/src/CacheableFileName.cpp
index e4f3585..451c327 100644
--- a/src/clicache/src/CacheableFileName.cpp
+++ b/src/clicache/src/CacheableFileName.cpp
@@ -35,11 +35,11 @@ namespace Apache
       void CacheableFileName::ToData(DataOutput^ output)
       {
         if (m_str->Length <= 0xFFFF) {
-          output->WriteByte(apache::geode::client::GemfireTypeIds::CacheableString);
+          output->WriteByte(apache::geode::client::GeodeTypeIds::CacheableString);
           output->WriteUTF(m_str);
         }
         else {
-          output->WriteByte(apache::geode::client::GemfireTypeIds::CacheableStringHuge);
+          output->WriteByte(apache::geode::client::GeodeTypeIds::CacheableStringHuge);
           output->WriteUTFHuge(m_str);
         }
       }
@@ -47,7 +47,7 @@ namespace Apache
       IGFSerializable^ CacheableFileName::FromData(DataInput^ input)
       {
         unsigned char filetype = input->ReadByte();
-        if (filetype == apache::geode::client::GemfireTypeIds::CacheableString) {
+        if (filetype == apache::geode::client::GeodeTypeIds::CacheableString) {
           m_str = input->ReadUTF();
         }
         else {

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/CacheableObjectArray.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/CacheableObjectArray.cpp b/src/clicache/src/CacheableObjectArray.cpp
index 95650a4..3df7c54 100644
--- a/src/clicache/src/CacheableObjectArray.cpp
+++ b/src/clicache/src/CacheableObjectArray.cpp
@@ -42,8 +42,8 @@ namespace Apache
       void CacheableObjectArray::ToData(DataOutput^ output)
       {
         output->WriteArrayLen((int32_t)Count);
-        output->WriteByte((int8_t)apache::geode::client::GemfireTypeIdsImpl::Class);
-        output->WriteByte((int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIString);
+        output->WriteByte((int8_t)apache::geode::client::GeodeTypeIdsImpl::Class);
+        output->WriteByte((int8_t)apache::geode::client::GeodeTypeIds::CacheableASCIIString);
         output->WriteUTF("java.lang.Object");
 
         for each (Object^ obj in this) {
@@ -55,8 +55,8 @@ namespace Apache
 
           apache::geode::client::DataOutput& nativeOutput = *(output->_NativePtr);
           nativeOutput.writeArrayLen((int32_t)Count);
-          nativeOutput.write((int8_t)apache::geode::client::GemfireTypeIdsImpl::Class);
-          nativeOutput.write((int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIString);
+          nativeOutput.write((int8_t)apache::geode::client::GeodeTypeIdsImpl::Class);
+          nativeOutput.write((int8_t)apache::geode::client::GeodeTypeIds::CacheableASCIIString);
           nativeOutput.writeASCII("java.lang.Object");
           for each (IGFSerializable^ obj in this) {
             apache::geode::client::SerializablePtr objPtr(SafeMSerializableConvert(obj));

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/DataInput.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/DataInput.cpp b/src/clicache/src/DataInput.cpp
index 11ccde8..26b174d 100644
--- a/src/clicache/src/DataInput.cpp
+++ b/src/clicache/src/DataInput.cpp
@@ -415,50 +415,50 @@ namespace Apache
 				{
 					switch(typeId)
 					{
-					case apache::geode::client::GemfireTypeIds::CacheableByte:
+					case apache::geode::client::GeodeTypeIds::CacheableByte:
 						{
 							return ReadSByte();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableBoolean:
+					case apache::geode::client::GeodeTypeIds::CacheableBoolean:
 						{
 							bool obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableWideChar:
+					case apache::geode::client::GeodeTypeIds::CacheableWideChar:
 						{
 							Char obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableDouble:
+					case apache::geode::client::GeodeTypeIds::CacheableDouble:
 						{
 							Double obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableASCIIString:
+					case apache::geode::client::GeodeTypeIds::CacheableASCIIString:
 						{
 						/*	CacheableString^ cs = static_cast<CacheableString^>(CacheableString::CreateDeserializable());
 							cs->FromData(this);
 							return cs->Value;*/
               return ReadUTF();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge:
+					case apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge:
 						{
 							/*CacheableString^ cs = static_cast<CacheableString^>(CacheableString::createDeserializableHuge());
 							cs->FromData(this);
 							return cs->Value;*/
               return ReadASCIIHuge();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableString:
+					case apache::geode::client::GeodeTypeIds::CacheableString:
 						{
 							/*CacheableString^ cs = static_cast<CacheableString^>(CacheableString::createUTFDeserializable());
 							cs->FromData(this);
 							return cs->Value;*/
               return ReadUTF();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableStringHuge:
+					case apache::geode::client::GeodeTypeIds::CacheableStringHuge:
 						{
 							//TODO: need to look all strings types
 							/*CacheableString^ cs = static_cast<CacheableString^>(CacheableString::createUTFDeserializableHuge());
@@ -466,103 +466,103 @@ namespace Apache
 							return cs->Value;*/
               return ReadUTFHuge();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableFloat:
+					case apache::geode::client::GeodeTypeIds::CacheableFloat:
 						{
 							float obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt16:
+					case apache::geode::client::GeodeTypeIds::CacheableInt16:
 						{
 							Int16 obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt32:
+					case apache::geode::client::GeodeTypeIds::CacheableInt32:
 						{
 							Int32 obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt64:
+					case apache::geode::client::GeodeTypeIds::CacheableInt64:
 						{
 							Int64 obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableDate:
+					case apache::geode::client::GeodeTypeIds::CacheableDate:
 						{
 							CacheableDate^ cd = CacheableDate::Create();
 							cd->FromData(this);
 							return cd->Value;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableBytes:
+					case apache::geode::client::GeodeTypeIds::CacheableBytes:
 						{
 							return ReadBytes();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
+					case apache::geode::client::GeodeTypeIds::CacheableDoubleArray:
 						{
 							array<Double>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
+					case apache::geode::client::GeodeTypeIds::CacheableFloatArray:
 						{
 							array<float>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
+					case apache::geode::client::GeodeTypeIds::CacheableInt16Array:
 						{
 							array<Int16>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
+					case apache::geode::client::GeodeTypeIds::CacheableInt32Array:
 						{
 							array<Int32>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::BooleanArray:
+					case apache::geode::client::GeodeTypeIds::BooleanArray:
 						{
 							array<bool>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CharArray:
+					case apache::geode::client::GeodeTypeIds::CharArray:
 						{
 							array<Char>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
+					case apache::geode::client::GeodeTypeIds::CacheableInt64Array:
 						{
 							array<Int64>^ obj;
 							ReadObject(obj);
 							return obj;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableStringArray:
+					case apache::geode::client::GeodeTypeIds::CacheableStringArray:
 						{
 							return ReadStringArray();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableHashTable:
+					case apache::geode::client::GeodeTypeIds::CacheableHashTable:
 						{
 							return ReadHashtable();
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableHashMap:
+					case apache::geode::client::GeodeTypeIds::CacheableHashMap:
 						{
 							CacheableHashMap^ chm = static_cast<CacheableHashMap^>(CacheableHashMap::CreateDeserializable());
 							chm->FromData(this);
 							return chm->Value;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
+					case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap:
 						{
 							CacheableIdentityHashMap^ chm = static_cast<CacheableIdentityHashMap^>(CacheableIdentityHashMap::CreateDeserializable());
 							chm->FromData(this);
 							return chm->Value;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableVector:
+					case apache::geode::client::GeodeTypeIds::CacheableVector:
 						{
 							/*CacheableVector^ cv = static_cast<CacheableVector^>(CacheableVector::CreateDeserializable());
 							cv->FromData(this);
@@ -576,7 +576,7 @@ namespace Apache
               }
               return retA;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableArrayList:
+					case apache::geode::client::GeodeTypeIds::CacheableArrayList:
 						{
 							/*CacheableArrayList^ cv = static_cast<CacheableArrayList^>(CacheableArrayList::CreateDeserializable());
 							cv->FromData(this);
@@ -590,7 +590,7 @@ namespace Apache
               return retA;
 
 						}
-          case apache::geode::client::GemfireTypeIds::CacheableLinkedList:
+          case apache::geode::client::GeodeTypeIds::CacheableLinkedList:
 						{
 							/*CacheableArrayList^ cv = static_cast<CacheableArrayList^>(CacheableArrayList::CreateDeserializable());
 							cv->FromData(this);
@@ -604,7 +604,7 @@ namespace Apache
               return retA;
 
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableStack:
+					case apache::geode::client::GeodeTypeIds::CacheableStack:
 						{
 							CacheableStack^ cv = static_cast<CacheableStack^>(CacheableStack::CreateDeserializable());
 							cv->FromData(this);
@@ -623,7 +623,7 @@ namespace Apache
 					int64_t compId = typeId;
 					TypeFactoryMethodGeneric^ createType = nullptr;
 
-					if (compId == GemfireTypeIds::NullObj) {
+					if (compId == GeodeTypeIds::NullObj) {
 						return nullptr;
 					}
 					else if(compId == GemFireClassIds::PDX)
@@ -659,32 +659,32 @@ namespace Apache
             Object^ enumVal = Internal::PdxHelper::GetEnum(enumId);
             return enumVal;
           }
-					else if (compId == GemfireTypeIds::CacheableNullString) {
+					else if (compId == GeodeTypeIds::CacheableNullString) {
 						//return SerializablePtr(CacheableString::createDeserializable());
 						//TODO::
 						return nullptr;
 					}
-					else if (compId == GemfireTypeIdsImpl::CacheableUserData) {
+					else if (compId == GeodeTypeIdsImpl::CacheableUserData) {
 						int8_t classId = ReadByte();
 						//compId |= ( ( (int64_t)classId ) << 32 );
 						compId = (int64_t)classId;
-					} else if ( compId == GemfireTypeIdsImpl::CacheableUserData2 ) {
+					} else if ( compId == GeodeTypeIdsImpl::CacheableUserData2 ) {
 						int16_t classId = ReadInt16();
 						//compId |= ( ( (int64_t)classId ) << 32 );
 						compId = (int64_t)classId;
-					} else if ( compId == GemfireTypeIdsImpl::CacheableUserData4 ) {
+					} else if ( compId == GeodeTypeIdsImpl::CacheableUserData4 ) {
 						int32_t classId = ReadInt32();
 						//compId |= ( ( (int64_t)classId ) << 32 );
 						compId = (int64_t)classId;
-					}else if (compId == GemfireTypeIdsImpl::FixedIDByte) {//TODO: need to verify again
+					}else if (compId == GeodeTypeIdsImpl::FixedIDByte) {//TODO: need to verify again
 						int8_t fixedId = ReadByte();
 						compId = fixedId;
 						findinternal = true;
-					} else if (compId == GemfireTypeIdsImpl::FixedIDShort) {
+					} else if (compId == GeodeTypeIdsImpl::FixedIDShort) {
 						int16_t fixedId = ReadInt16();
 						compId = fixedId;
 						findinternal = true;
-					} else if (compId == GemfireTypeIdsImpl::FixedIDInt) {
+					} else if (compId == GeodeTypeIdsImpl::FixedIDInt) {
 						int32_t fixedId = ReadInt32();
 						compId = fixedId;
 						findinternal = true;
@@ -701,7 +701,7 @@ namespace Apache
 								if(retVal != nullptr)
 									return retVal;
 
-                if(m_ispdxDesrialization && typeId == apache::geode::client::GemfireTypeIds::CacheableObjectArray)
+                if(m_ispdxDesrialization && typeId == apache::geode::client::GeodeTypeIds::CacheableObjectArray)
                 {//object array and pdxSerialization
                   return readDotNetObjectArray();
                 }
@@ -767,39 +767,39 @@ namespace Apache
 					int64_t compId = typeId;
 					TypeFactoryMethodGeneric^ createType = nullptr;
 
-					if (compId == GemfireTypeIds::NullObj) {
+					if (compId == GeodeTypeIds::NullObj) {
 						return nullptr;
 					}
 					else if(compId == GemFireClassIds::PDX)
 					{
 						return Internal::PdxHelper::DeserializePdx(this, false);
 					}
-					else if (compId == GemfireTypeIds::CacheableNullString) {
+					else if (compId == GeodeTypeIds::CacheableNullString) {
 						//return SerializablePtr(CacheableString::createDeserializable());
 						//TODO::
 						return nullptr;
 					}
-					else if (compId == GemfireTypeIdsImpl::CacheableUserData) {
+					else if (compId == GeodeTypeIdsImpl::CacheableUserData) {
 						int8_t classId = ReadByte();
 						//compId |= ( ( (int64_t)classId ) << 32 );
 						compId = (int64_t)classId;
-					} else if ( compId == GemfireTypeIdsImpl::CacheableUserData2 ) {
+					} else if ( compId == GeodeTypeIdsImpl::CacheableUserData2 ) {
 						int16_t classId = ReadInt16();
 						//compId |= ( ( (int64_t)classId ) << 32 );
 						compId = (int64_t)classId;
-					} else if ( compId == GemfireTypeIdsImpl::CacheableUserData4 ) {
+					} else if ( compId == GeodeTypeIdsImpl::CacheableUserData4 ) {
 						int32_t classId = ReadInt32();
 						//compId |= ( ( (int64_t)classId ) << 32 );
 						compId = (int64_t)classId;
-					}else if (compId == GemfireTypeIdsImpl::FixedIDByte) {//TODO: need to verify again
+					}else if (compId == GeodeTypeIdsImpl::FixedIDByte) {//TODO: need to verify again
 						int8_t fixedId = ReadByte();
 						compId = fixedId;
 						findinternal = true;
-					} else if (compId == GemfireTypeIdsImpl::FixedIDShort) {
+					} else if (compId == GeodeTypeIdsImpl::FixedIDShort) {
 						int16_t fixedId = ReadInt16();
 						compId = fixedId;
 						findinternal = true;
-					} else if (compId == GemfireTypeIdsImpl::FixedIDInt) {
+					} else if (compId == GeodeTypeIdsImpl::FixedIDInt) {
 						int32_t fixedId = ReadInt32();
 						compId = fixedId;
 						findinternal = true;
@@ -1070,15 +1070,15 @@ namespace Apache
 				{
 					UInt32 typeId = (Int32)ReadByte() ;
 
-					if(typeId == GemfireTypeIds::CacheableNullString)
+					if(typeId == GeodeTypeIds::CacheableNullString)
 						return nullptr;
 
-				  if (typeId == GemfireTypeIds::CacheableASCIIString ||
-              typeId == GemfireTypeIds::CacheableString)
+				  if (typeId == GeodeTypeIds::CacheableASCIIString ||
+              typeId == GeodeTypeIds::CacheableString)
           {
             return ReadUTF();
           }
-          else if (typeId == GemfireTypeIds::CacheableASCIIStringHuge)
+          else if (typeId == GeodeTypeIds::CacheableASCIIStringHuge)
           {
             return ReadASCIIHuge();
           }

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/DataOutput.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/DataOutput.cpp b/src/clicache/src/DataOutput.cpp
index 4bd0f15..7a3d39e 100644
--- a/src/clicache/src/DataOutput.cpp
+++ b/src/clicache/src/DataOutput.cpp
@@ -290,9 +290,9 @@ namespace Apache
       {
         System::Collections::IList^ list = (System::Collections::IList^)objectArray;
         this->WriteArrayLen(list->Count);
-        WriteByte((int8_t)apache::geode::client::GemfireTypeIdsImpl::Class);
+        WriteByte((int8_t)apache::geode::client::GeodeTypeIdsImpl::Class);
         String^ pdxDomainClassname = Serializable::GetPdxTypeName(objectArray->GetType()->GetElementType()->FullName);
-        WriteByte((int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIString);
+        WriteByte((int8_t)apache::geode::client::GeodeTypeIds::CacheableASCIIString);
         WriteUTF(pdxDomainClassname);
         for each(Object^ o in list)
           WriteObject(o);
@@ -338,12 +338,12 @@ namespace Apache
           {
             if(len == value->Length)//huge ascii
             {
-              WriteByte(GemfireTypeIds::CacheableASCIIStringHuge);
+              WriteByte(GeodeTypeIds::CacheableASCIIStringHuge);
               WriteASCIIHuge(value);
             }
             else//huge utf
             {
-              WriteByte(GemfireTypeIds::CacheableStringHuge);
+              WriteByte(GeodeTypeIds::CacheableStringHuge);
               WriteUTFHuge(value);
             }
             return;
@@ -351,11 +351,11 @@ namespace Apache
 
 		      if(len == value->Length)
           {
-            WriteByte(GemfireTypeIds::CacheableASCIIString);//ascii string
+            WriteByte(GeodeTypeIds::CacheableASCIIString);//ascii string
           }
           else
           {
-            WriteByte(GemfireTypeIds::CacheableString);//utf string
+            WriteByte(GeodeTypeIds::CacheableString);//utf string
           }
           WriteUInt16(len);
 					EnsureCapacity(len);
@@ -412,13 +412,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;
 						}
 				}
 
@@ -441,7 +441,7 @@ namespace Apache
 					
 					if ( obj == nullptr ) 
 					{
-						WriteByte( (int8_t) GemfireTypeIds::NullObj );
+						WriteByte( (int8_t) GeodeTypeIds::NullObj );
 						return;
 					}
           
@@ -461,31 +461,31 @@ namespace Apache
 
 					switch(typeId)
 					{
-					case apache::geode::client::GemfireTypeIds::CacheableByte:
+					case apache::geode::client::GeodeTypeIds::CacheableByte:
 						{
 							WriteByte(typeId);
 							WriteSByte((SByte)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableBoolean:
+					case apache::geode::client::GeodeTypeIds::CacheableBoolean:
 						{
 							WriteByte(typeId);
 							WriteBoolean((bool)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableWideChar:
+					case apache::geode::client::GeodeTypeIds::CacheableWideChar:
 						{
 							WriteByte(typeId);
 							WriteObject((Char)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableDouble:
+					case apache::geode::client::GeodeTypeIds::CacheableDouble:
 						{
 							WriteByte(typeId);
 							WriteDouble((Double)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableASCIIString:
+					case apache::geode::client::GeodeTypeIds::CacheableASCIIString:
 						{
 							//CacheableString^ cStr = CacheableString::Create((String^)obj);
 							////  TODO: igfser mapping between generic and non generic
@@ -493,31 +493,31 @@ namespace Apache
               WriteStringWithType((String^)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableFloat:
+					case apache::geode::client::GeodeTypeIds::CacheableFloat:
 						{
 							WriteByte(typeId);
 							WriteFloat((float)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt16:
+					case apache::geode::client::GeodeTypeIds::CacheableInt16:
 						{
 							WriteByte(typeId);
 							WriteInt16((Int16)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt32:
+					case apache::geode::client::GeodeTypeIds::CacheableInt32:
 						{
 							WriteByte(typeId);
 							WriteInt32((Int32)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt64:
+					case apache::geode::client::GeodeTypeIds::CacheableInt64:
 						{
 							WriteByte(typeId);
 							WriteInt64((Int64)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableDate:
+					case apache::geode::client::GeodeTypeIds::CacheableDate:
 						{
 							//CacheableDate^ cd = gcnew CacheableDate((DateTime)obj);
 							//  TODO: igfser mapping between generic and non generic
@@ -526,99 +526,99 @@ namespace Apache
 							WriteDate((DateTime)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableBytes:
+					case apache::geode::client::GeodeTypeIds::CacheableBytes:
 						{
 							WriteByte(typeId);
 							WriteBytes((array<Byte>^)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableDoubleArray:
+					case apache::geode::client::GeodeTypeIds::CacheableDoubleArray:
 						{
 							WriteByte(typeId);
 							WriteObject((array<Double>^)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableFloatArray:
+					case apache::geode::client::GeodeTypeIds::CacheableFloatArray:
 					{
 							WriteByte(typeId);
 							WriteObject((array<float>^)obj);
 							return;
 						}
-					case apache::geode::client::GemfireTypeIds::CacheableInt16Array:
+					case apache::geode::client::GeodeTypeIds::CacheableInt16Array:
 					{
 							WriteByte(typeId);
 							WriteObject((array<Int16>^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::CacheableInt32Array:
+					case apache::geode::client::GeodeTypeIds::CacheableInt32Array:
 					{
 							WriteByte(typeId);
 							WriteObject((array<Int32>^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::CacheableInt64Array:
+					case apache::geode::client::GeodeTypeIds::CacheableInt64Array:
 					{
 							WriteByte(typeId);
 							WriteObject((array<Int64>^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::BooleanArray:
+					case apache::geode::client::GeodeTypeIds::BooleanArray:
 					{
 							WriteByte(typeId);
 							WriteObject((array<bool>^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::CharArray:
+					case apache::geode::client::GeodeTypeIds::CharArray:
 					{
 							WriteByte(typeId);
 							WriteObject((array<char>^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::CacheableStringArray:
+					case apache::geode::client::GeodeTypeIds::CacheableStringArray:
 					{
 							WriteByte(typeId);
 							WriteObject((array<String^>^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::CacheableHashTable:
-					case apache::geode::client::GemfireTypeIds::CacheableHashMap:
-					case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap:
+					case apache::geode::client::GeodeTypeIds::CacheableHashTable:
+					case apache::geode::client::GeodeTypeIds::CacheableHashMap:
+					case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap:
 					{
 							WriteByte(typeId);
 							WriteDictionary((System::Collections::IDictionary^)obj);
 							return;
 					}
-					case apache::geode::client::GemfireTypeIds::CacheableVector:
+					case apache::geode::client::GeodeTypeIds::CacheableVector:
 					{
 						//CacheableVector^ cv = gcnew CacheableVector((System::Collections::IList^)obj);
 						////  TODO: igfser mapping between generic and non generic
 						//WriteObjectInternal(cv);
-            WriteByte(apache::geode::client::GemfireTypeIds::CacheableVector);
+            WriteByte(apache::geode::client::GeodeTypeIds::CacheableVector);
             WriteList((System::Collections::IList^)obj);
 						return;
 					}
-          case apache::geode::client::GemfireTypeIds::CacheableLinkedList:
+          case apache::geode::client::GeodeTypeIds::CacheableLinkedList:
 					{
 						//CacheableArrayList^ cal = gcnew CacheableArrayList((System::Collections::IList^)obj);
 						////  TODO: igfser mapping between generic and non generic
 						//WriteObjectInternal(cal);
-            WriteByte(apache::geode::client::GemfireTypeIds::CacheableLinkedList);
+            WriteByte(apache::geode::client::GeodeTypeIds::CacheableLinkedList);
             System::Collections::ICollection^ linkedList = (System::Collections::ICollection^)obj;
             this->WriteArrayLen(linkedList->Count);
             for each (Object^ o in linkedList) 
 						  this->WriteObject(o);
 						return;
 					}
-          case apache::geode::client::GemfireTypeIds::CacheableArrayList:
+          case apache::geode::client::GeodeTypeIds::CacheableArrayList:
 					{
 						//CacheableArrayList^ cal = gcnew CacheableArrayList((System::Collections::IList^)obj);
 						////  TODO: igfser mapping between generic and non generic
 						//WriteObjectInternal(cal);
-            WriteByte(apache::geode::client::GemfireTypeIds::CacheableArrayList);
+            WriteByte(apache::geode::client::GeodeTypeIds::CacheableArrayList);
             WriteList((System::Collections::IList^)obj);
 						return;
 					}
-					case apache::geode::client::GemfireTypeIds::CacheableStack:
+					case apache::geode::client::GeodeTypeIds::CacheableStack:
 					{
 						CacheableStack^ cs = gcnew CacheableStack((System::Collections::ICollection^)obj);
 						//  TODO: igfser mapping between generic and non generic
@@ -639,7 +639,7 @@ namespace Apache
                 //pdx serialization and is array of object
                 if(m_ispdxSerialization && obj->GetType()->IsArray)
                 {
-                  WriteByte(apache::geode::client::GemfireTypeIds::CacheableObjectArray);
+                  WriteByte(apache::geode::client::GeodeTypeIds::CacheableObjectArray);
                   WriteDotNetObjectArray(obj);
                   return;
                 }
@@ -683,20 +683,20 @@ namespace Apache
 				{
 					//CacheableKey^ key = gcnew CacheableKey();
 					if ( obj == nullptr ) {
-						WriteByte( (int8_t) GemfireTypeIds::NullObj );
+						WriteByte( (int8_t) GeodeTypeIds::NullObj );
 					} else {
 						int8_t typeId = DataOutput::GetTypeId( obj->ClassId);
 						switch (DataOutput::DSFID(obj->ClassId)) {
-							case GemfireTypeIdsImpl::FixedIDByte:
-								WriteByte((int8_t)GemfireTypeIdsImpl::FixedIDByte);
+							case GeodeTypeIdsImpl::FixedIDByte:
+								WriteByte((int8_t)GeodeTypeIdsImpl::FixedIDByte);
 								WriteByte( typeId ); // write the type ID.
 								break;
-							case GemfireTypeIdsImpl::FixedIDShort:
-								WriteByte((int8_t)GemfireTypeIdsImpl::FixedIDShort);
+							case GeodeTypeIdsImpl::FixedIDShort:
+								WriteByte((int8_t)GeodeTypeIdsImpl::FixedIDShort);
 								WriteInt16( (int16_t)typeId ); // write the type ID.
 								break;
-							case GemfireTypeIdsImpl::FixedIDInt:
-								WriteByte((int8_t)GemfireTypeIdsImpl::FixedIDInt);
+							case GeodeTypeIdsImpl::FixedIDInt:
+								WriteByte((int8_t)GeodeTypeIdsImpl::FixedIDInt);
 								WriteInt32( (int32_t)typeId ); // write the type ID.
 								break;
 							default:
@@ -704,11 +704,11 @@ namespace Apache
 								break;
 						}
 	          
-						if ( (int32_t)typeId == GemfireTypeIdsImpl::CacheableUserData ) {
+						if ( (int32_t)typeId == GeodeTypeIdsImpl::CacheableUserData ) {
 							WriteByte( (int8_t) obj->ClassId );
-						} else if ( (int32_t)typeId == GemfireTypeIdsImpl::CacheableUserData2 ) {
+						} else if ( (int32_t)typeId == GeodeTypeIdsImpl::CacheableUserData2 ) {
 							WriteInt16( (int16_t) obj->ClassId );
-						} else if ( (int32_t)typeId == GemfireTypeIdsImpl::CacheableUserData4 ) {
+						} else if ( (int32_t)typeId == GeodeTypeIdsImpl::CacheableUserData4 ) {
 							WriteInt32( (int32_t) obj->ClassId );
 						}
 						obj->ToData( this ); // let the obj serialize itself.
@@ -764,7 +764,7 @@ namespace Apache
 				{
 					if(value == nullptr)
 					{
-						this->WriteByte(GemfireTypeIds::CacheableNullString);
+						this->WriteByte(GeodeTypeIds::CacheableNullString);
 					}
 					else
 					{

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/DistributedSystem.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/DistributedSystem.cpp b/src/clicache/src/DistributedSystem.cpp
index 950a712..7b0acfa 100644
--- a/src/clicache/src/DistributedSystem.cpp
+++ b/src/clicache/src/DistributedSystem.cpp
@@ -267,128 +267,128 @@ namespace Apache
           /*
             Serializable::RegisterWrapperGeneric(
               gcnew WrapperDelegateGeneric(Apache::Geode::Client::CacheableHashSet::Create),
-              apache::geode::client::GemfireTypeIds::CacheableHashSet);
+              apache::geode::client::GeodeTypeIds::CacheableHashSet);
             
              Serializable::RegisterWrapperGeneric(
               gcnew WrapperDelegateGeneric(Apache::Geode::Client::CacheableLinkedHashSet::Create),
-              apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet);
+              apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet);
 
              Serializable::RegisterWrapperGeneric(
               gcnew WrapperDelegateGeneric(Apache::Geode::Client::Struct::Create),
-              apache::geode::client::GemfireTypeIds::Struct);
+              apache::geode::client::GeodeTypeIds::Struct);
             
              Serializable::RegisterWrapperGeneric(
               gcnew WrapperDelegateGeneric(Apache::Geode::Client::Properties::CreateDeserializable),
-              apache::geode::client::GemfireTypeIds::Properties);
+              apache::geode::client::GeodeTypeIds::Properties);
 
           // End register wrapper types for built-in types
 
   // Register with cpp using unmanaged Cacheablekey wrapper
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableByte,
+              apache::geode::client::GeodeTypeIds::CacheableByte,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableByte::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableBoolean,
+              apache::geode::client::GeodeTypeIds::CacheableBoolean,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableBoolean::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableBytes,
+              apache::geode::client::GeodeTypeIds::CacheableBytes,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableBytes::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::BooleanArray, 
+              apache::geode::client::GeodeTypeIds::BooleanArray, 
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::BooleanArray::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableWideChar,
+              apache::geode::client::GeodeTypeIds::CacheableWideChar,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableCharacter::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CharArray,
+              apache::geode::client::GeodeTypeIds::CharArray,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CharArray::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableDouble,
+              apache::geode::client::GeodeTypeIds::CacheableDouble,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableDouble::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableDoubleArray,
+              apache::geode::client::GeodeTypeIds::CacheableDoubleArray,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableDoubleArray::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableFloat,
+              apache::geode::client::GeodeTypeIds::CacheableFloat,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableFloat::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableFloatArray,
+              apache::geode::client::GeodeTypeIds::CacheableFloatArray,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableFloatArray::CreateDeserializable));
 
            
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableHashSet,
+              apache::geode::client::GeodeTypeIds::CacheableHashSet,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableHashSet::CreateDeserializable));
 
            Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet,
+              apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableLinkedHashSet::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt16,
+              apache::geode::client::GeodeTypeIds::CacheableInt16,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableInt16::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt16Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt16Array,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableInt16Array::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt32,
+              apache::geode::client::GeodeTypeIds::CacheableInt32,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableInt32::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt32Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt32Array,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableInt32Array::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt64,
+              apache::geode::client::GeodeTypeIds::CacheableInt64,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableInt64::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt64Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt64Array,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableInt64Array::CreateDeserializable));
               */
 
             /*Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableASCIIString,
+              apache::geode::client::GeodeTypeIds::CacheableASCIIString,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableString::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge,
+              apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableString::createDeserializableHuge));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableString,
+              apache::geode::client::GeodeTypeIds::CacheableString,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableString::createUTFDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableStringHuge,
+              apache::geode::client::GeodeTypeIds::CacheableStringHuge,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableString::createUTFDeserializableHuge));*/
 
             /*
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableNullString,
+              apache::geode::client::GeodeTypeIds::CacheableNullString,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableString::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableStringArray,
+              apache::geode::client::GeodeTypeIds::CacheableStringArray,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableStringArray::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::Struct,
+              apache::geode::client::GeodeTypeIds::Struct,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::Struct::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::Properties,
+              apache::geode::client::GeodeTypeIds::Properties,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::Properties::CreateDeserializable));
             */
             
@@ -400,183 +400,183 @@ namespace Apache
 
          /* Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableByte::Create),
-            apache::geode::client::GemfireTypeIds::CacheableByte, Byte::typeid);*/
+            apache::geode::client::GeodeTypeIds::CacheableByte, Byte::typeid);*/
 
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableByte::Create),
-            apache::geode::client::GemfireTypeIds::CacheableByte, SByte::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableByte, SByte::typeid);
           
           //boolean
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableBoolean::Create),
-            apache::geode::client::GemfireTypeIds::CacheableBoolean, Boolean::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableBoolean, Boolean::typeid);
           //wide char
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableCharacter::Create),
-            apache::geode::client::GemfireTypeIds::CacheableWideChar, Char::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableWideChar, Char::typeid);
           //double
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableDouble::Create),
-            apache::geode::client::GemfireTypeIds::CacheableDouble, Double::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableDouble, Double::typeid);
           //ascii string
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableString::Create),
-            apache::geode::client::GemfireTypeIds::CacheableASCIIString, String::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableASCIIString, String::typeid);
             
           //TODO:
           ////ascii string huge
           //Serializable::RegisterWrapperGeneric(
           //  gcnew WrapperDelegateGeneric(CacheableString::Create),
-          //  apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge, String::typeid);
+          //  apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge, String::typeid);
           ////string
           //Serializable::RegisterWrapperGeneric(
           //  gcnew WrapperDelegateGeneric(CacheableString::Create),
-          //  apache::geode::client::GemfireTypeIds::CacheableString, String::typeid);
+          //  apache::geode::client::GeodeTypeIds::CacheableString, String::typeid);
           ////string huge
           //Serializable::RegisterWrapperGeneric(
           //  gcnew WrapperDelegateGeneric(CacheableString::Create),
-          //  apache::geode::client::GemfireTypeIds::CacheableStringHuge, String::typeid);
+          //  apache::geode::client::GeodeTypeIds::CacheableStringHuge, String::typeid);
           //float
 
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableFloat::Create),
-            apache::geode::client::GemfireTypeIds::CacheableFloat, float::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableFloat, float::typeid);
           //int 16
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableInt16::Create),
-            apache::geode::client::GemfireTypeIds::CacheableInt16, Int16::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableInt16, Int16::typeid);
           //int32
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableInt32::Create),
-            apache::geode::client::GemfireTypeIds::CacheableInt32, Int32::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableInt32, Int32::typeid);
           //int64
           Serializable::RegisterWrapperGeneric(
             gcnew WrapperDelegateGeneric(CacheableInt64::Create),
-            apache::geode::client::GemfireTypeIds::CacheableInt64, Int64::typeid);
+            apache::geode::client::GeodeTypeIds::CacheableInt64, Int64::typeid);
 
           ////uint16
           //Serializable::RegisterWrapperGeneric(
           //  gcnew WrapperDelegateGeneric(CacheableInt16::Create),
-          //  apache::geode::client::GemfireTypeIds::CacheableInt16, UInt16::typeid);
+          //  apache::geode::client::GeodeTypeIds::CacheableInt16, UInt16::typeid);
           ////uint32
           //Serializable::RegisterWrapperGeneric(
           //  gcnew WrapperDelegateGeneric(CacheableInt32::Create),
-          //  apache::geode::client::GemfireTypeIds::CacheableInt32, UInt32::typeid);
+          //  apache::geode::client::GeodeTypeIds::CacheableInt32, UInt32::typeid);
           ////uint64
           //Serializable::RegisterWrapperGeneric(
           //  gcnew WrapperDelegateGeneric(CacheableInt64::Create),
-          //  apache::geode::client::GemfireTypeIds::CacheableInt64, UInt64::typeid);
+          //  apache::geode::client::GeodeTypeIds::CacheableInt64, UInt64::typeid);
           //=======================================================================
 
             //Now onwards all will be wrap in managed cacheable key..
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableBytes,
+              apache::geode::client::GeodeTypeIds::CacheableBytes,
               gcnew TypeFactoryMethodGeneric(CacheableBytes::CreateDeserializable), 
               Type::GetType("System.Byte[]"));
 
            /* Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableBytes,
+              apache::geode::client::GeodeTypeIds::CacheableBytes,
               gcnew TypeFactoryMethodGeneric(CacheableBytes::CreateDeserializable), 
               Type::GetType("System.SByte[]"));*/
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableDoubleArray,
+              apache::geode::client::GeodeTypeIds::CacheableDoubleArray,
               gcnew TypeFactoryMethodGeneric(CacheableDoubleArray::CreateDeserializable),
               Type::GetType("System.Double[]"));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableFloatArray,
+              apache::geode::client::GeodeTypeIds::CacheableFloatArray,
               gcnew TypeFactoryMethodGeneric(CacheableFloatArray::CreateDeserializable),
               Type::GetType("System.Single[]"));
 
            //TODO:
             //as it is
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableHashSet,
+              apache::geode::client::GeodeTypeIds::CacheableHashSet,
               gcnew TypeFactoryMethodGeneric(CacheableHashSet::CreateDeserializable),
               nullptr);
 
             //as it is
            Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet,
+              apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet,
               gcnew TypeFactoryMethodGeneric(CacheableLinkedHashSet::CreateDeserializable),
               nullptr);
 
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt16Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt16Array,
               gcnew TypeFactoryMethodGeneric(CacheableInt16Array::CreateDeserializable),
               Type::GetType("System.Int16[]"));
 
           /*  Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt16Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt16Array,
               gcnew TypeFactoryMethodGeneric(CacheableInt16Array::CreateDeserializable),
               Type::GetType("System.UInt16[]"));*/
 
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt32Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt32Array,
               gcnew TypeFactoryMethodGeneric(CacheableInt32Array::CreateDeserializable),
               Type::GetType("System.Int32[]"));
 
            /* Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt32Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt32Array,
               gcnew TypeFactoryMethodGeneric(CacheableInt32Array::CreateDeserializable),
               Type::GetType("System.UInt32[]"));*/
 
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt64Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt64Array,
               gcnew TypeFactoryMethodGeneric(CacheableInt64Array::CreateDeserializable),
               Type::GetType("System.Int64[]"));
 
            /* Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableInt64Array,
+              apache::geode::client::GeodeTypeIds::CacheableInt64Array,
               gcnew TypeFactoryMethodGeneric(CacheableInt64Array::CreateDeserializable),
               Type::GetType("System.UInt64[]"));*/
 						//TODO:;split
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::BooleanArray,
+              apache::geode::client::GeodeTypeIds::BooleanArray,
               gcnew TypeFactoryMethodGeneric(BooleanArray::CreateDeserializable),
               Type::GetType("System.Boolean[]"));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CharArray,
+              apache::geode::client::GeodeTypeIds::CharArray,
               gcnew TypeFactoryMethodGeneric(CharArray::CreateDeserializable),
               Type::GetType("System.Char[]"));
 
             //TODO::
 
             //Serializable::RegisterTypeGeneric(
-            //  apache::geode::client::GemfireTypeIds::CacheableNullString,
+            //  apache::geode::client::GeodeTypeIds::CacheableNullString,
             //  gcnew TypeFactoryMethodNew(Apache::Geode::Client::CacheableString::CreateDeserializable));
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableStringArray,
+              apache::geode::client::GeodeTypeIds::CacheableStringArray,
               gcnew TypeFactoryMethodGeneric(CacheableStringArray::CreateDeserializable),
               Type::GetType("System.String[]"));
 
             //as it is
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::Struct,
+              apache::geode::client::GeodeTypeIds::Struct,
               gcnew TypeFactoryMethodGeneric(Struct::CreateDeserializable),
               nullptr);
 
             //as it is
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::Properties,
+              apache::geode::client::GeodeTypeIds::Properties,
               gcnew TypeFactoryMethodGeneric(Properties<String^, String^>::CreateDeserializable),
               nullptr);
               
           /*  Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::PdxType,
+              apache::geode::client::GeodeTypeIds::PdxType,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::Internal::PdxType::CreateDeserializable),
               nullptr);*/
 
             Serializable::RegisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::EnumInfo,
+              apache::geode::client::GeodeTypeIds::EnumInfo,
               gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::Internal::EnumInfo::CreateDeserializable),
               nullptr);
           
@@ -616,36 +616,36 @@ namespace Apache
         // Register other built-in types
         /*
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableDate,
+          apache::geode::client::GeodeTypeIds::CacheableDate,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableDate::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableFileName,
+          apache::geode::client::GeodeTypeIds::CacheableFileName,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableFileName::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableHashMap,
+          apache::geode::client::GeodeTypeIds::CacheableHashMap,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableHashMap::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableHashTable,
+          apache::geode::client::GeodeTypeIds::CacheableHashTable,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableHashTable::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap,
+          apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap,
           gcnew TypeFactoryMethodGeneric(
           Apache::Geode::Client::CacheableIdentityHashMap::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableUndefined,
+          apache::geode::client::GeodeTypeIds::CacheableUndefined,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableUndefined::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableVector,
+          apache::geode::client::GeodeTypeIds::CacheableVector,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableVector::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableObjectArray,
+          apache::geode::client::GeodeTypeIds::CacheableObjectArray,
           gcnew TypeFactoryMethodGeneric(
           Apache::Geode::Client::CacheableObjectArray::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableArrayList,
+          apache::geode::client::GeodeTypeIds::CacheableArrayList,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableArrayList::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableStack,
+          apache::geode::client::GeodeTypeIds::CacheableStack,
           gcnew TypeFactoryMethodGeneric(Apache::Geode::Client::CacheableStack::CreateDeserializable));
         Serializable::RegisterTypeGeneric(
           GemFireClassIds::CacheableManagedObject - 0x80000000,
@@ -660,63 +660,63 @@ namespace Apache
         //c# datatime
         
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableDate,
+          apache::geode::client::GeodeTypeIds::CacheableDate,
           gcnew TypeFactoryMethodGeneric(CacheableDate::CreateDeserializable),
           Type::GetType("System.DateTime"));
         
         //as it is
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableFileName,
+          apache::geode::client::GeodeTypeIds::CacheableFileName,
           gcnew TypeFactoryMethodGeneric(CacheableFileName::CreateDeserializable),
           nullptr);
         
         //for generic dictionary define its type in static constructor of Serializable.hpp
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableHashMap,
+          apache::geode::client::GeodeTypeIds::CacheableHashMap,
           gcnew TypeFactoryMethodGeneric(CacheableHashMap::CreateDeserializable),
           nullptr);
 
         //c# hashtable
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableHashTable,
+          apache::geode::client::GeodeTypeIds::CacheableHashTable,
           gcnew TypeFactoryMethodGeneric(CacheableHashTable::CreateDeserializable),
           Type::GetType("System.Collections.Hashtable"));
 
         //Need to keep public as no counterpart in c#
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap,
+          apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap,
           gcnew TypeFactoryMethodGeneric(
           CacheableIdentityHashMap::CreateDeserializable),
           nullptr);
         
         //keep as it is
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableUndefined,
+          apache::geode::client::GeodeTypeIds::CacheableUndefined,
           gcnew TypeFactoryMethodGeneric(CacheableUndefined::CreateDeserializable),
           nullptr);
 
         //c# arraylist
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableVector,
+          apache::geode::client::GeodeTypeIds::CacheableVector,
           gcnew TypeFactoryMethodGeneric(CacheableVector::CreateDeserializable),
           nullptr);
 
         //as it is
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableObjectArray,
+          apache::geode::client::GeodeTypeIds::CacheableObjectArray,
           gcnew TypeFactoryMethodGeneric(
           CacheableObjectArray::CreateDeserializable),
           nullptr);
 
         //Generic::List
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableArrayList,
+          apache::geode::client::GeodeTypeIds::CacheableArrayList,
           gcnew TypeFactoryMethodGeneric(CacheableArrayList::CreateDeserializable),
           nullptr);
         
         //c# generic stack 
         Serializable::RegisterTypeGeneric(
-          apache::geode::client::GemfireTypeIds::CacheableStack,
+          apache::geode::client::GeodeTypeIds::CacheableStack,
           gcnew TypeFactoryMethodGeneric(CacheableStack::CreateDeserializable),
           nullptr);
 
@@ -772,23 +772,23 @@ namespace Apache
            
             
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableDate);
+              apache::geode::client::GeodeTypeIds::CacheableDate);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableFileName);
+              apache::geode::client::GeodeTypeIds::CacheableFileName);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableHashMap);
+              apache::geode::client::GeodeTypeIds::CacheableHashMap);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableHashTable);
+              apache::geode::client::GeodeTypeIds::CacheableHashTable);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap);
+              apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableVector);
+              apache::geode::client::GeodeTypeIds::CacheableVector);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableObjectArray);
+              apache::geode::client::GeodeTypeIds::CacheableObjectArray);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableArrayList);
+              apache::geode::client::GeodeTypeIds::CacheableArrayList);
             Serializable::UnregisterTypeGeneric(
-              apache::geode::client::GemfireTypeIds::CacheableStack);
+              apache::geode::client::GeodeTypeIds::CacheableStack);
             Serializable::UnregisterTypeGeneric(
               GemFireClassIds::CacheableManagedObject - 0x80000000);
             Serializable::UnregisterTypeGeneric(

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/GemFireClassIds.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/GemFireClassIds.hpp b/src/clicache/src/GemFireClassIds.hpp
index bfe3063..cc5707a 100644
--- a/src/clicache/src/GemFireClassIds.hpp
+++ b/src/clicache/src/GemFireClassIds.hpp
@@ -70,25 +70,25 @@ namespace Apache
         /// ClassId of <c>Properties</c> class
         /// </summary>
         literal uint32_t Properties =
-          apache::geode::client::GemfireTypeIds::Properties + 0x80000000;
+          apache::geode::client::GeodeTypeIds::Properties + 0x80000000;
 
         /// <summary>        
         /// ClassId of <c>CharArray</c> class
         /// </summary>
         literal uint32_t CharArray =
-          apache::geode::client::GemfireTypeIds::CharArray + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CharArray + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>BooleanArray</c> class
         /// </summary>
         literal uint32_t BooleanArray =
-          apache::geode::client::GemfireTypeIds::BooleanArray + 0x80000000;
+          apache::geode::client::GeodeTypeIds::BooleanArray + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>RegionAttributes</c> class
         /// </summary>
         literal uint32_t RegionAttributes =
-          apache::geode::client::GemfireTypeIds::RegionAttributes + 0x80000000;
+          apache::geode::client::GeodeTypeIds::RegionAttributes + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableUndefined</c> class
@@ -96,214 +96,214 @@ namespace Apache
         /// different increment.
         /// </summary>
         literal uint32_t CacheableUndefined =
-          apache::geode::client::GemfireTypeIds::CacheableUndefined + 0xa0000000;
+          apache::geode::client::GeodeTypeIds::CacheableUndefined + 0xa0000000;
 
         literal uint32_t EnumInfo =
-          apache::geode::client::GemfireTypeIds::EnumInfo + 0xa0000000;
+          apache::geode::client::GeodeTypeIds::EnumInfo + 0xa0000000;
 
         /// <summary>
         /// ClassId of <c>Struct</c> class
         /// </summary>
         literal uint32_t Struct =
-          apache::geode::client::GemfireTypeIds::Struct + 0x80000000;
+          apache::geode::client::GeodeTypeIds::Struct + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableString</c> class
         /// </summary>
         literal uint32_t CacheableString =
-          apache::geode::client::GemfireTypeIds::CacheableString + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableString + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableString</c> class for huge strings
         /// </summary>
         literal uint32_t CacheableStringHuge =
-          apache::geode::client::GemfireTypeIds::CacheableStringHuge + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableStringHuge + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableBytes</c> class
         /// </summary>
         literal uint32_t CacheableBytes =
-          apache::geode::client::GemfireTypeIds::CacheableBytes + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableBytes + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt16Array</c> class
         /// </summary>
         literal uint32_t CacheableInt16Array =
-          apache::geode::client::GemfireTypeIds::CacheableInt16Array + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableInt16Array + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt32Array</c> class
         /// </summary>
         literal uint32_t CacheableInt32Array =
-          apache::geode::client::GemfireTypeIds::CacheableInt32Array + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableInt32Array + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt64Array</c> class
         /// </summary>
         literal uint32_t CacheableInt64Array =
-          apache::geode::client::GemfireTypeIds::CacheableInt64Array + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableInt64Array + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableFloatArray</c> class
         /// </summary>
         literal uint32_t CacheableFloatArray =
-          apache::geode::client::GemfireTypeIds::CacheableFloatArray + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableFloatArray + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableDoubleArray</c> class
         /// </summary>
         literal uint32_t CacheableDoubleArray =
-          apache::geode::client::GemfireTypeIds::CacheableDoubleArray + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableDoubleArray + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableVector</c> class for object arrays
         /// </summary>
         literal uint32_t CacheableObjectArray =
-          apache::geode::client::GemfireTypeIds::CacheableObjectArray + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableObjectArray + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableBoolean</c> class
         /// </summary>
         literal uint32_t CacheableBoolean =
-          apache::geode::client::GemfireTypeIds::CacheableBoolean + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableBoolean + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt16</c> class for wide-characters
         /// </summary>
         literal uint32_t CacheableCharacter =
-          apache::geode::client::GemfireTypeIds::CacheableWideChar + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableWideChar + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableByte</c> class
         /// </summary>
         literal uint32_t CacheableByte =
-          apache::geode::client::GemfireTypeIds::CacheableByte + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableByte + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt16</c> class
         /// </summary>
         literal uint32_t CacheableInt16 =
-          apache::geode::client::GemfireTypeIds::CacheableInt16 + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableInt16 + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt32</c> class
         /// </summary>
         literal uint32_t CacheableInt32 =
-          apache::geode::client::GemfireTypeIds::CacheableInt32 + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableInt32 + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableInt64</c> class
         /// </summary>
         literal uint32_t CacheableInt64 =
-          apache::geode::client::GemfireTypeIds::CacheableInt64 + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableInt64 + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableFloat</c> class
         /// </summary>
         literal uint32_t CacheableFloat =
-          apache::geode::client::GemfireTypeIds::CacheableFloat + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableFloat + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableDouble</c> class
         /// </summary>
         literal uint32_t CacheableDouble =
-          apache::geode::client::GemfireTypeIds::CacheableDouble + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableDouble + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableDate</c> class
         /// </summary>
         literal uint32_t CacheableDate =
-          apache::geode::client::GemfireTypeIds::CacheableDate + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableDate + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableFileName</c> class
         /// </summary>
         literal uint32_t CacheableFileName =
-          apache::geode::client::GemfireTypeIds::CacheableFileName + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableFileName + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableStringArray</c> class
         /// </summary>
         literal uint32_t CacheableStringArray =
-          apache::geode::client::GemfireTypeIds::CacheableStringArray + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableStringArray + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableVector</c> class
         /// </summary>
         literal uint32_t CacheableVector =
-          apache::geode::client::GemfireTypeIds::CacheableVector + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableVector + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableStack</c> class
         /// </summary>
         literal uint32_t CacheableStack =
-          apache::geode::client::GemfireTypeIds::CacheableStack + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableStack + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableArrayList</c> class
         /// </summary>
         literal uint32_t CacheableArrayList =
-          apache::geode::client::GemfireTypeIds::CacheableArrayList + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableArrayList + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableArrayList</c> class
         /// </summary>
         literal uint32_t CacheableLinkedList =
-          apache::geode::client::GemfireTypeIds::CacheableLinkedList + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableLinkedList + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableHashSet</c> class
         /// </summary>
         literal uint32_t CacheableHashSet =
-          apache::geode::client::GemfireTypeIds::CacheableHashSet + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableHashSet + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableLinkedHashSet</c> class
         /// </summary>
         literal uint32_t CacheableLinkedHashSet =
-          apache::geode::client::GemfireTypeIds::CacheableLinkedHashSet + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableHashMap</c> class
         /// </summary>
         literal uint32_t CacheableHashMap =
-          apache::geode::client::GemfireTypeIds::CacheableHashMap + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableHashMap + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableHashTable</c> class
         /// </summary>
         literal uint32_t CacheableHashTable =
-          apache::geode::client::GemfireTypeIds::CacheableHashTable + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableHashTable + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableIdentityHashMap</c> class
         /// </summary>
         literal uint32_t CacheableIdentityHashMap =
-          apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap + 0x80000000;
 
         /// <summary>
         /// Not used.
         /// </summary>
         literal uint32_t CacheableTimeUnit =
-          apache::geode::client::GemfireTypeIds::CacheableTimeUnit + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableTimeUnit + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableString</c> class for null strings
         /// </summary>
         literal uint32_t CacheableNullString =
-          apache::geode::client::GemfireTypeIds::CacheableNullString + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableNullString + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableString</c> class for ASCII strings
         /// </summary>
         literal uint32_t CacheableASCIIString =
-          apache::geode::client::GemfireTypeIds::CacheableASCIIString + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableASCIIString + 0x80000000;
 
         /// <summary>
         /// ClassId of <c>CacheableString</c> class for huge ASCII strings
         /// </summary>
         literal uint32_t CacheableASCIIStringHuge =
-          apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge + 0x80000000;
+          apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge + 0x80000000;
 
 
         // Built-in managed types.
@@ -319,7 +319,7 @@ namespace Apache
         literal uint32_t CacheableManagedObjectXml = 8 + 0x80000000;
 				   internal:
 
-        literal uint32_t PdxType = apache::geode::client::GemfireTypeIds::PdxType + 0x80000000;
+        literal uint32_t PdxType = apache::geode::client::GeodeTypeIds::PdxType + 0x80000000;
 
         literal uint32_t DATA_SERIALIZABLE = 45;
         literal uint32_t JAVA_CLASS = 43;

http://git-wip-us.apache.org/repos/asf/geode/blob/49cc4f26/src/clicache/src/Properties.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Properties.cpp b/src/clicache/src/Properties.cpp
index 153849a..35b0bbc 100644
--- a/src/clicache/src/Properties.cpp
+++ b/src/clicache/src/Properties.cpp
@@ -119,8 +119,8 @@ namespace Apache
             return SafeUMSerializableConvert( value.ptr( ) );
           } 
           else {
-            if(cs->typeId() == (int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIString
-              || cs->typeId() == (int8_t)apache::geode::client::GemfireTypeIds::CacheableASCIIStringHuge) {
+            if(cs->typeId() == (int8_t)apache::geode::client::GeodeTypeIds::CacheableASCIIString
+              || cs->typeId() == (int8_t)apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge) {
               String^ str = gcnew String(cs->asChar());
               return CacheableString::Create(str);
             }


Mime
View raw message