Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 939F3200C0C for ; Mon, 30 Jan 2017 19:11:28 +0100 (CET) Received: by cust-asf.ponee.io (Postfix) id 92268160B35; Mon, 30 Jan 2017 18:11:28 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 9A5C2160B4D for ; Mon, 30 Jan 2017 19:11:25 +0100 (CET) Received: (qmail 63570 invoked by uid 500); 30 Jan 2017 18:11:24 -0000 Mailing-List: contact commits-help@geode.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@geode.apache.org Delivered-To: mailing list commits@geode.apache.org Received: (qmail 63548 invoked by uid 99); 30 Jan 2017 18:11:24 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 30 Jan 2017 18:11:24 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 98FBCDFE46; Mon, 30 Jan 2017 18:11:24 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: jbarrett@apache.org To: commits@geode.apache.org Date: Mon, 30 Jan 2017 18:11:25 -0000 Message-Id: <3219162b683c48e89c639684048c44a8@git.apache.org> In-Reply-To: <61c93042ee69465f97737d60a7ff2c19@git.apache.org> References: <61c93042ee69465f97737d60a7ff2c19@git.apache.org> X-Mailer: ASF-Git Admin Mailer 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. archived-at: Mon, 30 Jan 2017 18:11:28 -0000 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(Serializable::getByte(val)); /* if (TValue::typeid == System::SByte::typeid) { @@ -626,31 +626,31 @@ namespace Apache } return safe_cast(Serializable::getByte(val));*/ } - case apache::geode::client::GemfireTypeIds::CacheableBoolean: + case apache::geode::client::GeodeTypeIds::CacheableBoolean: { return safe_cast(Serializable::getBoolean(val)); } - case apache::geode::client::GemfireTypeIds::CacheableWideChar: + case apache::geode::client::GeodeTypeIds::CacheableWideChar: { return safe_cast(Serializable::getChar(val)); } - case apache::geode::client::GemfireTypeIds::CacheableDouble: + case apache::geode::client::GeodeTypeIds::CacheableDouble: { return safe_cast(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(Serializable::getASCIIString(val)); } - case apache::geode::client::GemfireTypeIds::CacheableFloat: + case apache::geode::client::GeodeTypeIds::CacheableFloat: { return safe_cast(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(Serializable::getInt16(val)); @@ -660,7 +660,7 @@ namespace Apache }*/ return safe_cast(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(Serializable::getInt32(val)); @@ -670,7 +670,7 @@ namespace Apache } */ return safe_cast(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(Serializable::getInt64(val)); @@ -680,7 +680,7 @@ namespace Apache }*/ return safe_cast(Serializable::getInt64(val)); } - case apache::geode::client::GemfireTypeIds::CacheableDate: + case apache::geode::client::GeodeTypeIds::CacheableDate: { //TODO:: Apache::Geode::Client::CacheableDate^ ret = static_cast @@ -689,16 +689,16 @@ namespace Apache System::DateTime dt(ret->Value.Ticks); return safe_cast(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(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(ret); } - case apache::geode::client::GemfireTypeIds::CacheableBytes: + case apache::geode::client::GeodeTypeIds::CacheableBytes: { Apache::Geode::Client::CacheableBytes^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableDoubleArray: + case apache::geode::client::GeodeTypeIds::CacheableDoubleArray: { Apache::Geode::Client::CacheableDoubleArray^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableFloatArray: + case apache::geode::client::GeodeTypeIds::CacheableFloatArray: { Apache::Geode::Client::CacheableFloatArray^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableInt16Array: + case apache::geode::client::GeodeTypeIds::CacheableInt16Array: { Apache::Geode::Client::CacheableInt16Array^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableInt32Array: + case apache::geode::client::GeodeTypeIds::CacheableInt32Array: { Apache::Geode::Client::CacheableInt32Array^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableInt64Array: + case apache::geode::client::GeodeTypeIds::CacheableInt64Array: { Apache::Geode::Client::CacheableInt64Array^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableStringArray: + case apache::geode::client::GeodeTypeIds::CacheableStringArray: { Apache::Geode::Client::CacheableStringArray^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); @@ -765,81 +765,81 @@ namespace Apache return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableIdentityHashMap: + case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap: { Apache::Geode::Client::CacheableIdentityHashMap^ ret = static_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret); } - case apache::geode::client::GemfireTypeIds::CacheableFileName: + case apache::geode::client::GeodeTypeIds::CacheableFileName: { Apache::Geode::Client::CacheableFileName^ ret = static_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret); } - case apache::geode::client::GemfireTypeIds::CacheableObjectArray: + case apache::geode::client::GeodeTypeIds::CacheableObjectArray: { Apache::Geode::Client::CacheableObjectArray^ ret = static_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret); } - case apache::geode::client::GemfireTypeIds::CacheableVector://collection::arraylist + case apache::geode::client::GeodeTypeIds::CacheableVector://collection::arraylist { Apache::Geode::Client::CacheableVector^ ret = static_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CacheableUndefined: + case apache::geode::client::GeodeTypeIds::CacheableUndefined: { Apache::Geode::Client::CacheableUndefined^ ret = static_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret); } - case apache::geode::client::GemfireTypeIds::Struct: + case apache::geode::client::GeodeTypeIds::Struct: { return safe_cast(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 ( SafeGenericUMSerializableConvert(val.ptr())); @@ -858,7 +858,7 @@ namespace Apache return safe_cast(ret); } /* TODO: replace with IDictionary - case apache::geode::client::GemfireTypeIds::Properties: + case apache::geode::client::GeodeTypeIds::Properties: { Apache::Geode::Client::Properties^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); @@ -866,14 +866,14 @@ namespace Apache return safe_cast(ret); }*/ - case apache::geode::client::GemfireTypeIds::BooleanArray: + case apache::geode::client::GeodeTypeIds::BooleanArray: { Apache::Geode::Client::BooleanArray^ ret = safe_cast ( SafeGenericUMSerializableConvert(val.ptr())); return safe_cast(ret->Value); } - case apache::geode::client::GemfireTypeIds::CharArray: + case apache::geode::client::GeodeTypeIds::CharArray: { Apache::Geode::Client::CharArray^ ret = safe_cast ( SafeGenericUMSerializableConvert(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^)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^)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^)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^)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^)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^)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^)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^)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^)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^)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^ dic = gcnew Dictionary(); - 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^ linketList = gcnew System::Collections::Generic::LinkedList(); - 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^ iList = gcnew System::Collections::Generic::List(); - 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^ stack = gcnew System::Collections::Generic::Stack(); - 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^ Float_DefaultBytes = gcnew array{0, 0, 0, 0}; static array^ Double_DefaultBytes = gcnew array{0, 0, 0, 0, 0, 0, 0, 0}; static array^ Date_DefaultBytes = gcnew array{-1, -1, -1, -1, -1, -1, -1, -1}; - static array^ String_DefaultBytes = gcnew array{apache::geode::client::GemfireTypeIds::CacheableNullString}; - static array^ Object_DefaultBytes = gcnew array{apache::geode::client::GemfireTypeIds::NullObj}; + static array^ String_DefaultBytes = gcnew array{apache::geode::client::GeodeTypeIds::CacheableNullString}; + static array^ Object_DefaultBytes = gcnew array{apache::geode::client::GeodeTypeIds::NullObj}; static array^ NULL_ARRAY_DefaultBytes = gcnew array{-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; \ - typedef CacheableKeyType \ + CacheableKeyType; \ + typedef CacheableKeyType \ _##k; \ class CPPCACHE_EXPORT k; \ typedef SharedPtr 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; \ - typedef CacheableArrayType _##c; \ + TEMPLATE_EXPORT CacheableArrayType; \ + typedef CacheableArrayType _##c; \ class CPPCACHE_EXPORT c; \ - typedef SharedArrayPtr c##Ptr; + typedef SharedArrayPtr 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; \ - typedef CacheableContainerType _##c; \ + TEMPLATE_EXPORT CacheableContainerType; \ + typedef CacheableContainerType _##c; \ class CPPCACHE_EXPORT c; \ typedef SharedPtr 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(GemfireTypeIds::CacheableEnum); + return static_cast(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 CacheableString this shall return - * GemfireTypeIds::CacheableNullString if the underlying - * string is null, GemfireTypeIds::CacheableASCIIString + * GeodeTypeIds::CacheableNullString if the underlying + * string is null, GeodeTypeIds::CacheableASCIIString * if the underlying string is a char*, and - * GemfireTypeIds::CacheableString if it is a wchar_t*. + * GeodeTypeIds::CacheableString if it is a wchar_t*. * For strings larger than 64K it will return - * GemfireTypeIds::CacheableASCIIStringHuge and - * GemfireTypeIds::CacheableStringHuge for char* and wchar_t* + * GeodeTypeIds::CacheableASCIIStringHuge and + * GeodeTypeIds::CacheableStringHuge 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::createDeserializable())); } else if (compId == - apache::geode::client::GemfireTypeIds::CacheableASCIIString) { + apache::geode::client::GeodeTypeIds::CacheableASCIIString) { csPtr = CacheableStringPtr(dynamic_cast( 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::createDeserializableHuge())); csPtr.ptr()->fromData(*this); } else if (compId == - apache::geode::client::GemfireTypeIds::CacheableString) { + apache::geode::client::GeodeTypeIds::CacheableString) { csPtr = CacheableStringPtr(dynamic_cast( CacheableString::createUTFDeserializable())); csPtr.ptr()->fromData(*this); } else if (compId == - apache::geode::client::GemfireTypeIds::CacheableStringHuge) { + apache::geode::client::GeodeTypeIds::CacheableStringHuge) { csPtr = CacheableStringPtr(dynamic_cast( 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(GemfireTypeIds::CacheableASCIIString) || - typeId == static_cast(GemfireTypeIds::CacheableString)) { + if (typeId == static_cast(GeodeTypeIds::CacheableASCIIString) || + typeId == static_cast(GeodeTypeIds::CacheableString)) { // readUTF( value); readASCII(value); // m_len = shortLen; } else if (typeId == static_cast( - GemfireTypeIds::CacheableASCIIStringHuge) || + GeodeTypeIds::CacheableASCIIStringHuge) || typeId == - static_cast(GemfireTypeIds::CacheableStringHuge)) { + static_cast(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(GemfireTypeIds::CacheableASCIIString) || - typeId == static_cast(GemfireTypeIds::CacheableString)) { + if (typeId == static_cast(GeodeTypeIds::CacheableASCIIString) || + typeId == static_cast(GeodeTypeIds::CacheableString)) { readUTF(value); } else if (typeId == static_cast( - GemfireTypeIds::CacheableASCIIStringHuge) || + GeodeTypeIds::CacheableASCIIStringHuge) || typeId == - static_cast(GemfireTypeIds::CacheableStringHuge)) { + static_cast(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(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(GemfireTypeIdsImpl::FixedIDByte); // Never used + return static_cast(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(GemfireTypeIds::CacheableEnum)); + output.write(static_cast(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(GemfireTypeIdsImpl::Class)); - output.write(static_cast(GemfireTypeIds::CacheableASCIIString)); + output.write(static_cast(GeodeTypeIdsImpl::Class)); + output.write(static_cast(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(GemfireTypeIdsImpl::CacheableToken); + return static_cast(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(GemfireTypeIdsImpl::ClientConnectionRequest); + return static_cast(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(GemfireTypeIdsImpl::ClientConnectionResponse); + return static_cast(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(GemfireTypeIdsImpl::FixedIDByte); + return static_cast(GeodeTypeIdsImpl::FixedIDByte); } int8_t ClientHealthStats::typeId() const { - return static_cast(GemfireTypeIdsImpl::ClientHealthStats); + return static_cast(GeodeTypeIdsImpl::ClientHealthStats); } ClientHealthStats::ClientHealthStats()