You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ec...@apache.org on 2018/08/10 22:10:25 UTC
[geode-native] branch develop updated: Refactor GeodeTypeIds enums
into DSCode, DSFid, and InternalId enums, make enums enum classes (#325)
This is an automated email from the ASF dual-hosted git repository.
echobravo pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git
The following commit(s) were added to refs/heads/develop by this push:
new 57c838f Refactor GeodeTypeIds enums into DSCode, DSFid, and InternalId enums, make enums enum classes (#325)
57c838f is described below
commit 57c838fb1a2e190455a640e4cd6a33093e756fb8
Author: Blake Bender <ek...@hotmail.com>
AuthorDate: Fri Aug 10 22:10:23 2018 +0000
Refactor GeodeTypeIds enums into DSCode, DSFid, and InternalId enums, make enums enum classes (#325)
Co-authored-by: Ivan Godwin <ig...@pivotal.io>
Co-authored-by: Jacob Barrett <jb...@pivotal.io>
---
clicache/src/CacheableArrayList.hpp | 2 +-
clicache/src/CacheableBuiltins.hpp | 18 +-
clicache/src/CacheableDate.cpp | 2 +-
clicache/src/CacheableFileName.cpp | 8 +-
clicache/src/CacheableHashMap.hpp | 2 +-
clicache/src/CacheableHashSet.hpp | 10 +-
clicache/src/CacheableHashTable.hpp | 2 +-
clicache/src/CacheableIdentityHashMap.hpp | 2 +-
clicache/src/CacheableLinkedList.hpp | 2 +-
clicache/src/CacheableObject.hpp | 2 +-
clicache/src/CacheableObjectArray.cpp | 5 +-
clicache/src/CacheableObjectArray.hpp | 2 +-
clicache/src/CacheableObjectXml.hpp | 2 +-
clicache/src/CacheableStack.cpp | 3 +-
clicache/src/CacheableString.cpp | 20 +-
clicache/src/CacheableString.hpp | 16 +-
clicache/src/CacheableStringArray.hpp | 2 +-
clicache/src/CacheableUndefined.hpp | 2 +-
clicache/src/CacheableVector.hpp | 2 +-
clicache/src/DataInput.cpp | 299 ++++++++++-----------
clicache/src/DataOutput.cpp | 147 +++++-----
clicache/src/DataOutput.hpp | 14 +-
clicache/src/DistributedSystem.cpp | 77 +++---
clicache/src/GeodeClassIds.hpp | 85 +++---
clicache/src/Properties.hpp | 2 +-
clicache/src/Serializable.cpp | 64 ++---
clicache/src/TypeRegistry.cpp | 98 +++----
clicache/src/TypeRegistry.hpp | 56 ++--
clicache/src/geode_includes.hpp | 2 +-
clicache/src/impl/EnumInfo.hpp | 2 +-
clicache/src/impl/ManagedCacheableDelta.cpp | 1 -
clicache/src/impl/ManagedCacheableKey.cpp | 1 -
clicache/src/impl/ManagedCacheableKey.hpp | 5 +-
clicache/src/impl/PdxFieldType.cpp | 1 -
clicache/src/impl/PdxInstanceFactoryImpl.cpp | 1 -
clicache/src/impl/PdxInstanceImpl.hpp | 4 +-
clicache/src/impl/PdxManagedCacheableKey.cpp | 1 -
clicache/src/impl/PdxManagedCacheableKey.hpp | 1 -
clicache/src/impl/PdxReaderWithTypeCollector.cpp | 1 -
clicache/src/impl/PdxType.cpp | 4 +-
clicache/src/impl/PdxWriterWithTypeCollector.cpp | 1 -
clicache/src/impl/SafeConvert.hpp | 4 +-
cppcache/include/geode/CacheableBuiltins.hpp | 38 +--
cppcache/include/geode/CacheableDate.hpp | 3 +-
cppcache/include/geode/CacheableEnum.hpp | 5 +-
cppcache/include/geode/CacheableFileName.hpp | 2 +-
cppcache/include/geode/CacheableObjectArray.hpp | 6 +-
cppcache/include/geode/CacheableString.hpp | 16 +-
cppcache/include/geode/CacheableUndefined.hpp | 5 +-
cppcache/include/geode/DataInput.hpp | 17 +-
cppcache/include/geode/DataOutput.hpp | 6 +-
cppcache/include/geode/GeodeTypeIds.hpp | 90 -------
cppcache/include/geode/Properties.hpp | 2 +-
cppcache/include/geode/Serializer.hpp | 1 -
cppcache/include/geode/Struct.hpp | 2 +-
cppcache/include/geode/internal/DSCode.hpp | 92 +++++++
...DataSerializablePrimitive.hpp => DSFixedId.hpp} | 44 +--
.../geode/internal/DataSerializableFixedId.hpp | 7 +-
.../geode/internal/DataSerializablePrimitive.hpp | 3 +-
.../geode/internal/InternalId.hpp} | 25 +-
.../integration-test/BuiltinCacheableWrappers.hpp | 122 +++++----
cppcache/integration-test/CacheableWrapper.cpp | 26 +-
cppcache/integration-test/CacheableWrapper.hpp | 16 +-
cppcache/integration-test/testSerialization.cpp | 2 -
.../integration-test/testThinClientCacheables.cpp | 10 +-
.../integration-test/testThinClientHeapLRU.cpp | 4 +-
.../integration-test/testThinClientPRSingleHop.cpp | 4 +-
cppcache/src/CacheAttributes.cpp | 1 -
cppcache/src/CacheFactory.cpp | 5 +-
cppcache/src/CacheableDate.cpp | 3 +-
cppcache/src/CacheableEnum.cpp | 3 +-
cppcache/src/CacheableFileName.cpp | 9 +-
cppcache/src/CacheableObjectArray.cpp | 3 +-
cppcache/src/CacheableObjectPartList.cpp | 1 -
cppcache/src/CacheableObjectPartList.hpp | 5 +-
cppcache/src/CacheableString.cpp | 25 +-
cppcache/src/CacheableToken.cpp | 3 +-
cppcache/src/ClientConnectionRequest.cpp | 5 +-
cppcache/src/ClientConnectionRequest.hpp | 2 +-
cppcache/src/ClientConnectionResponse.cpp | 4 +-
cppcache/src/ClientConnectionResponse.hpp | 2 +-
cppcache/src/ClientHealthStats.hpp | 3 +-
cppcache/src/ClientProxyMembershipID.cpp | 7 +-
cppcache/src/ClientProxyMembershipID.hpp | 5 +-
cppcache/src/ClientReplacementRequest.cpp | 5 +-
cppcache/src/ClientReplacementRequest.hpp | 2 +-
cppcache/src/DiskStoreId.hpp | 3 +-
cppcache/src/DiskVersionTag.hpp | 3 +-
cppcache/src/EnumInfo.cpp | 1 -
cppcache/src/EnumInfo.hpp | 3 +-
cppcache/src/EventId.cpp | 1 -
cppcache/src/EventId.hpp | 4 +-
cppcache/src/FarSideEntryOp.cpp | 10 +-
cppcache/src/GeodeTypeIdsImpl.hpp | 85 ------
cppcache/src/GetAllServersRequest.hpp | 3 +-
cppcache/src/GetAllServersResponse.hpp | 2 +-
cppcache/src/LocatorListRequest.cpp | 5 +-
cppcache/src/LocatorListRequest.hpp | 3 +-
cppcache/src/LocatorListResponse.cpp | 4 +-
cppcache/src/LocatorListResponse.hpp | 3 +-
cppcache/src/PdxFieldType.cpp | 1 -
cppcache/src/PdxInstanceFactory.cpp | 2 +-
cppcache/src/PdxInstanceImpl.cpp | 42 +--
cppcache/src/PdxLocalWriter.cpp | 5 +-
cppcache/src/PdxSerializable.cpp | 1 -
cppcache/src/PdxType.cpp | 5 +-
cppcache/src/PdxType.hpp | 2 +-
cppcache/src/Properties.cpp | 3 +-
cppcache/src/QueueConnectionRequest.cpp | 9 +-
cppcache/src/QueueConnectionRequest.hpp | 2 +-
cppcache/src/QueueConnectionResponse.cpp | 5 +-
cppcache/src/QueueConnectionResponse.hpp | 2 +-
cppcache/src/RegionAttributes.cpp | 3 +-
cppcache/src/Serializable.cpp | 1 -
cppcache/src/SerializationRegistry.cpp | 42 +--
cppcache/src/SerializationRegistry.hpp | 32 ++-
cppcache/src/ServerLocation.hpp | 1 -
cppcache/src/Struct.cpp | 3 +-
cppcache/src/TXCommitMessage.cpp | 16 +-
cppcache/src/TXCommitMessage.hpp | 2 +-
cppcache/src/TcrConnection.cpp | 11 +-
cppcache/src/TcrMessage.cpp | 38 +--
cppcache/src/TcrMessage.hpp | 63 ++---
cppcache/src/ThinClientRegion.cpp | 101 ++++---
cppcache/src/VersionTag.hpp | 5 +-
cppcache/src/VersionedCacheableObjectPartList.cpp | 1 -
cppcache/src/VersionedCacheableObjectPartList.hpp | 4 +-
127 files changed, 1001 insertions(+), 1147 deletions(-)
diff --git a/clicache/src/CacheableArrayList.hpp b/clicache/src/CacheableArrayList.hpp
index cac5971..7e30208 100644
--- a/clicache/src/CacheableArrayList.hpp
+++ b/clicache/src/CacheableArrayList.hpp
@@ -78,7 +78,7 @@ namespace Apache
{
int8_t get() override
{
- return native::GeodeTypeIds::CacheableArrayList;
+ return static_cast<int8_t>(native::DSCode::CacheableArrayList);
}
}
diff --git a/clicache/src/CacheableBuiltins.hpp b/clicache/src/CacheableBuiltins.hpp
index bdc9706..cab94e6 100644
--- a/clicache/src/CacheableBuiltins.hpp
+++ b/clicache/src/CacheableBuiltins.hpp
@@ -364,7 +364,7 @@ namespace Apache
//mt = managed type(bool, int)
#define _GFCLI_CACHEABLE_KEY_DEF_NEW(n, m, mt) \
ref class m : public CacheableBuiltinKey<n, mt, \
- GeodeTypeIds::m> \
+ static_cast<int8_t>(DSCode::m)> \
{ \
public: \
/** <summary>
@@ -570,49 +570,49 @@ namespace Apache
/// An immutable wrapper for byte arrays that can serve
/// as a distributable object for caching.
/// </summary>
- using CacheableBytes = CacheableArray<native::CacheableArray<int8_t, native::GeodeTypeIds::CacheableBytes>, Byte, GeodeTypeIds::CacheableBytes>;
+ using CacheableBytes = CacheableArray<native::CacheableArray<int8_t, native::DSCode::CacheableBytes>, Byte, static_cast<int8_t>(DSCode::CacheableBytes)>;
/// <summary>
/// An immutable wrapper for array of doubles that can serve
/// as a distributable object for caching.
/// </summary>
- using CacheableDoubleArray = CacheableArray<native::CacheableArray<double, native::GeodeTypeIds::CacheableDoubleArray>, Double, GeodeTypeIds::CacheableDoubleArray>;
+ using CacheableDoubleArray = CacheableArray<native::CacheableArray<double, native::DSCode::CacheableDoubleArray>, Double, static_cast<int8_t>(DSCode::CacheableDoubleArray)>;
/// <summary>
/// An immutable wrapper for array of floats that can serve
/// as a distributable object for caching.
/// </summary>
- using CacheableFloatArray = CacheableArray<native::CacheableArray<float, native::GeodeTypeIds::CacheableFloatArray>, Single, GeodeTypeIds::CacheableFloatArray>;
+ using CacheableFloatArray = CacheableArray<native::CacheableArray<float, native::DSCode::CacheableFloatArray>, Single, static_cast<int8_t>(DSCode::CacheableFloatArray)>;
/// <summary>
/// An immutable wrapper for array of 16-bit integers that can serve
/// as a distributable object for caching.
/// </summary>
- using CacheableInt16Array = CacheableArray<native::CacheableArray<int16_t, native::GeodeTypeIds::CacheableInt16Array>, System::Int16, GeodeTypeIds::CacheableInt16Array>;
+ using CacheableInt16Array = CacheableArray<native::CacheableArray<int16_t, native::DSCode::CacheableInt16Array>, System::Int16, static_cast<int8_t>(DSCode::CacheableInt16Array)>;
/// <summary>
/// An immutable wrapper for array of 32-bit integers that can serve
/// as a distributable object for caching.
/// </summary>
- using CacheableInt32Array = CacheableArray<native::CacheableArray<int32_t, native::GeodeTypeIds::CacheableInt32Array>, System::Int32, GeodeTypeIds::CacheableInt32Array>;
+ using CacheableInt32Array = CacheableArray<native::CacheableArray<int32_t, native::DSCode::CacheableInt32Array>, System::Int32, static_cast<int8_t>(DSCode::CacheableInt32Array)>;
/// <summary>
/// An immutable wrapper for array of 64-bit integers that can serve
/// as a distributable object for caching.
/// </summary>
- using CacheableInt64Array = CacheableArray<native::CacheableArray<int64_t, native::GeodeTypeIds::CacheableInt64Array>, System::Int64, GeodeTypeIds::CacheableInt64Array>;
+ using CacheableInt64Array = CacheableArray<native::CacheableArray<int64_t, native::DSCode::CacheableInt64Array>, System::Int64, static_cast<int8_t>(DSCode::CacheableInt64Array)>;
/// <summary>
/// An immutable wrapper for array of booleans that can serve
/// as a distributable object for caching.
/// </summary>
- using BooleanArray = CacheableArray<native::CacheableArray<bool, native::GeodeTypeIds::BooleanArray>, bool, GeodeTypeIds::BooleanArray>;
+ using BooleanArray = CacheableArray<native::CacheableArray<bool, native::DSCode::BooleanArray>, bool, static_cast<int8_t>(DSCode::BooleanArray)>;
/// <summary>
/// An immutable wrapper for array of 16-bit characters that can serve
/// as a distributable object for caching.
/// </summary>
- using CharArray = CacheableArray<native::CacheableArray<char16_t, native::GeodeTypeIds::CharArray>, Char, GeodeTypeIds::CharArray>;
+ using CharArray = CacheableArray<native::CacheableArray<char16_t, native::DSCode::CharArray>, Char, static_cast<int8_t>(DSCode::CharArray)>;
} // namespace Client
} // namespace Geode
} // namespace Apache
diff --git a/clicache/src/CacheableDate.cpp b/clicache/src/CacheableDate.cpp
index 6d13159..12caa29 100644
--- a/clicache/src/CacheableDate.cpp
+++ b/clicache/src/CacheableDate.cpp
@@ -70,7 +70,7 @@ namespace Apache
int8_t CacheableDate::DsCode::get()
{
- return native::GeodeTypeIds::CacheableDate;
+ return static_cast<int8_t>(native::DSCode::CacheableDate);
}
String^ CacheableDate::ToString()
diff --git a/clicache/src/CacheableFileName.cpp b/clicache/src/CacheableFileName.cpp
index 4b05130..5fe7d39 100644
--- a/clicache/src/CacheableFileName.cpp
+++ b/clicache/src/CacheableFileName.cpp
@@ -32,11 +32,11 @@ namespace Apache
void CacheableFileName::ToData(DataOutput^ output)
{
if (m_str->Length <= 0xFFFF) {
- output->WriteByte(apache::geode::client::GeodeTypeIds::CacheableString);
+ output->WriteByte(static_cast<int8_t>(apache::geode::client::DSCode::CacheableString));
output->WriteUTF(m_str);
}
else {
- output->WriteByte(apache::geode::client::GeodeTypeIds::CacheableStringHuge);
+ output->WriteByte(static_cast<int8_t>(apache::geode::client::DSCode::CacheableStringHuge));
output->WriteUTFHuge(m_str);
}
}
@@ -44,7 +44,7 @@ namespace Apache
void CacheableFileName::FromData(DataInput^ input)
{
unsigned char filetype = input->ReadByte();
- if (filetype == apache::geode::client::GeodeTypeIds::CacheableString) {
+ if (filetype == static_cast<int8_t>(apache::geode::client::DSCode::CacheableString)) {
m_str = input->ReadUTF();
}
else {
@@ -54,7 +54,7 @@ namespace Apache
int8_t CacheableFileName::DsCode::get()
{
- return native::GeodeTypeIds::CacheableFileName;
+ return static_cast<int8_t>(native::DSCode::CacheableFileName);
}
System::UInt64 CacheableFileName::ObjectSize::get()
diff --git a/clicache/src/CacheableHashMap.hpp b/clicache/src/CacheableHashMap.hpp
index 45bd339..dbb0c4d 100644
--- a/clicache/src/CacheableHashMap.hpp
+++ b/clicache/src/CacheableHashMap.hpp
@@ -120,7 +120,7 @@ namespace Apache
{
virtual int8_t get()
{
- return native::GeodeTypeIds::CacheableHashMap;
+ return static_cast<int8_t>(native::DSCode::CacheableHashMap);
}
}
diff --git a/clicache/src/CacheableHashSet.hpp b/clicache/src/CacheableHashSet.hpp
index f2b207d..d0f46aa 100644
--- a/clicache/src/CacheableHashSet.hpp
+++ b/clicache/src/CacheableHashSet.hpp
@@ -599,7 +599,7 @@ namespace Apache
}
#define _GFCLI_CACHEABLEHASHSET_DEF_GENERIC(m, HSTYPE) \
- public ref class m : public Internal::CacheableHashSetType<native::GeodeTypeIds::m, HSTYPE> \
+ public ref class m : public Internal::CacheableHashSetType<static_cast<int8_t>(native::DSCode::m), HSTYPE> \
{ \
public: \
/** <summary>
@@ -607,15 +607,15 @@ namespace Apache
* </summary>
*/ \
inline m() \
- : Internal::CacheableHashSetType<native::GeodeTypeIds::m, HSTYPE>() {} \
+ : Internal::CacheableHashSetType<static_cast<int8_t>(native::DSCode::m), HSTYPE>() {} \
\
/** <summary>
* Allocates a new instance with the given size.
* </summary>
- * <param name="size">the intial size of the new instance</param>
+ * <param name="size">the initial size of the new instance</param>
*/ \
inline m(System::Int32 size) \
- : Internal::CacheableHashSetType<native::GeodeTypeIds::m, HSTYPE>(size) {} \
+ : Internal::CacheableHashSetType<static_cast<int8_t>(native::DSCode::m), HSTYPE>(size) {} \
\
/** <summary>
* Static function to create a new empty instance.
@@ -652,7 +652,7 @@ namespace Apache
\
private: \
inline m(std::shared_ptr<apache::geode::client::Serializable> nativeptr) \
- : Internal::CacheableHashSetType<native::GeodeTypeIds::m, HSTYPE>(nativeptr) { } \
+ : Internal::CacheableHashSetType<static_cast<int8_t>(native::DSCode::m), HSTYPE>(nativeptr) { } \
};
/// <summary>
diff --git a/clicache/src/CacheableHashTable.hpp b/clicache/src/CacheableHashTable.hpp
index 7902266..e65f6b5 100644
--- a/clicache/src/CacheableHashTable.hpp
+++ b/clicache/src/CacheableHashTable.hpp
@@ -83,7 +83,7 @@ namespace Apache
{
int8_t get() override
{
- return native::GeodeTypeIds::CacheableHashTable;
+ return static_cast<int8_t>(native::DSCode::CacheableHashTable);
}
}
diff --git a/clicache/src/CacheableIdentityHashMap.hpp b/clicache/src/CacheableIdentityHashMap.hpp
index 6960bca..f6e9c53 100644
--- a/clicache/src/CacheableIdentityHashMap.hpp
+++ b/clicache/src/CacheableIdentityHashMap.hpp
@@ -109,7 +109,7 @@ namespace Apache
{
int8_t get() override
{
- return native::GeodeTypeIds::CacheableIdentityHashMap;
+ return static_cast<int8_t>(native::DSCode::CacheableIdentityHashMap);
}
}
diff --git a/clicache/src/CacheableLinkedList.hpp b/clicache/src/CacheableLinkedList.hpp
index 0777f49..335a482 100644
--- a/clicache/src/CacheableLinkedList.hpp
+++ b/clicache/src/CacheableLinkedList.hpp
@@ -80,7 +80,7 @@ namespace Apache
{
virtual int8_t get()
{
- return native::GeodeTypeIds::CacheableLinkedList;
+ return static_cast<int8_t>(native::DSCode::CacheableLinkedList);
}
}
diff --git a/clicache/src/CacheableObject.hpp b/clicache/src/CacheableObject.hpp
index 4cccd79..53edfa1 100644
--- a/clicache/src/CacheableObject.hpp
+++ b/clicache/src/CacheableObject.hpp
@@ -79,7 +79,7 @@ namespace Apache
{
virtual int8_t get()
{
- return apache::geode::client::GeodeTypeIds::CacheableManagedObject;
+ return static_cast<int8_t>(apache::geode::client::internal::InternalId::CacheableManagedObject);
}
}
diff --git a/clicache/src/CacheableObjectArray.cpp b/clicache/src/CacheableObjectArray.cpp
index 3208cfa..5edd61f 100644
--- a/clicache/src/CacheableObjectArray.cpp
+++ b/clicache/src/CacheableObjectArray.cpp
@@ -17,7 +17,6 @@
#include "begin_native.hpp"
-#include <GeodeTypeIdsImpl.hpp>
#include "end_native.hpp"
#include "CacheableObjectArray.hpp"
#include "DataOutput.hpp"
@@ -42,8 +41,8 @@ namespace Apache
void CacheableObjectArray::ToData(DataOutput^ output)
{
output->WriteArrayLen((System::Int32)Count);
- output->WriteByte((int8_t)apache::geode::client::GeodeTypeIdsImpl::Class);
- output->WriteByte((int8_t)apache::geode::client::GeodeTypeIds::CacheableASCIIString);
+ output->WriteByte((int8_t)apache::geode::client::DSCode::Class);
+ output->WriteByte((int8_t)apache::geode::client::DSCode::CacheableASCIIString);
output->WriteUTF("java.lang.Object");
for each (Object^ obj in this) {
diff --git a/clicache/src/CacheableObjectArray.hpp b/clicache/src/CacheableObjectArray.hpp
index 6ad7c55..8f8c230 100644
--- a/clicache/src/CacheableObjectArray.hpp
+++ b/clicache/src/CacheableObjectArray.hpp
@@ -108,7 +108,7 @@ namespace Apache
{
virtual int8_t get()
{
- return GeodeTypeIds::CacheableObjectArray;
+ return static_cast<int8_t>(DSCode::CacheableObjectArray);
}
}
diff --git a/clicache/src/CacheableObjectXml.hpp b/clicache/src/CacheableObjectXml.hpp
index 20a32bd..ef7c610 100644
--- a/clicache/src/CacheableObjectXml.hpp
+++ b/clicache/src/CacheableObjectXml.hpp
@@ -82,7 +82,7 @@ namespace Apache
{
virtual int8_t get()
{
- return apache::geode::client::GeodeTypeIds::CacheableManagedObjectXml;
+ return static_cast<int8_t>(apache::geode::client::internal::InternalId::CacheableManagedObjectXml);
}
}
diff --git a/clicache/src/CacheableStack.cpp b/clicache/src/CacheableStack.cpp
index ab819a7..eeef84b 100644
--- a/clicache/src/CacheableStack.cpp
+++ b/clicache/src/CacheableStack.cpp
@@ -22,7 +22,6 @@
#include "DataOutput.hpp"
#include "DataInput.hpp"
#include "begin_native.hpp"
-#include <GeodeTypeIdsImpl.hpp>
#include "end_native.hpp"
#include "impl/SafeConvert.hpp"
@@ -69,7 +68,7 @@ namespace Apache
int8_t CacheableStack::DsCode::get()
{
- return native::GeodeTypeIds::CacheableStack;
+ return static_cast<int8_t>(native::DSCode::CacheableStack);
}
System::UInt64 CacheableStack::ObjectSize::get()
diff --git a/clicache/src/CacheableString.cpp b/clicache/src/CacheableString.cpp
index 934f537..43a5199 100644
--- a/clicache/src/CacheableString.cpp
+++ b/clicache/src/CacheableString.cpp
@@ -36,12 +36,12 @@ namespace Apache
void CacheableString::ToData(DataOutput^ output)
{
- if (m_type == GeodeTypeIds::CacheableASCIIString ||
- m_type == GeodeTypeIds::CacheableString)
+ if (m_type == DSCode::CacheableASCIIString ||
+ m_type == DSCode::CacheableString)
{
output->WriteUTF(m_value);
}
- else if (m_type == GeodeTypeIds::CacheableASCIIStringHuge)
+ else if (m_type == DSCode::CacheableASCIIStringHuge)
{
output->WriteASCIIHuge(m_value);
}
@@ -53,12 +53,12 @@ namespace Apache
void CacheableString::FromData(DataInput^ input)
{
- if (m_type == GeodeTypeIds::CacheableASCIIString ||
- m_type == GeodeTypeIds::CacheableString)
+ if (m_type == DSCode::CacheableASCIIString ||
+ m_type == DSCode::CacheableString)
{
m_value = input->ReadUTF();
}
- else if (m_type == GeodeTypeIds::CacheableASCIIStringHuge)
+ else if (m_type == DSCode::CacheableASCIIStringHuge)
{
m_value = input->ReadASCIIHuge();
}
@@ -152,16 +152,16 @@ namespace Apache
if (len == m_value->Length)//ASCII string
{
if (len > 0xFFFF)
- m_type = GeodeTypeIds::CacheableASCIIStringHuge;
+ m_type = DSCode::CacheableASCIIStringHuge;
else
- m_type = GeodeTypeIds::CacheableASCIIString;
+ m_type = DSCode::CacheableASCIIString;
}
else
{
if (len > 0xFFFF)
- m_type = GeodeTypeIds::CacheableStringHuge;
+ m_type = DSCode::CacheableStringHuge;
else
- m_type = GeodeTypeIds::CacheableString;
+ m_type = DSCode::CacheableString;
} // namespace Client
} // namespace Geode
} // namespace Apache
diff --git a/clicache/src/CacheableString.hpp b/clicache/src/CacheableString.hpp
index 4465c59..c15d7f3 100644
--- a/clicache/src/CacheableString.hpp
+++ b/clicache/src/CacheableString.hpp
@@ -87,7 +87,7 @@ namespace Apache
{
virtual int8_t get()
{
- return m_type;
+ return static_cast<int8_t>(m_type);
}
}
@@ -197,22 +197,22 @@ namespace Apache
internal:
static ISerializable^ CreateDeserializable()
{
- return gcnew CacheableString(GeodeTypeIds::CacheableASCIIString);
+ return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableASCIIString));
}
static ISerializable^ createDeserializableHuge()
{
- return gcnew CacheableString(GeodeTypeIds::CacheableASCIIStringHuge);
+ return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableASCIIStringHuge));
}
static ISerializable^ createUTFDeserializable()
{
- return gcnew CacheableString(GeodeTypeIds::CacheableString);
+ return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableString));
}
static ISerializable^ createUTFDeserializableHuge()
{
- return gcnew CacheableString(GeodeTypeIds::CacheableStringHuge);
+ return gcnew CacheableString(static_cast<int8_t>(DSCode::CacheableStringHuge));
}
/// <summary>
/// Factory function to register wrapper
@@ -228,17 +228,17 @@ namespace Apache
CacheableString(System::UInt32 type) : CacheableKey()
{
- m_type = type;
+ m_type = static_cast<DSCode>(type);
}
private:
String^ m_value;
- int8_t m_type;
+ DSCode m_type;
int m_hashcode;
CacheableString() : CacheableKey()
{
- m_type = GeodeTypeIds::CacheableASCIIString;
+ m_type = DSCode::CacheableASCIIString;
}
void SetStringType();
diff --git a/clicache/src/CacheableStringArray.hpp b/clicache/src/CacheableStringArray.hpp
index 5b7c8d1..e8a4a85 100644
--- a/clicache/src/CacheableStringArray.hpp
+++ b/clicache/src/CacheableStringArray.hpp
@@ -72,7 +72,7 @@ namespace Apache
{
virtual int8_t get()
{
- return GeodeTypeIds::CacheableStringArray;
+ return static_cast<int8_t>(DSCode::CacheableStringArray);
}
}
diff --git a/clicache/src/CacheableUndefined.hpp b/clicache/src/CacheableUndefined.hpp
index ff9935d..f4f3a5a 100644
--- a/clicache/src/CacheableUndefined.hpp
+++ b/clicache/src/CacheableUndefined.hpp
@@ -92,7 +92,7 @@ namespace Apache
{
virtual Int32 get()
{
- return native::GeodeTypeIds::CacheableUndefined;
+ return static_cast<Int32>(native::DSFid::CacheableUndefined);
}
}
diff --git a/clicache/src/CacheableVector.hpp b/clicache/src/CacheableVector.hpp
index 64d492a..33dbda2 100644
--- a/clicache/src/CacheableVector.hpp
+++ b/clicache/src/CacheableVector.hpp
@@ -107,7 +107,7 @@ namespace Apache
{
virtual int8_t get()
{
- return native::GeodeTypeIds::CacheableVector;
+ return static_cast<int8_t>(native::DSCode::CacheableVector);
}
}
diff --git a/clicache/src/DataInput.cpp b/clicache/src/DataInput.cpp
index 4203874..68dd211 100644
--- a/clicache/src/DataInput.cpp
+++ b/clicache/src/DataInput.cpp
@@ -18,7 +18,6 @@
#include "begin_native.hpp"
#include <geode/Cache.hpp>
-#include <GeodeTypeIdsImpl.hpp>
#include "SerializationRegistry.hpp"
#include "CacheRegionHelper.hpp"
#include "CacheImpl.hpp"
@@ -449,52 +448,52 @@ namespace Apache
Object^ DataInput::ReadDotNetTypes(int8_t typeId)
{
- switch (typeId)
+ switch (static_cast<apache::geode::client::DSCode>(typeId))
{
- case apache::geode::client::GeodeTypeIds::CacheableByte:
+ case apache::geode::client::DSCode::CacheableByte:
{
return ReadByte();
}
- case apache::geode::client::GeodeTypeIds::CacheableBoolean:
+ case apache::geode::client::DSCode::CacheableBoolean:
{
bool obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableCharacter:
+ case apache::geode::client::DSCode::CacheableCharacter:
{
Char obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableDouble:
+ case apache::geode::client::DSCode::CacheableDouble:
{
Double obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableASCIIString:
+ case apache::geode::client::DSCode::CacheableASCIIString:
{
/* CacheableString^ cs = static_cast<CacheableString^>(CacheableString::CreateDeserializable());
cs->FromData(this);
return cs->Value;*/
return ReadUTF();
}
- case apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge:
+ case apache::geode::client::DSCode::CacheableASCIIStringHuge:
{
/*CacheableString^ cs = static_cast<CacheableString^>(CacheableString::createDeserializableHuge());
cs->FromData(this);
return cs->Value;*/
return ReadASCIIHuge();
}
- case apache::geode::client::GeodeTypeIds::CacheableString:
+ case apache::geode::client::DSCode::CacheableString:
{
/*CacheableString^ cs = static_cast<CacheableString^>(CacheableString::createUTFDeserializable());
cs->FromData(this);
return cs->Value;*/
return ReadUTF();
}
- case apache::geode::client::GeodeTypeIds::CacheableStringHuge:
+ case apache::geode::client::DSCode::CacheableStringHuge:
{
//TODO: need to look all strings types
/*CacheableString^ cs = static_cast<CacheableString^>(CacheableString::createUTFDeserializableHuge());
@@ -502,103 +501,103 @@ namespace Apache
return cs->Value;*/
return ReadUTFHuge();
}
- case apache::geode::client::GeodeTypeIds::CacheableFloat:
+ case apache::geode::client::DSCode::CacheableFloat:
{
float obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableInt16:
+ case apache::geode::client::DSCode::CacheableInt16:
{
Int16 obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableInt32:
+ case apache::geode::client::DSCode::CacheableInt32:
{
Int32 obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableInt64:
+ case apache::geode::client::DSCode::CacheableInt64:
{
Int64 obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableDate:
+ case apache::geode::client::DSCode::CacheableDate:
{
CacheableDate^ cd = CacheableDate::Create();
cd->FromData(this);
return cd->Value;
}
- case apache::geode::client::GeodeTypeIds::CacheableBytes:
+ case apache::geode::client::DSCode::CacheableBytes:
{
return ReadBytes();
}
- case apache::geode::client::GeodeTypeIds::CacheableDoubleArray:
+ case apache::geode::client::DSCode::CacheableDoubleArray:
{
array<Double>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableFloatArray:
+ case apache::geode::client::DSCode::CacheableFloatArray:
{
array<float>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableInt16Array:
+ case apache::geode::client::DSCode::CacheableInt16Array:
{
array<Int16>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableInt32Array:
+ case apache::geode::client::DSCode::CacheableInt32Array:
{
array<Int32>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::BooleanArray:
+ case apache::geode::client::DSCode::BooleanArray:
{
array<bool>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CharArray:
+ case apache::geode::client::DSCode::CharArray:
{
array<Char>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableInt64Array:
+ case apache::geode::client::DSCode::CacheableInt64Array:
{
array<Int64>^ obj;
ReadObject(obj);
return obj;
}
- case apache::geode::client::GeodeTypeIds::CacheableStringArray:
+ case apache::geode::client::DSCode::CacheableStringArray:
{
return ReadStringArray();
}
- case apache::geode::client::GeodeTypeIds::CacheableHashTable:
+ case apache::geode::client::DSCode::CacheableHashTable:
{
return ReadHashtable();
}
- case apache::geode::client::GeodeTypeIds::CacheableHashMap:
+ case apache::geode::client::DSCode::CacheableHashMap:
{
CacheableHashMap^ chm = static_cast<CacheableHashMap^>(CacheableHashMap::CreateDeserializable());
chm->FromData(this);
return chm->Value;
}
- case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap:
+ case apache::geode::client::DSCode::CacheableIdentityHashMap:
{
CacheableIdentityHashMap^ chm = static_cast<CacheableIdentityHashMap^>(CacheableIdentityHashMap::CreateDeserializable());
chm->FromData(this);
return chm->Value;
}
- case apache::geode::client::GeodeTypeIds::CacheableVector:
+ case apache::geode::client::DSCode::CacheableVector:
{
/*CacheableVector^ cv = static_cast<CacheableVector^>(CacheableVector::CreateDeserializable());
cv->FromData(this);
@@ -612,7 +611,7 @@ namespace Apache
}
return retA;
}
- case apache::geode::client::GeodeTypeIds::CacheableArrayList:
+ case apache::geode::client::DSCode::CacheableArrayList:
{
/*CacheableArrayList^ cv = static_cast<CacheableArrayList^>(CacheableArrayList::CreateDeserializable());
cv->FromData(this);
@@ -626,7 +625,7 @@ namespace Apache
return retA;
}
- case apache::geode::client::GeodeTypeIds::CacheableLinkedList:
+ case apache::geode::client::DSCode::CacheableLinkedList:
{
/*CacheableArrayList^ cv = static_cast<CacheableArrayList^>(CacheableArrayList::CreateDeserializable());
cv->FromData(this);
@@ -640,7 +639,7 @@ namespace Apache
return retA;
}
- case apache::geode::client::GeodeTypeIds::CacheableStack:
+ case apache::geode::client::DSCode::CacheableStack:
{
CacheableStack^ cv = static_cast<CacheableStack^>(CacheableStack::CreateDeserializable());
cv->FromData(this);
@@ -655,129 +654,123 @@ namespace Apache
{
try
{
- //Log::Debug("DataInput::ReadInternalObject m_cursor " + m_cursor);
- bool findinternal = false;
- int8_t typeId = ReadByte();
- System::Int64 compId = typeId;
- TypeFactoryMethod^ createType = nullptr;
+ //Log::Debug("DataInput::ReadInternalObject m_cursor " + m_cursor);
+ bool findinternal = false;
+ int8_t typeId = ReadByte();
+ System::Int64 compId;
+ TypeFactoryMethod^ createType = nullptr;
- if (compId == GeodeTypeIds::NullObj) {
- return nullptr;
- }
- else if (compId == GeodeTypeIdsImpl::PDX)
- {
- //cache current state and reset after reading pdx object
- auto cacheCursor = m_cursor;
- System::Byte* cacheBuffer = m_buffer;
- auto cacheBufferLength = m_bufferLength;
- Object^ ret = Internal::PdxHelper::DeserializePdx(this, false, CacheRegionHelper::getCacheImpl(m_cache->GetNative().get())->getSerializationRegistry().get());
- auto tmp = m_nativeptr->get()->getBytesRemaining();
- m_cursor = cacheBufferLength - tmp;
- m_buffer = cacheBuffer;
- m_bufferLength = cacheBufferLength;
- m_nativeptr->get()->rewindCursor(m_cursor);
-
- if (ret != nullptr)
+ switch (static_cast<DSCode>(typeId))
{
- if (auto pdxWrapper = dynamic_cast<Apache::Geode::Client::PdxWrapper^>(ret))
+ case DSCode::NullObj:
+ return nullptr;
+ case DSCode::PDX:
{
- return pdxWrapper->GetObject();
+ //cache current state and reset after reading pdx object
+ auto cacheCursor = m_cursor;
+ System::Byte* cacheBuffer = m_buffer;
+ auto cacheBufferLength = m_bufferLength;
+ Object^ ret = Internal::PdxHelper::DeserializePdx(this, false, CacheRegionHelper::getCacheImpl(m_cache->GetNative().get())->getSerializationRegistry().get());
+ auto tmp = m_nativeptr->get()->getBytesRemaining();
+ m_cursor = cacheBufferLength - tmp;
+ m_buffer = cacheBuffer;
+ m_bufferLength = cacheBufferLength;
+ m_nativeptr->get()->rewindCursor(m_cursor);
+
+ if (ret != nullptr)
+ {
+ if (auto pdxWrapper = dynamic_cast<Apache::Geode::Client::PdxWrapper^>(ret))
+ {
+ return pdxWrapper->GetObject();
+ }
+ }
+ return ret;
}
+ case DSCode::PDX_ENUM:
+ {
+ int8_t dsId = ReadByte();
+ int tmp = ReadArrayLen();
+ int enumId = (dsId << 24) | (tmp & 0xFFFFFF);
+
+ Object^ enumVal = Internal::PdxHelper::GetEnum(enumId, m_cache);
+ return enumVal;
+ }
+ case DSCode::CacheableNullString:
+ return nullptr;
+ case DSCode::CacheableUserData:
+ compId = ReadByte();
+ break;
+ case DSCode::CacheableUserData2:
+ compId = ReadInt16();
+ break;
+ case DSCode::CacheableUserData4:
+ compId = ReadInt32();
+ break;
+ case DSCode::FixedIDByte:
+ compId = ReadByte();
+ findinternal = true;
+ break;
+ case DSCode::FixedIDShort:
+ compId = ReadInt16();
+ findinternal = true;
+ break;
+ case DSCode::FixedIDInt:
+ compId = ReadInt32();
+ findinternal = true;
+ break;
}
- return ret;
- }
- else if (compId == GeodeTypeIdsImpl::PDX_ENUM)
- {
- int8_t dsId = ReadByte();
- int tmp = ReadArrayLen();
- int enumId = (dsId << 24) | (tmp & 0xFFFFFF);
- Object^ enumVal = Internal::PdxHelper::GetEnum(enumId, m_cache);
- return enumVal;
- }
- else if (compId == GeodeTypeIds::CacheableNullString) {
- //return SerializablePtr(CacheableString::createDeserializable());
- //TODO::
- return nullptr;
- }
- else if (compId == GeodeTypeIdsImpl::CacheableUserData) {
- int8_t classId = ReadByte();
- //compId |= ( ( (System::Int64)classId ) << 32 );
- compId = (System::Int64)classId;
- }
- else if (compId == GeodeTypeIdsImpl::CacheableUserData2) {
- System::Int16 classId = ReadInt16();
- //compId |= ( ( (System::Int64)classId ) << 32 );
- compId = (System::Int64)classId;
- }
- else if (compId == GeodeTypeIdsImpl::CacheableUserData4) {
- System::Int32 classId = ReadInt32();
- //compId |= ( ( (System::Int64)classId ) << 32 );
- compId = (System::Int64)classId;
- }
- else if (compId == GeodeTypeIdsImpl::FixedIDByte) {//TODO: need to verify again
- int8_t fixedId = ReadByte();
- compId = fixedId;
- findinternal = true;
- }
- else if (compId == GeodeTypeIdsImpl::FixedIDShort) {
- System::Int16 fixedId = ReadInt16();
- compId = fixedId;
- findinternal = true;
- }
- else if (compId == GeodeTypeIdsImpl::FixedIDInt) {
- System::Int32 fixedId = ReadInt32();
- compId = fixedId;
- findinternal = true;
- }
- if (findinternal) {
- createType = m_cache->TypeRegistry->GetDataSerializableFixedTypeFactoryMethodForFixedId((Int32)compId);
- }
- else {
- createType = m_cache->TypeRegistry->GetManagedDelegateGeneric(compId);
- if (createType == nullptr)
+ if (findinternal)
+ {
+ createType = m_cache->TypeRegistry->GetDataSerializableFixedTypeFactoryMethodForFixedId(static_cast<Int32>(compId));
+ }
+ else
{
- Object^ retVal = ReadDotNetTypes(typeId);
+ createType = m_cache->TypeRegistry->GetManagedDelegateGeneric(compId);
+ if (createType == nullptr)
+ {
+ Object^ retVal = ReadDotNetTypes(typeId);
- if (retVal != nullptr)
- return retVal;
+ if (retVal != nullptr)
+ return retVal;
- if (m_ispdxDesrialization && typeId == apache::geode::client::GeodeTypeIds::CacheableObjectArray)
- {//object array and pdxSerialization
- return readDotNetObjectArray();
+ if (m_ispdxDesrialization && static_cast<DSCode>(typeId) == DSCode::CacheableObjectArray)
+ {//object array and pdxSerialization
+ return readDotNetObjectArray();
+ }
+
+ createType = m_cache->TypeRegistry->GetDataSerializablePrimitiveTypeFactoryMethodForDsCode(typeId);
}
-
- createType = m_cache->TypeRegistry->GetDataSerializablePrimitiveTypeFactoryMethodForDsCode(typeId);
}
- }
- if (createType == nullptr) {
- throw gcnew IllegalStateException("Unregistered typeId " + typeId + " in deserialization, aborting.");
- }
+ if (createType == nullptr)
+ {
+ throw gcnew IllegalStateException("Unregistered typeId " + typeId + " in deserialization, aborting.");
+ }
- bool isPdxDeserialization = m_ispdxDesrialization;
- m_ispdxDesrialization = false;//for nested objects
- ISerializable^ newObj = createType();
+ bool isPdxDeserialization = m_ispdxDesrialization;
+ m_ispdxDesrialization = false;//for nested objects
+ ISerializable^ newObj = createType();
- if (auto dataSerializable = dynamic_cast<IDataSerializablePrimitive^>(newObj))
- {
- dataSerializable->FromData(this);
- }
- else if (auto dataSerializable = dynamic_cast<IDataSerializable^>(newObj))
- {
- dataSerializable->FromData(this);
- }
- else if (auto dataSerializableFixedId = dynamic_cast<IDataSerializableFixedId^>(newObj))
- {
- dataSerializableFixedId->FromData(this);
- }
- else
- {
- throw gcnew IllegalStateException("Unknown serialization type.");
- }
+ if (auto dataSerializable = dynamic_cast<IDataSerializablePrimitive^>(newObj))
+ {
+ dataSerializable->FromData(this);
+ }
+ else if (auto dataSerializable = dynamic_cast<IDataSerializable^>(newObj))
+ {
+ dataSerializable->FromData(this);
+ }
+ else if (auto dataSerializableFixedId = dynamic_cast<IDataSerializableFixedId^>(newObj))
+ {
+ dataSerializableFixedId->FromData(this);
+ }
+ else
+ {
+ throw gcnew IllegalStateException("Unknown serialization type.");
+ }
- m_ispdxDesrialization = isPdxDeserialization;
- return newObj;
+ m_ispdxDesrialization = isPdxDeserialization;
+ return newObj;
}
finally
{
@@ -1077,23 +1070,17 @@ namespace Apache
String^ DataInput::ReadString()
{
- UInt32 typeId = (Int32)ReadByte();
-
- if (typeId == GeodeTypeIds::CacheableNullString)
- return nullptr;
-
- if (typeId == GeodeTypeIds::CacheableASCIIString ||
- typeId == GeodeTypeIds::CacheableString)
- {
- return ReadUTF();
- }
- else if (typeId == GeodeTypeIds::CacheableASCIIStringHuge)
- {
- return ReadASCIIHuge();
- }
- else
- {
- return ReadUTFHuge();
+ switch (static_cast<DSCode>(ReadByte()))
+ {
+ case DSCode::CacheableNullString:
+ return nullptr;
+ case DSCode::CacheableASCIIString:
+ case DSCode::CacheableString:
+ return ReadUTF();
+ case DSCode::CacheableASCIIStringHuge:
+ return ReadASCIIHuge();
+ default:
+ return ReadUTFHuge();
}
}
diff --git a/clicache/src/DataOutput.cpp b/clicache/src/DataOutput.cpp
index 24e1638..986a042 100644
--- a/clicache/src/DataOutput.cpp
+++ b/clicache/src/DataOutput.cpp
@@ -17,7 +17,6 @@
#include "begin_native.hpp"
-#include <GeodeTypeIdsImpl.hpp>
#include "CacheRegionHelper.hpp"
#include "CacheImpl.hpp"
#include "DataOutputInternal.hpp"
@@ -321,9 +320,9 @@ namespace Apache
{
System::Collections::IList^ list = (System::Collections::IList^)objectArray;
this->WriteArrayLen(list->Count);
- WriteByte((int8_t)apache::geode::client::GeodeTypeIdsImpl::Class);
+ WriteByte((int8_t)apache::geode::client::DSCode::Class);
String^ pdxDomainClassname = m_cache->TypeRegistry->GetPdxTypeName(objectArray->GetType()->GetElementType()->FullName);
- WriteByte((int8_t)GeodeTypeIds::CacheableASCIIString);
+ WriteByte((int8_t)DSCode::CacheableASCIIString);
WriteUTF(pdxDomainClassname);
for each(Object^ o in list)
WriteObject(o);
@@ -369,12 +368,12 @@ namespace Apache
{
if (len == value->Length)//huge ascii
{
- WriteByte(GeodeTypeIds::CacheableASCIIStringHuge);
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableASCIIStringHuge));
WriteASCIIHuge(value);
}
else//huge utf
{
- WriteByte(GeodeTypeIds::CacheableStringHuge);
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableStringHuge));
WriteUTFHuge(value);
}
return;
@@ -382,11 +381,11 @@ namespace Apache
if (len == value->Length)
{
- WriteByte(GeodeTypeIds::CacheableASCIIString);//ascii string
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableASCIIString));//ascii string
}
else
{
- WriteByte(GeodeTypeIds::CacheableString);//utf string
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableString));//utf string
}
WriteUInt16(len);
EnsureCapacity(len);
@@ -443,13 +442,13 @@ namespace Apache
return (int8_t)((classId - 0x80000000) % 0x20000000);
}
else if (classId <= 0x7F) {
- return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
+ return (int8_t)DSCode::CacheableUserData;
}
else if (classId <= 0x7FFF) {
- return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
+ return (int8_t)DSCode::CacheableUserData2;
}
else {
- return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
+ return (int8_t)DSCode::CacheableUserData4;
}
}
@@ -472,7 +471,7 @@ namespace Apache
if (obj == nullptr)
{
- WriteByte((int8_t)GeodeTypeIds::NullObj);
+ WriteByte((int8_t)DSCode::NullObj);
return;
}
@@ -480,41 +479,41 @@ namespace Apache
{
//need to set
int enumVal = Internal::PdxHelper::GetEnumValue(obj->GetType()->FullName, Enum::GetName(obj->GetType(), obj), obj->GetHashCode(), m_cache);
- WriteByte(GeodeTypeIdsImpl::PDX_ENUM);
+ WriteByte(static_cast<int8_t>(DSCode::PDX_ENUM));
WriteByte(enumVal >> 24);
WriteArrayLen(enumVal & 0xFFFFFF);
return;
}
- Byte typeId = m_cache->TypeRegistry->GetDsCodeForManagedType(obj->GetType());
+ DSCode typeId = static_cast<DSCode>(m_cache->TypeRegistry->GetDsCodeForManagedType(obj->GetType()));
switch (typeId)
{
- case GeodeTypeIds::CacheableByte:
+ case DSCode::CacheableByte:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteByte((Byte)obj);
return;
}
- case GeodeTypeIds::CacheableBoolean:
+ case DSCode::CacheableBoolean:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteBoolean((bool)obj);
return;
}
- case GeodeTypeIds::CacheableCharacter:
+ case DSCode::CacheableCharacter:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((Char)obj);
return;
}
- case GeodeTypeIds::CacheableDouble:
+ case DSCode::CacheableDouble:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteDouble((Double)obj);
return;
}
- case GeodeTypeIds::CacheableASCIIString:
+ case DSCode::CacheableASCIIString:
{
//CacheableString^ cStr = CacheableString::Create((String^)obj);
//// TODO: igfser mapping between generic and non generic
@@ -522,132 +521,132 @@ namespace Apache
WriteStringWithType((String^)obj);
return;
}
- case GeodeTypeIds::CacheableFloat:
+ case DSCode::CacheableFloat:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteFloat((float)obj);
return;
}
- case GeodeTypeIds::CacheableInt16:
+ case DSCode::CacheableInt16:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteInt16((Int16)obj);
return;
}
- case GeodeTypeIds::CacheableInt32:
+ case DSCode::CacheableInt32:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteInt32((Int32)obj);
return;
}
- case GeodeTypeIds::CacheableInt64:
+ case DSCode::CacheableInt64:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteInt64((Int64)obj);
return;
}
- case GeodeTypeIds::CacheableDate:
+ case DSCode::CacheableDate:
{
//CacheableDate^ cd = gcnew CacheableDate((DateTime)obj);
// TODO: igfser mapping between generic and non generic
//WriteObjectInternal(cd);
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteDate((DateTime)obj);
return;
}
- case GeodeTypeIds::CacheableBytes:
+ case DSCode::CacheableBytes:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteBytes((array<Byte>^)obj);
return;
}
- case GeodeTypeIds::CacheableDoubleArray:
+ case DSCode::CacheableDoubleArray:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<Double>^)obj);
return;
}
- case GeodeTypeIds::CacheableFloatArray:
+ case DSCode::CacheableFloatArray:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<float>^)obj);
return;
}
- case GeodeTypeIds::CacheableInt16Array:
+ case DSCode::CacheableInt16Array:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<Int16>^)obj);
return;
}
- case GeodeTypeIds::CacheableInt32Array:
+ case DSCode::CacheableInt32Array:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<Int32>^)obj);
return;
}
- case GeodeTypeIds::CacheableInt64Array:
+ case DSCode::CacheableInt64Array:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<Int64>^)obj);
return;
}
- case GeodeTypeIds::BooleanArray:
+ case DSCode::BooleanArray:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<bool>^)obj);
return;
}
- case GeodeTypeIds::CharArray:
+ case DSCode::CharArray:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<char>^)obj);
return;
}
- case GeodeTypeIds::CacheableStringArray:
+ case DSCode::CacheableStringArray:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteObject((array<String^>^)obj);
return;
}
- case GeodeTypeIds::CacheableHashTable:
- case GeodeTypeIds::CacheableHashMap:
- case GeodeTypeIds::CacheableIdentityHashMap:
+ case DSCode::CacheableHashTable:
+ case DSCode::CacheableHashMap:
+ case DSCode::CacheableIdentityHashMap:
{
- WriteByte(typeId);
+ WriteByte(static_cast<unsigned char>(typeId));
WriteDictionary((System::Collections::IDictionary^)obj);
return;
}
- case GeodeTypeIds::CacheableVector:
+ case DSCode::CacheableVector:
{
//CacheableVector^ cv = gcnew CacheableVector((System::Collections::IList^)obj);
//// TODO: igfser mapping between generic and non generic
//WriteObjectInternal(cv);
- WriteByte(GeodeTypeIds::CacheableVector);
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableVector));
WriteList((System::Collections::IList^)obj);
return;
}
- case GeodeTypeIds::CacheableLinkedList:
+ case DSCode::CacheableLinkedList:
{
//CacheableArrayList^ cal = gcnew CacheableArrayList((System::Collections::IList^)obj);
//// TODO: igfser mapping between generic and non generic
//WriteObjectInternal(cal);
- WriteByte(GeodeTypeIds::CacheableLinkedList);
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableLinkedList));
System::Collections::ICollection^ linkedList = (System::Collections::ICollection^)obj;
this->WriteArrayLen(linkedList->Count);
for each (Object^ o in linkedList)
this->WriteObject(o);
return;
}
- case GeodeTypeIds::CacheableArrayList:
+ case DSCode::CacheableArrayList:
{
//CacheableArrayList^ cal = gcnew CacheableArrayList((System::Collections::IList^)obj);
//// TODO: igfser mapping between generic and non generic
//WriteObjectInternal(cal);
- WriteByte(GeodeTypeIds::CacheableArrayList);
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableArrayList));
WriteList((System::Collections::IList^)obj);
return;
}
- case GeodeTypeIds::CacheableStack:
+ case DSCode::CacheableStack:
{
CacheableStack^ cs = gcnew CacheableStack((System::Collections::ICollection^)obj);
// TODO: igfser mapping between generic and non generic
@@ -658,7 +657,7 @@ namespace Apache
{
if (auto pdxObj = dynamic_cast<IPdxSerializable^>(obj))
{
- WriteByte(GeodeTypeIdsImpl::PDX);
+ WriteByte(static_cast<int8_t>(DSCode::PDX));
Internal::PdxHelper::SerializePdx(this, pdxObj);
return;
}
@@ -667,7 +666,7 @@ namespace Apache
//pdx serialization and is array of object
if (m_ispdxSerialization && obj->GetType()->IsArray)
{
- WriteByte(GeodeTypeIds::CacheableObjectArray);
+ WriteByte(static_cast<unsigned char>(DSCode::CacheableObjectArray));
WriteDotNetObjectArray(obj);
return;
}
@@ -680,7 +679,7 @@ namespace Apache
if (m_cache->TypeRegistry->PdxSerializer)
{
auto pdxObj = gcnew PdxWrapper(obj);
- WriteByte(GeodeTypeIdsImpl::PDX);
+ WriteByte(static_cast<int8_t>(DSCode::PDX));
Internal::PdxHelper::SerializePdx(this, pdxObj);
return;
}
@@ -710,7 +709,7 @@ namespace Apache
{
//CacheableKey^ key = gcnew CacheableKey();
if (obj == nullptr) {
- WriteByte((int8_t)GeodeTypeIds::NullObj);
+ WriteByte((int8_t)DSCode::NullObj);
}
else if (auto dataSerializablePrimitive = dynamic_cast<IDataSerializablePrimitive^>(obj))
{
@@ -722,15 +721,15 @@ namespace Apache
{
auto id = dataSerializable->ClassId;
auto dsCode = getDataSerializableDsCode(id);
- WriteByte(dsCode);
+ WriteByte(static_cast<int8_t>(dsCode));
switch (dsCode) {
- case GeodeTypeIdsImpl::CacheableUserData:
+ case DSCode::CacheableUserData:
WriteByte(static_cast<int8_t>(id));
break;
- case GeodeTypeIdsImpl::CacheableUserData2:
+ case DSCode::CacheableUserData2:
WriteInt16(static_cast<int16_t>(id));
break;
- case GeodeTypeIdsImpl::CacheableUserData4:
+ case DSCode::CacheableUserData4:
WriteInt32(static_cast<int32_t>(id));
break;
default:
@@ -743,14 +742,14 @@ namespace Apache
auto id = dataSerializableFixedId->DSFID;
auto dsCode = getDataSerializableFixedIdDsCode(id);
WriteByte(dsCode);
- switch (dsCode) {
- case GeodeTypeIdsImpl::FixedIDByte:
+ switch (static_cast<DSCode>(dsCode)) {
+ case DSCode::FixedIDByte:
WriteByte(static_cast<int8_t>(id));
break;
- case GeodeTypeIdsImpl::FixedIDShort:
+ case DSCode::FixedIDShort:
WriteInt16(static_cast<int16_t>(id));
break;
- case GeodeTypeIdsImpl::FixedIDInt:
+ case DSCode::FixedIDInt:
WriteInt32(static_cast<int32_t>(id));
break;
default:
@@ -840,7 +839,7 @@ namespace Apache
{
if (value == nullptr)
{
- this->WriteByte(GeodeTypeIds::CacheableNullString);
+ this->WriteByte(static_cast<unsigned char>(DSCode::CacheableNullString));
}
else
{
diff --git a/clicache/src/DataOutput.hpp b/clicache/src/DataOutput.hpp
index 8700e40..f839ba6 100644
--- a/clicache/src/DataOutput.hpp
+++ b/clicache/src/DataOutput.hpp
@@ -482,27 +482,27 @@ namespace Apache
static int8_t DSFID(System::UInt32 classId);
- static inline int8_t getDataSerializableDsCode(int32_t classId) {
+ static inline DSCode getDataSerializableDsCode(int32_t classId) {
if (classId <= std::numeric_limits<int8_t>::max() &&
classId >= std::numeric_limits<int8_t>::min()) {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableUserData);
+ return DSCode::CacheableUserData;
} else if (classId <= std::numeric_limits<int16_t>::max() &&
classId >= std::numeric_limits<int16_t>::min()) {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableUserData2);
+ return DSCode::CacheableUserData2;
} else {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableUserData4);
+ return DSCode::CacheableUserData4;
}
}
static inline int8_t getDataSerializableFixedIdDsCode(int32_t fixedId) {
if (fixedId <= std::numeric_limits<int8_t>::max() &&
fixedId >= std::numeric_limits<int8_t>::min()) {
- return static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte);
+ return static_cast<int8_t>(DSCode::FixedIDByte);
} else if (fixedId <= std::numeric_limits<int16_t>::max() &&
fixedId >= std::numeric_limits<int16_t>::min()) {
- return static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDShort);
+ return static_cast<int8_t>(DSCode::FixedIDShort);
} else {
- return static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDInt);
+ return static_cast<int8_t>(DSCode::FixedIDInt);
}
}
diff --git a/clicache/src/DistributedSystem.cpp b/clicache/src/DistributedSystem.cpp
index a2ecbb9..1eb3595 100644
--- a/clicache/src/DistributedSystem.cpp
+++ b/clicache/src/DistributedSystem.cpp
@@ -22,7 +22,6 @@
#include <geode/CacheListener.hpp>
#include <geode/FixedPartitionResolver.hpp>
#include <geode/CacheWriter.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/Cache.hpp>
#include <CacheImpl.hpp>
#include <CacheXmlParser.hpp>
@@ -169,127 +168,127 @@ namespace Apache
auto&& typeRegistry = cache->TypeRegistry;
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableBytes,
+ static_cast<int8_t>(native::DSCode::CacheableBytes),
gcnew TypeFactoryMethod(CacheableBytes::CreateDeserializable),
Type::GetType("System.Byte[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableDoubleArray,
+ static_cast<int8_t>(native::DSCode::CacheableDoubleArray),
gcnew TypeFactoryMethod(CacheableDoubleArray::CreateDeserializable),
Type::GetType("System.Double[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableFloatArray,
+ static_cast<int8_t>(native::DSCode::CacheableFloatArray),
gcnew TypeFactoryMethod(CacheableFloatArray::CreateDeserializable),
Type::GetType("System.Single[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableHashSet,
+ static_cast<int8_t>(native::DSCode::CacheableHashSet),
gcnew TypeFactoryMethod(CacheableHashSet::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableLinkedHashSet,
+ static_cast<int8_t>(native::DSCode::CacheableLinkedHashSet),
gcnew TypeFactoryMethod(CacheableLinkedHashSet::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableInt16Array,
+ static_cast<int8_t>(native::DSCode::CacheableInt16Array),
gcnew TypeFactoryMethod(CacheableInt16Array::CreateDeserializable),
Type::GetType("System.Int16[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableInt32Array,
+ static_cast<int8_t>(native::DSCode::CacheableInt32Array),
gcnew TypeFactoryMethod(CacheableInt32Array::CreateDeserializable),
Type::GetType("System.Int32[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableInt64Array,
+ static_cast<int8_t>(native::DSCode::CacheableInt64Array),
gcnew TypeFactoryMethod(CacheableInt64Array::CreateDeserializable),
Type::GetType("System.Int64[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::BooleanArray,
+ static_cast<int8_t>(native::DSCode::BooleanArray),
gcnew TypeFactoryMethod(BooleanArray::CreateDeserializable),
Type::GetType("System.Boolean[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CharArray,
+ static_cast<int8_t>(native::DSCode::CharArray),
gcnew TypeFactoryMethod(CharArray::CreateDeserializable),
Type::GetType("System.Char[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableStringArray,
+ static_cast<int8_t>(native::DSCode::CacheableStringArray),
gcnew TypeFactoryMethod(CacheableStringArray::CreateDeserializable),
Type::GetType("System.String[]"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::Struct,
+ static_cast<int8_t>(native::DSFid::Struct),
gcnew TypeFactoryMethod(Struct::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableDate,
+ static_cast<int8_t>(native::DSCode::CacheableDate),
gcnew TypeFactoryMethod(CacheableDate::CreateDeserializable),
Type::GetType("System.DateTime"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableFileName,
+ static_cast<int8_t>(native::DSCode::CacheableFileName),
gcnew TypeFactoryMethod(CacheableFileName::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableHashMap,
+ static_cast<int8_t>(native::DSCode::CacheableHashMap),
gcnew TypeFactoryMethod(CacheableHashMap::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableHashTable,
+ static_cast<int8_t>(native::DSCode::CacheableHashTable),
gcnew TypeFactoryMethod(CacheableHashTable::CreateDeserializable),
Type::GetType("System.Collections.Hashtable"));
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableIdentityHashMap,
+ static_cast<int8_t>(native::DSCode::CacheableIdentityHashMap),
gcnew TypeFactoryMethod(CacheableIdentityHashMap::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableUndefined,
+ static_cast<int8_t>(native::DSFid::CacheableUndefined),
gcnew TypeFactoryMethod(CacheableUndefined::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableVector,
+ static_cast<int8_t>(native::DSCode::CacheableVector),
gcnew TypeFactoryMethod(CacheableVector::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableObjectArray,
+ static_cast<int8_t>(native::DSCode::CacheableObjectArray),
gcnew TypeFactoryMethod(CacheableObjectArray::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableArrayList,
+ static_cast<int8_t>(native::DSCode::CacheableArrayList),
gcnew TypeFactoryMethod(CacheableArrayList::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableLinkedList,
+ static_cast<int8_t>(native::DSCode::CacheableLinkedList),
gcnew TypeFactoryMethod(CacheableLinkedList::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableStack,
+ static_cast<int8_t>(native::DSCode::CacheableStack),
gcnew TypeFactoryMethod(CacheableStack::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableManagedObject,
+ static_cast<int8_t>(native::internal::InternalId::CacheableManagedObject),
gcnew TypeFactoryMethod(CacheableObject::CreateDeserializable),
nullptr);
typeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::CacheableManagedObjectXml,
+ static_cast<int8_t>(native::internal::InternalId::CacheableManagedObjectXml),
gcnew TypeFactoryMethod(CacheableObjectXml::CreateDeserializable),
nullptr);
}
@@ -299,7 +298,7 @@ namespace Apache
auto&& typeRegistry = cache->TypeRegistry;
typeRegistry->RegisterDataSerializableFixedIdTypeOverrideNativeDeserialization(
- native::GeodeTypeIds::EnumInfo,
+ static_cast<int8_t>(native::DSFid::EnumInfo),
gcnew TypeFactoryMethod(Internal::EnumInfo::CreateDeserializable));
}
@@ -310,7 +309,7 @@ namespace Apache
// Actually an internal type being registered as a primitive
cache->TypeRegistry->RegisterDataSerializablePrimitiveOverrideNativeDeserialization(
- native::GeodeTypeIds::PdxType,
+ static_cast<int8_t>(native::DSCode::PdxType),
gcnew TypeFactoryMethod(Apache::Geode::Client::Internal::PdxType::CreateDeserializable),
nullptr);
@@ -355,27 +354,27 @@ namespace Apache
TypeRegistry::UnregisterNativesGeneric(cache);
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableDate);
+ static_cast<int8_t>(native::DSCode::CacheableDate));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableFileName);
+ static_cast<int8_t>(native::DSCode::CacheableFileName));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableHashMap);
+ static_cast<int8_t>(native::DSCode::CacheableHashMap));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableHashTable);
+ static_cast<int8_t>(native::DSCode::CacheableHashTable));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableIdentityHashMap);
+ static_cast<int8_t>(native::DSCode::CacheableIdentityHashMap));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableVector);
+ static_cast<int8_t>(native::DSCode::CacheableVector));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableObjectArray);
+ static_cast<int8_t>(native::DSCode::CacheableObjectArray));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableArrayList);
+ static_cast<int8_t>(native::DSCode::CacheableArrayList));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableStack);
+ static_cast<int8_t>(native::DSCode::CacheableStack));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableManagedObject);
+ static_cast<int8_t>(native::InternalId::CacheableManagedObject));
cache->TypeRegistry->UnregisterTypeGeneric(
- native::GeodeTypeIds::CacheableManagedObjectXml);
+ static_cast<int8_t>(native::InternalId::CacheableManagedObjectXml));
_GF_MG_EXCEPTION_CATCH_ALL2
}
diff --git a/clicache/src/GeodeClassIds.hpp b/clicache/src/GeodeClassIds.hpp
index dd2440d..aea451b 100644
--- a/clicache/src/GeodeClassIds.hpp
+++ b/clicache/src/GeodeClassIds.hpp
@@ -19,7 +19,6 @@
#include "geode_defs.hpp"
#include "begin_native.hpp"
-#include <geode/GeodeTypeIds.hpp>
#include "end_native.hpp"
namespace Apache
@@ -41,25 +40,25 @@ namespace Apache
/// ClassId of <c>Properties</c> class
/// </summary>
literal System::UInt32 Properties =
- apache::geode::client::GeodeTypeIds::Properties + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::Properties) + 0x80000000;
/// <summary>
/// ClassId of <c>CharArray</c> class
/// </summary>
literal System::UInt32 CharArray =
- apache::geode::client::GeodeTypeIds::CharArray + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CharArray) + 0x80000000;
/// <summary>
/// ClassId of <c>BooleanArray</c> class
/// </summary>
literal System::UInt32 BooleanArray =
- apache::geode::client::GeodeTypeIds::BooleanArray + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::BooleanArray) + 0x80000000;
/// <summary>
/// ClassId of <c>RegionAttributes</c> class
/// </summary>
literal System::UInt32 RegionAttributes =
- apache::geode::client::GeodeTypeIds::RegionAttributes + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::RegionAttributes) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableUndefined</c> class
@@ -67,214 +66,214 @@ namespace Apache
/// different increment.
/// </summary>
literal System::UInt32 CacheableUndefined =
- apache::geode::client::GeodeTypeIds::CacheableUndefined + 0xa0000000;
+ static_cast<System::UInt32>(apache::geode::client::DSFid::CacheableUndefined) + 0xa0000000;
literal System::Int32 EnumInfo =
- apache::geode::client::GeodeTypeIds::EnumInfo;
+ static_cast<System::UInt32>(apache::geode::client::DSFid::EnumInfo);
/// <summary>
/// ClassId of <c>Struct</c> class
/// </summary>
literal System::UInt32 Struct =
- apache::geode::client::GeodeTypeIds::Struct + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSFid::Struct) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableString</c> class
/// </summary>
literal System::UInt32 CacheableString =
- apache::geode::client::GeodeTypeIds::CacheableString + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableString) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableString</c> class for huge strings
/// </summary>
literal System::UInt32 CacheableStringHuge =
- apache::geode::client::GeodeTypeIds::CacheableStringHuge + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableStringHuge) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableBytes</c> class
/// </summary>
literal System::UInt32 CacheableBytes =
- apache::geode::client::GeodeTypeIds::CacheableBytes + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableBytes) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt16Array</c> class
/// </summary>
literal System::UInt32 CacheableInt16Array =
- apache::geode::client::GeodeTypeIds::CacheableInt16Array + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableInt16Array) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt32Array</c> class
/// </summary>
literal System::UInt32 CacheableInt32Array =
- apache::geode::client::GeodeTypeIds::CacheableInt32Array + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableInt32Array) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt64Array</c> class
/// </summary>
literal System::UInt32 CacheableInt64Array =
- apache::geode::client::GeodeTypeIds::CacheableInt64Array + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableInt64Array) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableFloatArray</c> class
/// </summary>
literal System::UInt32 CacheableFloatArray =
- apache::geode::client::GeodeTypeIds::CacheableFloatArray + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableFloatArray) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableDoubleArray</c> class
/// </summary>
literal System::UInt32 CacheableDoubleArray =
- apache::geode::client::GeodeTypeIds::CacheableDoubleArray + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableDoubleArray) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableVector</c> class for object arrays
/// </summary>
literal System::UInt32 CacheableObjectArray =
- apache::geode::client::GeodeTypeIds::CacheableObjectArray + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableObjectArray) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableBoolean</c> class
/// </summary>
literal System::UInt32 CacheableBoolean =
- apache::geode::client::GeodeTypeIds::CacheableBoolean + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableBoolean) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt16</c> class for wide-characters
/// </summary>
literal System::UInt32 CacheableCharacter =
- apache::geode::client::GeodeTypeIds::CacheableCharacter + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableCharacter) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableByte</c> class
/// </summary>
literal System::UInt32 CacheableByte =
- apache::geode::client::GeodeTypeIds::CacheableByte + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableByte) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt16</c> class
/// </summary>
literal System::UInt32 CacheableInt16 =
- apache::geode::client::GeodeTypeIds::CacheableInt16 + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableInt16) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt32</c> class
/// </summary>
literal System::UInt32 CacheableInt32 =
- apache::geode::client::GeodeTypeIds::CacheableInt32 + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableInt32) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableInt64</c> class
/// </summary>
literal System::UInt32 CacheableInt64 =
- apache::geode::client::GeodeTypeIds::CacheableInt64 + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableInt64) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableFloat</c> class
/// </summary>
literal System::UInt32 CacheableFloat =
- apache::geode::client::GeodeTypeIds::CacheableFloat + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableFloat) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableDouble</c> class
/// </summary>
literal System::UInt32 CacheableDouble =
- apache::geode::client::GeodeTypeIds::CacheableDouble + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableDouble) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableDate</c> class
/// </summary>
literal System::UInt32 CacheableDate =
- apache::geode::client::GeodeTypeIds::CacheableDate + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableDate) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableFileName</c> class
/// </summary>
literal System::UInt32 CacheableFileName =
- apache::geode::client::GeodeTypeIds::CacheableFileName + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableFileName) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableStringArray</c> class
/// </summary>
literal System::UInt32 CacheableStringArray =
- apache::geode::client::GeodeTypeIds::CacheableStringArray + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableStringArray) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableVector</c> class
/// </summary>
literal System::UInt32 CacheableVector =
- apache::geode::client::GeodeTypeIds::CacheableVector + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableVector) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableStack</c> class
/// </summary>
literal System::UInt32 CacheableStack =
- apache::geode::client::GeodeTypeIds::CacheableStack + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableStack) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableArrayList</c> class
/// </summary>
literal System::UInt32 CacheableArrayList =
- apache::geode::client::GeodeTypeIds::CacheableArrayList + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableArrayList) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableArrayList</c> class
/// </summary>
literal System::UInt32 CacheableLinkedList =
- apache::geode::client::GeodeTypeIds::CacheableLinkedList + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableLinkedList) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableHashSet</c> class
/// </summary>
literal System::UInt32 CacheableHashSet =
- apache::geode::client::GeodeTypeIds::CacheableHashSet + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableHashSet) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableLinkedHashSet</c> class
/// </summary>
literal System::UInt32 CacheableLinkedHashSet =
- apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableLinkedHashSet) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableHashMap</c> class
/// </summary>
literal System::UInt32 CacheableHashMap =
- apache::geode::client::GeodeTypeIds::CacheableHashMap + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableHashMap) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableHashTable</c> class
/// </summary>
literal System::UInt32 CacheableHashTable =
- apache::geode::client::GeodeTypeIds::CacheableHashTable + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableHashTable) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableIdentityHashMap</c> class
/// </summary>
literal System::UInt32 CacheableIdentityHashMap =
- apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableIdentityHashMap) + 0x80000000;
/// <summary>
/// Not used.
/// </summary>
literal System::UInt32 CacheableTimeUnit =
- apache::geode::client::GeodeTypeIds::CacheableTimeUnit + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableTimeUnit) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableString</c> class for null strings
/// </summary>
literal System::UInt32 CacheableNullString =
- apache::geode::client::GeodeTypeIds::CacheableNullString + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableNullString) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableString</c> class for ASCII strings
/// </summary>
literal System::UInt32 CacheableASCIIString =
- apache::geode::client::GeodeTypeIds::CacheableASCIIString + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableASCIIString) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableString</c> class for huge ASCII strings
/// </summary>
literal System::UInt32 CacheableASCIIStringHuge =
- apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::DSCode::CacheableASCIIStringHuge) + 0x80000000;
// Built-in managed types.
@@ -283,13 +282,13 @@ namespace Apache
/// ClassId of <c>CacheableObject</c> class
/// </summary>
literal System::UInt32 CacheableManagedObject =
- apache::geode::client::GeodeTypeIds::CacheableManagedObject + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::InternalId::CacheableManagedObject) + 0x80000000;
/// <summary>
/// ClassId of <c>CacheableObjectXml</c> class
/// </summary>
literal System::UInt32 CacheableManagedObjectXml =
- apache::geode::client::GeodeTypeIds::CacheableManagedObjectXml + 0x80000000;
+ static_cast<System::UInt32>(apache::geode::client::InternalId::CacheableManagedObjectXml) + 0x80000000;
};
} // namespace Client
diff --git a/clicache/src/Properties.hpp b/clicache/src/Properties.hpp
index f0bff7a..213149d 100644
--- a/clicache/src/Properties.hpp
+++ b/clicache/src/Properties.hpp
@@ -193,7 +193,7 @@ namespace Apache
{
inline virtual int8_t get( )
{
- return native::GeodeTypeIds::Properties;
+ return static_cast<int8_t>(native::DSCode::Properties);
}
}
diff --git a/clicache/src/Serializable.cpp b/clicache/src/Serializable.cpp
index b871729..79068b4 100644
--- a/clicache/src/Serializable.cpp
+++ b/clicache/src/Serializable.cpp
@@ -154,117 +154,117 @@ namespace Apache
switch (typeId)
{
- case native::GeodeTypeIds::CacheableByte: {
+ case native::DSCode::CacheableByte: {
return Serializable::getCacheableByte((Byte)key);
}
- case native::GeodeTypeIds::CacheableBoolean:
+ case native::DSCode::CacheableBoolean:
return Serializable::getCacheableBoolean((bool)key);
- case native::GeodeTypeIds::CacheableCharacter:
+ case native::DSCode::CacheableCharacter:
return Serializable::getCacheableWideChar((Char)key);
- case native::GeodeTypeIds::CacheableDouble:
+ case native::DSCode::CacheableDouble:
return Serializable::getCacheableDouble((double)key);
- case native::GeodeTypeIds::CacheableASCIIString:
+ case native::DSCode::CacheableASCIIString:
return Serializable::GetCacheableString((String^)key);
- case native::GeodeTypeIds::CacheableFloat:
+ case native::DSCode::CacheableFloat:
return Serializable::getCacheableFloat((float)key);
- case native::GeodeTypeIds::CacheableInt16: {
+ case native::DSCode::CacheableInt16: {
return Serializable::getCacheableInt16((System::Int16)key);
}
- case native::GeodeTypeIds::CacheableInt32: {
+ case native::DSCode::CacheableInt32: {
return Serializable::getCacheableInt32((System::Int32)key);
}
- case native::GeodeTypeIds::CacheableInt64: {
+ case native::DSCode::CacheableInt64: {
return Serializable::getCacheableInt64((System::Int64)key);
}
- case native::GeodeTypeIds::CacheableBytes:
+ case native::DSCode::CacheableBytes:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key));
}
- case native::GeodeTypeIds::CacheableDoubleArray:
+ case native::DSCode::CacheableDoubleArray:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableDoubleArray::Create((array<Double>^)key));
}
- case native::GeodeTypeIds::CacheableFloatArray:
+ case native::DSCode::CacheableFloatArray:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableFloatArray::Create((array<float>^)key));
}
- case native::GeodeTypeIds::CacheableInt16Array:
+ case native::DSCode::CacheableInt16Array:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key));
}
- case native::GeodeTypeIds::CacheableInt32Array:
+ case native::DSCode::CacheableInt32Array:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key));
}
- case native::GeodeTypeIds::CacheableInt64Array:
+ case native::DSCode::CacheableInt64Array:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key));
}
- case native::GeodeTypeIds::CacheableStringArray:
+ case native::DSCode::CacheableStringArray:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableStringArray::Create((array<String^>^)key));
}
- case native::GeodeTypeIds::CacheableFileName:
+ case native::DSCode::CacheableFileName:
{
return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableFileName^)key);
}
- case native::GeodeTypeIds::CacheableHashTable://collection::hashtable
+ case native::DSCode::CacheableHashTable://collection::hashtable
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableHashTable::Create((System::Collections::Hashtable^)key));
}
- case native::GeodeTypeIds::CacheableHashMap://generic dictionary
+ case native::DSCode::CacheableHashMap://generic dictionary
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableHashMap::Create((System::Collections::IDictionary^)key));
}
- case native::GeodeTypeIds::CacheableVector://collection::arraylist
+ case native::DSCode::CacheableVector://collection::arraylist
{
return GetNativeCacheableKeyWrapperForManagedISerializable(CacheableVector::Create((System::Collections::IList^)key));
}
- case native::GeodeTypeIds::CacheableArrayList://generic ilist
+ case native::DSCode::CacheableArrayList://generic ilist
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableArrayList::Create((System::Collections::IList^)key));
}
- case native::GeodeTypeIds::CacheableLinkedList://generic linked list
+ case native::DSCode::CacheableLinkedList://generic linked list
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key));
}
- case native::GeodeTypeIds::CacheableStack:
+ case native::DSCode::CacheableStack:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableStack::Create((System::Collections::ICollection^)key));
}
- case native::GeodeTypeIds::CacheableManagedObject:
+ case native::InternalId::CacheableManagedObject:
{
return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableObject^)key);
}
- case native::GeodeTypeIds::CacheableManagedObjectXml:
+ case native::InternalId::CacheableManagedObjectXml:
{
return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableObjectXml^)key);
}
- case native::GeodeTypeIds::CacheableObjectArray:
+ case native::DSCode::CacheableObjectArray:
{
return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableObjectArray^)key);
}
- case native::GeodeTypeIds::CacheableIdentityHashMap:
+ case native::DSCode::CacheableIdentityHashMap:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key));
}
- case native::GeodeTypeIds::CacheableHashSet://no need of it, default case should work
+ case native::DSCode::CacheableHashSet://no need of it, default case should work
{
return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableHashSet^)key);
}
- case native::GeodeTypeIds::CacheableLinkedHashSet://no need of it, default case should work
+ case native::DSCode::CacheableLinkedHashSet://no need of it, default case should work
{
return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableLinkedHashSet^)key);
}
- case native::GeodeTypeIds::CacheableDate:
+ case native::DSCode::CacheableDate:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableDate::Create((System::DateTime)key));
}
- case native::GeodeTypeIds::BooleanArray:
+ case native::DSCode::BooleanArray:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::BooleanArray::Create((array<bool>^)key));
}
- case native::GeodeTypeIds::CharArray:
+ case native::DSCode::CharArray:
{
return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CharArray::Create((array<Char>^)key));
}
diff --git a/clicache/src/TypeRegistry.cpp b/clicache/src/TypeRegistry.cpp
index 6de9585..944aad1 100644
--- a/clicache/src/TypeRegistry.cpp
+++ b/clicache/src/TypeRegistry.cpp
@@ -327,133 +327,133 @@ namespace Apache
{
switch (dataSerializablePrimitive->getDsCode())
{
- case native::GeodeTypeIds::CacheableDate:
+ case native::DSCode::CacheableDate:
{
auto ret = SafeGenericUMSerializableConvert<CacheableDate^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableBytes:
+ case native::DSCode::CacheableBytes:
{
auto ret = SafeGenericUMSerializableConvert<CacheableBytes^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableDoubleArray:
+ case native::DSCode::CacheableDoubleArray:
{
auto ret = SafeGenericUMSerializableConvert<CacheableDoubleArray^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableFloatArray:
+ case native::DSCode::CacheableFloatArray:
{
auto ret = SafeGenericUMSerializableConvert<CacheableFloatArray^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableInt16Array:
+ case native::DSCode::CacheableInt16Array:
{
auto ret = SafeGenericUMSerializableConvert<CacheableInt16Array^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableInt32Array:
+ case native::DSCode::CacheableInt32Array:
{
auto ret = SafeGenericUMSerializableConvert<CacheableInt32Array^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableInt64Array:
+ case native::DSCode::CacheableInt64Array:
{
auto ret = SafeGenericUMSerializableConvert<CacheableInt64Array^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableStringArray:
+ case native::DSCode::CacheableStringArray:
{
auto ret = SafeGenericUMSerializableConvert<CacheableStringArray^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->GetValues());
}
- case native::GeodeTypeIds::CacheableArrayList://Ilist generic
+ case native::DSCode::CacheableArrayList://Ilist generic
{
auto ret = SafeGenericUMSerializableConvert<CacheableArrayList^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableLinkedList://LinkedList generic
+ case native::DSCode::CacheableLinkedList://LinkedList generic
{
auto ret = SafeGenericUMSerializableConvert<CacheableLinkedList^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableHashTable://collection::hashtable
+ case native::DSCode::CacheableHashTable://collection::hashtable
{
auto ret = SafeGenericUMSerializableConvert<CacheableHashTable^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableHashMap://generic dictionary
+ case native::DSCode::CacheableHashMap://generic dictionary
{
auto ret = SafeGenericUMSerializableConvert<CacheableHashMap^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableIdentityHashMap:
+ case native::DSCode::CacheableIdentityHashMap:
{
auto ret = SafeGenericUMSerializableConvert<CacheableIdentityHashMap^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableHashSet://no need of it, default case should work
+ case native::DSCode::CacheableHashSet://no need of it, default case should work
{
auto ret = SafeGenericUMSerializableConvert<CacheableHashSet^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
- case native::GeodeTypeIds::CacheableLinkedHashSet://no need of it, default case should work
+ case native::DSCode::CacheableLinkedHashSet://no need of it, default case should work
{
auto ret = SafeGenericUMSerializableConvert<CacheableLinkedHashSet^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
- case native::GeodeTypeIds::CacheableFileName:
+ case native::DSCode::CacheableFileName:
{
auto ret = SafeGenericUMSerializableConvert<CacheableFileName^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
- case native::GeodeTypeIds::CacheableObjectArray:
+ case native::DSCode::CacheableObjectArray:
{
auto ret = SafeGenericUMSerializableConvert<CacheableObjectArray^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
- case native::GeodeTypeIds::CacheableVector://collection::arraylist
+ case native::DSCode::CacheableVector://collection::arraylist
{
auto ret = SafeGenericUMSerializableConvert<CacheableVector^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableUndefined:
+ case native::DSFid::CacheableUndefined:
{
auto ret = SafeGenericUMSerializableConvert<CacheableUndefined^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
- case native::GeodeTypeIds::Struct:
+ case native::DSFid::Struct:
{
return safe_cast<TValue>(Struct::Create(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableStack:
+ case native::DSCode::CacheableStack:
{
auto ret = SafeGenericUMSerializableConvert<CacheableStack^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CacheableManagedObject:
+ case native::InternalId::CacheableManagedObject:
{
auto ret = SafeGenericUMSerializableConvert<CacheableObject^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
- case native::GeodeTypeIds::CacheableManagedObjectXml:
+ case native::InternalId::CacheableManagedObjectXml:
{
auto ret = SafeGenericUMSerializableConvert<CacheableObjectXml^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
/*
- case native::GeodeTypeIds::Properties: // TODO: replace with IDictionary<K, V>
+ case native::DSCode::Properties: // TODO: replace with IDictionary<K, V>
{
auto ret = SafeGenericUMSerializableConvert<Properties<Object^, Object^>^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret);
}
*/
- case native::GeodeTypeIds::BooleanArray:
+ case native::DSCode::BooleanArray:
{
auto ret = SafeGenericUMSerializableConvert<BooleanArray^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
}
- case native::GeodeTypeIds::CharArray:
+ case native::DSCode::CharArray:
{
auto ret = SafeGenericUMSerializableConvert<CharArray^>(dataSerializablePrimitive);
return safe_cast<TValue>(ret->Value);
@@ -480,42 +480,42 @@ namespace Apache
{
switch (dataSerializablePrimitive->getDsCode())
{
- case native::GeodeTypeIds::CacheableByte:
+ case native::DSCode::CacheableByte:
{
return safe_cast<TValue>(Serializable::getByte(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableBoolean:
+ case native::DSCode::CacheableBoolean:
{
return safe_cast<TValue>(Serializable::getBoolean(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableCharacter:
+ case native::DSCode::CacheableCharacter:
{
return safe_cast<TValue>(Serializable::getChar(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableDouble:
+ case native::DSCode::CacheableDouble:
{
return safe_cast<TValue>(Serializable::getDouble(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableASCIIString:
- case native::GeodeTypeIds::CacheableASCIIStringHuge:
- case native::GeodeTypeIds::CacheableString:
- case native::GeodeTypeIds::CacheableStringHuge:
+ case native::DSCode::CacheableASCIIString:
+ case native::DSCode::CacheableASCIIStringHuge:
+ case native::DSCode::CacheableString:
+ case native::DSCode::CacheableStringHuge:
{
return safe_cast<TValue>(Serializable::getString(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableFloat:
+ case native::DSCode::CacheableFloat:
{
return safe_cast<TValue>(Serializable::getFloat(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableInt16:
+ case native::DSCode::CacheableInt16:
{
return safe_cast<TValue>(Serializable::getInt16(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableInt32:
+ case native::DSCode::CacheableInt32:
{
return safe_cast<TValue>(Serializable::getInt32(dataSerializablePrimitive));
}
- case native::GeodeTypeIds::CacheableInt64:
+ case native::DSCode::CacheableInt64:
{
return safe_cast<TValue>(Serializable::getInt64(dataSerializablePrimitive));
}
@@ -527,11 +527,11 @@ namespace Apache
{
switch (dataSerializableFixedId->getDSFID())
{
- case native::GeodeTypeIds::Struct:
+ case native::DSFid::Struct:
{
return safe_cast<TValue>(Struct::Create(val));
}
- case native::GeodeTypeIds::CacheableUndefined:
+ case native::DSFid::CacheableUndefined:
{
return safe_cast<TValue>(CacheableUndefined::Create());
}
@@ -705,39 +705,39 @@ namespace Apache
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableByte::Create),
- native::GeodeTypeIds::CacheableByte, Byte::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableByte), Byte::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableBoolean::Create),
- native::GeodeTypeIds::CacheableBoolean, Boolean::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableBoolean), Boolean::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableCharacter::Create),
- native::GeodeTypeIds::CacheableCharacter, Char::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableCharacter), Char::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableDouble::Create),
- native::GeodeTypeIds::CacheableDouble, Double::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableDouble), Double::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableString::Create),
- native::GeodeTypeIds::CacheableASCIIString, String::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableASCIIString), String::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableFloat::Create),
- native::GeodeTypeIds::CacheableFloat, float::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableFloat), float::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableInt16::Create),
- native::GeodeTypeIds::CacheableInt16, Int16::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableInt16), Int16::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableInt32::Create),
- native::GeodeTypeIds::CacheableInt32, Int32::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableInt32), Int32::typeid);
RegisterDataSerializablePrimitiveWrapper(
gcnew DataSerializablePrimitiveWrapperDelegate(CacheableInt64::Create),
- native::GeodeTypeIds::CacheableInt64, Int64::typeid);
+ static_cast<int8_t>(native::DSCode::CacheableInt64), Int64::typeid);
}
} // namespace Client
diff --git a/clicache/src/TypeRegistry.hpp b/clicache/src/TypeRegistry.hpp
index f99c5ff..3d22d6e 100644
--- a/clicache/src/TypeRegistry.hpp
+++ b/clicache/src/TypeRegistry.hpp
@@ -275,44 +275,44 @@ namespace Apache
static void InitializeManagedTypeToDsCode()
{
Dictionary<Object^, Object^>^ dic = gcnew Dictionary<Object^, Object^>();
- ManagedTypeToDsCode[dic->GetType()] = native::GeodeTypeIds::CacheableHashMap;
- ManagedTypeToDsCode[dic->GetType()->GetGenericTypeDefinition()] = native::GeodeTypeIds::CacheableHashMap;
+ ManagedTypeToDsCode[dic->GetType()] = static_cast<int8_t>(native::DSCode::CacheableHashMap);
+ ManagedTypeToDsCode[dic->GetType()->GetGenericTypeDefinition()] = static_cast<int8_t>(native::DSCode::CacheableHashMap);
System::Collections::ArrayList^ arr = gcnew System::Collections::ArrayList();
- ManagedTypeToDsCode[arr->GetType()] = native::GeodeTypeIds::CacheableVector;
+ ManagedTypeToDsCode[arr->GetType()] = static_cast<int8_t>(native::DSCode::CacheableVector);
System::Collections::Generic::LinkedList<Object^>^ linketList = gcnew System::Collections::Generic::LinkedList<Object^>();
- ManagedTypeToDsCode[linketList->GetType()] = native::GeodeTypeIds::CacheableLinkedList;
- ManagedTypeToDsCode[linketList->GetType()->GetGenericTypeDefinition()] = native::GeodeTypeIds::CacheableLinkedList;
+ ManagedTypeToDsCode[linketList->GetType()] = static_cast<int8_t>(native::DSCode::CacheableLinkedList);
+ ManagedTypeToDsCode[linketList->GetType()->GetGenericTypeDefinition()] = static_cast<int8_t>(native::DSCode::CacheableLinkedList);
System::Collections::Generic::IList<Object^>^ iList = gcnew System::Collections::Generic::List<Object^>();
- ManagedTypeToDsCode[iList->GetType()] = native::GeodeTypeIds::CacheableArrayList;
- ManagedTypeToDsCode[iList->GetType()->GetGenericTypeDefinition()] = native::GeodeTypeIds::CacheableArrayList;
+ ManagedTypeToDsCode[iList->GetType()] = static_cast<int8_t>(native::DSCode::CacheableArrayList);
+ ManagedTypeToDsCode[iList->GetType()->GetGenericTypeDefinition()] = static_cast<int8_t>(native::DSCode::CacheableArrayList);
//TODO: Linked list, non generic stack, some other map types and see if more
System::Collections::Generic::Stack<Object^>^ stack = gcnew System::Collections::Generic::Stack<Object^>();
- ManagedTypeToDsCode[stack->GetType()] = native::GeodeTypeIds::CacheableStack;
- ManagedTypeToDsCode[stack->GetType()->GetGenericTypeDefinition()] = native::GeodeTypeIds::CacheableStack;
-
- ManagedTypeToDsCode[Byte::typeid] = native::GeodeTypeIds::CacheableByte;
- ManagedTypeToDsCode[Boolean::typeid] = native::GeodeTypeIds::CacheableBoolean;
- ManagedTypeToDsCode[Char::typeid] = native::GeodeTypeIds::CacheableCharacter;
- ManagedTypeToDsCode[Double::typeid] = native::GeodeTypeIds::CacheableDouble;
- ManagedTypeToDsCode[String::typeid] = native::GeodeTypeIds::CacheableASCIIString;
- ManagedTypeToDsCode[float::typeid] = native::GeodeTypeIds::CacheableFloat;
- ManagedTypeToDsCode[Int16::typeid] = native::GeodeTypeIds::CacheableInt16;
- ManagedTypeToDsCode[Int32::typeid] = native::GeodeTypeIds::CacheableInt32;
- ManagedTypeToDsCode[Int64::typeid] = native::GeodeTypeIds::CacheableInt64;
- ManagedTypeToDsCode[Type::GetType("System.Byte[]")] = native::GeodeTypeIds::CacheableBytes;
- ManagedTypeToDsCode[Type::GetType("System.Double[]")] = native::GeodeTypeIds::CacheableDoubleArray;
- ManagedTypeToDsCode[Type::GetType("System.Single[]")] = native::GeodeTypeIds::CacheableFloatArray;
- ManagedTypeToDsCode[Type::GetType("System.Int16[]")] = native::GeodeTypeIds::CacheableInt16Array;
- ManagedTypeToDsCode[Type::GetType("System.Int32[]")] = native::GeodeTypeIds::CacheableInt32Array;
- ManagedTypeToDsCode[Type::GetType("System.Int64[]")] = native::GeodeTypeIds::CacheableInt64Array;
- ManagedTypeToDsCode[Type::GetType("System.String[]")] = native::GeodeTypeIds::CacheableStringArray;
- ManagedTypeToDsCode[Type::GetType("System.DateTime")] = native::GeodeTypeIds::CacheableDate;
- ManagedTypeToDsCode[Type::GetType("System.Collections.Hashtable")] = native::GeodeTypeIds::CacheableHashTable;
+ ManagedTypeToDsCode[stack->GetType()] = static_cast<int8_t>(native::DSCode::CacheableStack);
+ ManagedTypeToDsCode[stack->GetType()->GetGenericTypeDefinition()] = static_cast<int8_t>(native::DSCode::CacheableStack);
+
+ ManagedTypeToDsCode[Byte::typeid] = static_cast<int8_t>(native::DSCode::CacheableByte);
+ ManagedTypeToDsCode[Boolean::typeid] = static_cast<int8_t>(native::DSCode::CacheableBoolean);
+ ManagedTypeToDsCode[Char::typeid] = static_cast<int8_t>(native::DSCode::CacheableCharacter);
+ ManagedTypeToDsCode[Double::typeid] = static_cast<int8_t>(native::DSCode::CacheableDouble);
+ ManagedTypeToDsCode[String::typeid] = static_cast<int8_t>(native::DSCode::CacheableASCIIString);
+ ManagedTypeToDsCode[float::typeid] = static_cast<int8_t>(native::DSCode::CacheableFloat);
+ ManagedTypeToDsCode[Int16::typeid] = static_cast<int8_t>(native::DSCode::CacheableInt16);
+ ManagedTypeToDsCode[Int32::typeid] = static_cast<int8_t>(native::DSCode::CacheableInt32);
+ ManagedTypeToDsCode[Int64::typeid] = static_cast<int8_t>(native::DSCode::CacheableInt64);
+ ManagedTypeToDsCode[Type::GetType("System.Byte[]")] = static_cast<int8_t>(native::DSCode::CacheableBytes);
+ ManagedTypeToDsCode[Type::GetType("System.Double[]")] = static_cast<int8_t>(native::DSCode::CacheableDoubleArray);
+ ManagedTypeToDsCode[Type::GetType("System.Single[]")] = static_cast<int8_t>(native::DSCode::CacheableFloatArray);
+ ManagedTypeToDsCode[Type::GetType("System.Int16[]")] = static_cast<int8_t>(native::DSCode::CacheableInt16Array);
+ ManagedTypeToDsCode[Type::GetType("System.Int32[]")] = static_cast<int8_t>(native::DSCode::CacheableInt32Array);
+ ManagedTypeToDsCode[Type::GetType("System.Int64[]")] = static_cast<int8_t>(native::DSCode::CacheableInt64Array);
+ ManagedTypeToDsCode[Type::GetType("System.String[]")] = static_cast<int8_t>(native::DSCode::CacheableStringArray);
+ ManagedTypeToDsCode[Type::GetType("System.DateTime")] = static_cast<int8_t>(native::DSCode::CacheableDate);
+ ManagedTypeToDsCode[Type::GetType("System.Collections.Hashtable")] = static_cast<int8_t>(native::DSCode::CacheableHashTable);
}
static void RegisterDataSerializablePrimitivesWrapNativeDeserialization();
diff --git a/clicache/src/geode_includes.hpp b/clicache/src/geode_includes.hpp
index bf2b3f8..8ddce3f 100644
--- a/clicache/src/geode_includes.hpp
+++ b/clicache/src/geode_includes.hpp
@@ -36,7 +36,7 @@
#include <geode/CacheListener.hpp>
#include <geode/FixedPartitionResolver.hpp>
#include <geode/CacheWriter.hpp>
-#include <geode/GeodeTypeIds.hpp>
+#include <geode/internal/InternalId.hpp>
#include "end_native.hpp"
// Include private headers from CPP Cache
diff --git a/clicache/src/impl/EnumInfo.hpp b/clicache/src/impl/EnumInfo.hpp
index 09e562a..7cca168 100755
--- a/clicache/src/impl/EnumInfo.hpp
+++ b/clicache/src/impl/EnumInfo.hpp
@@ -69,7 +69,7 @@ namespace Apache
property Int32 DSFID
{
- virtual Int32 get() { return GeodeTypeIds::EnumInfo; }
+ virtual Int32 get() { return static_cast<Int32>(apache::geode::client::DSFid::EnumInfo); }
}
virtual String^ ToString() override
diff --git a/clicache/src/impl/ManagedCacheableDelta.cpp b/clicache/src/impl/ManagedCacheableDelta.cpp
index 6caa28d..42b9d09 100644
--- a/clicache/src/impl/ManagedCacheableDelta.cpp
+++ b/clicache/src/impl/ManagedCacheableDelta.cpp
@@ -17,7 +17,6 @@
#include "../begin_native.hpp"
-#include <GeodeTypeIdsImpl.hpp>
#include "../end_native.hpp"
#include "ManagedCacheableDelta.hpp"
diff --git a/clicache/src/impl/ManagedCacheableKey.cpp b/clicache/src/impl/ManagedCacheableKey.cpp
index 36581d9..dc36cea 100644
--- a/clicache/src/impl/ManagedCacheableKey.cpp
+++ b/clicache/src/impl/ManagedCacheableKey.cpp
@@ -17,7 +17,6 @@
#include "../begin_native.hpp"
-#include <GeodeTypeIdsImpl.hpp>
#include "../end_native.hpp"
#include "../ICacheableKey.hpp"
diff --git a/clicache/src/impl/ManagedCacheableKey.hpp b/clicache/src/impl/ManagedCacheableKey.hpp
index acbaa2d..e9f212c 100644
--- a/clicache/src/impl/ManagedCacheableKey.hpp
+++ b/clicache/src/impl/ManagedCacheableKey.hpp
@@ -22,7 +22,6 @@
#include <vcclr.h>
#include "../begin_native.hpp"
#include <geode/CacheableKey.hpp>
-#include <GeodeTypeIdsImpl.hpp>
#include "../end_native.hpp"
#include "../IDataSerializable.hpp"
@@ -142,7 +141,7 @@ namespace apache
void fromData(DataInput& input) override;
- int8_t getDsCode() const override { return m_managedptr->DsCode; }
+ DSCode getDsCode() const override { return static_cast<DSCode>(m_managedptr->DsCode); }
bool operator == (const CacheableKey& other) const override;
@@ -212,7 +211,7 @@ namespace apache
void fromData(DataInput& input) override;
- int32_t getDSFID() const override { return m_managedptr->DSFID; }
+ DSFid getDSFID() const override { return static_cast<DSFid>(m_managedptr->DSFID); }
inline Apache::Geode::Client::IDataSerializableFixedId^ ptr() const
{
diff --git a/clicache/src/impl/PdxFieldType.cpp b/clicache/src/impl/PdxFieldType.cpp
index 7d2dae8..04d8f99 100644
--- a/clicache/src/impl/PdxFieldType.cpp
+++ b/clicache/src/impl/PdxFieldType.cpp
@@ -20,7 +20,6 @@
#include "PdxFieldType.hpp"
#include "../begin_native.hpp"
-#include <geode/GeodeTypeIds.hpp>
#include <PdxTypes.hpp>
#include "../end_native.hpp"
diff --git a/clicache/src/impl/PdxInstanceFactoryImpl.cpp b/clicache/src/impl/PdxInstanceFactoryImpl.cpp
index 4251982..5b09927 100644
--- a/clicache/src/impl/PdxInstanceFactoryImpl.cpp
+++ b/clicache/src/impl/PdxInstanceFactoryImpl.cpp
@@ -16,7 +16,6 @@
*/
#include "../begin_native.hpp"
-#include <geode/GeodeTypeIds.hpp>
#include <PdxTypes.hpp>
#include "../end_native.hpp"
diff --git a/clicache/src/impl/PdxInstanceImpl.hpp b/clicache/src/impl/PdxInstanceImpl.hpp
index bcfbb31..a3eb779 100755
--- a/clicache/src/impl/PdxInstanceImpl.hpp
+++ b/clicache/src/impl/PdxInstanceImpl.hpp
@@ -67,8 +67,8 @@ namespace Apache
static array<SByte>^ Float_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
static array<SByte>^ Double_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
static array<SByte>^ Date_DefaultBytes = gcnew array<SByte>{-1, -1, -1, -1, -1, -1, -1, -1};
- static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::CacheableNullString};
- static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::NullObj};
+ static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{static_cast<SByte>(apache::geode::client::DSCode::CacheableNullString)};
+ static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{static_cast<SByte>(apache::geode::client::DSCode::NullObj)};
static array<SByte>^ NULL_ARRAY_DefaultBytes = gcnew array<SByte>{-1};
static PdxFieldType^ Default_PdxFieldType = gcnew PdxFieldType("default", "default", -1,
diff --git a/clicache/src/impl/PdxManagedCacheableKey.cpp b/clicache/src/impl/PdxManagedCacheableKey.cpp
index c1b8939..272db16 100644
--- a/clicache/src/impl/PdxManagedCacheableKey.cpp
+++ b/clicache/src/impl/PdxManagedCacheableKey.cpp
@@ -20,7 +20,6 @@
#include "PdxManagedCacheableKey.hpp"
#include "../begin_native.hpp"
-#include <GeodeTypeIdsImpl.hpp>
#include "../end_native.hpp"
#include "../DataInput.hpp"
diff --git a/clicache/src/impl/PdxManagedCacheableKey.hpp b/clicache/src/impl/PdxManagedCacheableKey.hpp
index db38be3..12ddcba 100644
--- a/clicache/src/impl/PdxManagedCacheableKey.hpp
+++ b/clicache/src/impl/PdxManagedCacheableKey.hpp
@@ -22,7 +22,6 @@
#include "../begin_native.hpp"
#include <geode/CacheableKey.hpp>
#include <geode/Delta.hpp>
-#include <GeodeTypeIdsImpl.hpp>
#include "../end_native.hpp"
#include "../geode_defs.hpp"
diff --git a/clicache/src/impl/PdxReaderWithTypeCollector.cpp b/clicache/src/impl/PdxReaderWithTypeCollector.cpp
index bcaf069..4380e4a 100644
--- a/clicache/src/impl/PdxReaderWithTypeCollector.cpp
+++ b/clicache/src/impl/PdxReaderWithTypeCollector.cpp
@@ -18,7 +18,6 @@
#include "PdxReaderWithTypeCollector.hpp"
#include "../begin_native.hpp"
-#include <geode/GeodeTypeIds.hpp>
#include <PdxTypes.hpp>
#include "../end_native.hpp"
diff --git a/clicache/src/impl/PdxType.cpp b/clicache/src/impl/PdxType.cpp
index 535f40d..bf17ee3 100644
--- a/clicache/src/impl/PdxType.cpp
+++ b/clicache/src/impl/PdxType.cpp
@@ -70,8 +70,8 @@ namespace Apache
void PdxType::ToData(DataOutput^ output)
{
//defaulf java Dataserializable require this
- output->WriteByte(GeodeTypeIdsImpl::DataSerializable);
- output->WriteByte(GeodeTypeIdsImpl::Class);
+ output->WriteByte(static_cast<int8_t>(DSCode::DataSerializable));
+ output->WriteByte(static_cast<int8_t>(DSCode::Class));
output->WriteObject((Object^)m_javaPdxClass);
//pdx type
diff --git a/clicache/src/impl/PdxWriterWithTypeCollector.cpp b/clicache/src/impl/PdxWriterWithTypeCollector.cpp
index ca6201d..850f1f4 100644
--- a/clicache/src/impl/PdxWriterWithTypeCollector.cpp
+++ b/clicache/src/impl/PdxWriterWithTypeCollector.cpp
@@ -16,7 +16,6 @@
*/
#include "../begin_native.hpp"
-#include <geode/GeodeTypeIds.hpp>
#include <PdxTypes.hpp>
#include "../end_native.hpp"
diff --git a/clicache/src/impl/SafeConvert.hpp b/clicache/src/impl/SafeConvert.hpp
index fe22de9..73acc85 100644
--- a/clicache/src/impl/SafeConvert.hpp
+++ b/clicache/src/impl/SafeConvert.hpp
@@ -76,7 +76,7 @@ namespace Apache
}
else if (auto primitive = std::dynamic_pointer_cast<native::DataSerializablePrimitive>(serializableObject))
{
- if (auto wrapperMethod = TypeRegistry::GetDataSerializablePrimitiveWrapperDelegateForDsCode(primitive->getDsCode()))
+ if (auto wrapperMethod = TypeRegistry::GetDataSerializablePrimitiveWrapperDelegateForDsCode(static_cast<int8_t>(primitive->getDsCode())))
{
return wrapperMethod(primitive);
}
@@ -175,7 +175,7 @@ namespace Apache
}
if (auto primitive = std::dynamic_pointer_cast<native::DataSerializablePrimitive>(obj)) {
- auto wrapperMethod = TypeRegistry::GetDataSerializablePrimitiveWrapperDelegateForDsCode( primitive->getDsCode( ) );
+ auto wrapperMethod = TypeRegistry::GetDataSerializablePrimitiveWrapperDelegateForDsCode(static_cast<int8_t>(primitive->getDsCode()));
if (wrapperMethod != nullptr)
{
return (Client::ICacheableKey^)wrapperMethod(primitive);
diff --git a/cppcache/include/geode/CacheableBuiltins.hpp b/cppcache/include/geode/CacheableBuiltins.hpp
index a371dee..336b4c3 100644
--- a/cppcache/include/geode/CacheableBuiltins.hpp
+++ b/cppcache/include/geode/CacheableBuiltins.hpp
@@ -38,7 +38,7 @@ namespace geode {
namespace client {
/** Template CacheableKey class for primitive types. */
-template <typename TObj, int8_t TYPEID, const char* TYPENAME>
+template <typename TObj, DSCode TYPEID, const char* TYPENAME>
class APACHE_GEODE_EXPORT CacheableKeyType : public DataSerializablePrimitive,
public CacheableKey {
protected:
@@ -63,7 +63,7 @@ class APACHE_GEODE_EXPORT CacheableKeyType : public DataSerializablePrimitive,
apache::geode::client::serializer::readObject(input, m_value);
}
- virtual int8_t getDsCode() const override { return TYPEID; }
+ virtual DSCode getDsCode() const override { return TYPEID; }
/** Return a string representation of the object. */
virtual std::string toString() const override {
@@ -126,7 +126,7 @@ inline void copyArray(std::shared_ptr<TObj>* dest,
}
/** Template class for container Cacheable types. */
-template <typename TBase, int8_t TYPEID>
+template <typename TBase, DSCode TYPEID>
class APACHE_GEODE_EXPORT CacheableContainerType
: public DataSerializablePrimitive,
public TBase {
@@ -146,7 +146,7 @@ class APACHE_GEODE_EXPORT CacheableContainerType
apache::geode::client::serializer::readObject(input, *this);
}
- int8_t getDsCode() const override { return TYPEID; }
+ DSCode getDsCode() const override { return TYPEID; }
size_t objectSize() const override {
return sizeof(CacheableContainerType) + serializer::objectSize(*this);
@@ -160,8 +160,8 @@ class APACHE_GEODE_EXPORT CacheableContainerType
#define _GEODE_CACHEABLE_KEY_TYPE_DEF_(p, k) \
extern const char tName_##k[]; \
- template class CacheableKeyType<p, GeodeTypeIds::k, tName_##k>; \
- typedef CacheableKeyType<p, GeodeTypeIds::k, tName_##k> _##k;
+ template class CacheableKeyType<p, DSCode::k, tName_##k>; \
+ typedef CacheableKeyType<p, DSCode::k, tName_##k> _##k;
// use a class instead of typedef for bug #283
#define _GEODE_CACHEABLE_KEY_TYPE_(p, k) \
@@ -195,8 +195,8 @@ class APACHE_GEODE_EXPORT CacheableContainerType
}
#define _GEODE_CACHEABLE_CONTAINER_TYPE_DEF_(p, c) \
- template class CacheableContainerType<p, GeodeTypeIds::c>; \
- typedef CacheableContainerType<p, GeodeTypeIds::c> _##c;
+ template class CacheableContainerType<p, DSCode::c>; \
+ typedef CacheableContainerType<p, DSCode::c> _##c;
// use a class instead of typedef for bug #283
#define _GEODE_CACHEABLE_CONTAINER_TYPE_(p, c) \
@@ -282,7 +282,7 @@ _GEODE_CACHEABLE_KEY_TYPE_(char16_t, CacheableCharacter)
// Instantiations for array built-in Cacheables
-template <typename T, GeodeTypeIds::IdValues GeodeTypeId>
+template <typename T, DSCode GeodeTypeId>
class APACHE_GEODE_EXPORT CacheableArray : public DataSerializablePrimitive {
protected:
inline CacheableArray() = default;
@@ -294,7 +294,7 @@ class APACHE_GEODE_EXPORT CacheableArray : public DataSerializablePrimitive {
template <typename TT>
CacheableArray(TT&& value) : m_value(std::forward<TT>(value)) {}
- virtual int8_t getDsCode() const override { return GeodeTypeId; }
+ virtual DSCode getDsCode() const override { return GeodeTypeId; }
virtual size_t objectSize() const override {
return static_cast<uint32_t>(
@@ -350,61 +350,61 @@ class APACHE_GEODE_EXPORT CacheableArray : public DataSerializablePrimitive {
* An immutable wrapper for byte arrays that can serve as
* a distributable object for caching.
*/
-using CacheableBytes = CacheableArray<int8_t, GeodeTypeIds::CacheableBytes>;
+using CacheableBytes = CacheableArray<int8_t, DSCode::CacheableBytes>;
/**
* An immutable wrapper for array of booleans that can serve as
* a distributable object for caching.
*/
-using BooleanArray = CacheableArray<bool, GeodeTypeIds::BooleanArray>;
+using BooleanArray = CacheableArray<bool, DSCode::BooleanArray>;
/**
* An immutable wrapper for array of wide-characters that can serve as
* a distributable object for caching.
*/
-using CharArray = CacheableArray<char16_t, GeodeTypeIds::CharArray>;
+using CharArray = CacheableArray<char16_t, DSCode::CharArray>;
/**
* An immutable wrapper for array of doubles that can serve as
* a distributable object for caching.
*/
using CacheableDoubleArray =
- CacheableArray<double, GeodeTypeIds::CacheableDoubleArray>;
+ CacheableArray<double, DSCode::CacheableDoubleArray>;
/**
* An immutable wrapper for array of floats that can serve as
* a distributable object for caching.
*/
using CacheableFloatArray =
- CacheableArray<float, GeodeTypeIds::CacheableFloatArray>;
+ CacheableArray<float, DSCode::CacheableFloatArray>;
/**
* An immutable wrapper for array of 16-bit integers that can serve as
* a distributable object for caching.
*/
using CacheableInt16Array =
- CacheableArray<int16_t, GeodeTypeIds::CacheableInt16Array>;
+ CacheableArray<int16_t, DSCode::CacheableInt16Array>;
/**
* An immutable wrapper for array of 32-bit integers that can serve as
* a distributable object for caching.
*/
using CacheableInt32Array =
- CacheableArray<int32_t, GeodeTypeIds::CacheableInt32Array>;
+ CacheableArray<int32_t, DSCode::CacheableInt32Array>;
/**
* An immutable wrapper for array of 64-bit integers that can serve as
* a distributable object for caching.
*/
using CacheableInt64Array =
- CacheableArray<int64_t, GeodeTypeIds::CacheableInt64Array>;
+ CacheableArray<int64_t, DSCode::CacheableInt64Array>;
/**
* An immutable wrapper for array of strings that can serve as
* a distributable object for caching.
*/
using CacheableStringArray = CacheableArray<std::shared_ptr<CacheableString>,
- GeodeTypeIds::CacheableStringArray>;
+ DSCode::CacheableStringArray>;
// Instantiations for container types (Vector/HashMap/HashSet) Cacheables
diff --git a/cppcache/include/geode/CacheableDate.hpp b/cppcache/include/geode/CacheableDate.hpp
index 3591dd2..be00a18 100644
--- a/cppcache/include/geode/CacheableDate.hpp
+++ b/cppcache/include/geode/CacheableDate.hpp
@@ -23,7 +23,6 @@
#include "internal/geode_globals.hpp"
#include "CacheableKey.hpp"
#include "CacheableString.hpp"
-#include "GeodeTypeIds.hpp"
#include "ExceptionTypes.hpp"
#include <string>
@@ -64,7 +63,7 @@ class APACHE_GEODE_EXPORT CacheableDate : public DataSerializablePrimitive,
*/
static std::shared_ptr<Serializable> createDeserializable();
- virtual int8_t getDsCode() const override;
+ virtual DSCode getDsCode() const override;
/** @return the size of the object in bytes */
virtual size_t objectSize() const override { return sizeof(CacheableDate); }
diff --git a/cppcache/include/geode/CacheableEnum.hpp b/cppcache/include/geode/CacheableEnum.hpp
index db71a29..a81b617 100644
--- a/cppcache/include/geode/CacheableEnum.hpp
+++ b/cppcache/include/geode/CacheableEnum.hpp
@@ -26,7 +26,6 @@
#include "CacheableKey.hpp"
#include "CacheableString.hpp"
-#include "GeodeTypeIds.hpp"
#include "internal/geode_base.hpp"
namespace apache {
@@ -81,8 +80,8 @@ class APACHE_GEODE_EXPORT CacheableEnum : public DataSerializablePrimitive,
return size;
}
- virtual int8_t getDsCode() const override {
- return static_cast<int8_t>(GeodeTypeIds::CacheableEnum);
+ virtual DSCode getDsCode() const override {
+ return DSCode::CacheableEnum;
}
/**
diff --git a/cppcache/include/geode/CacheableFileName.hpp b/cppcache/include/geode/CacheableFileName.hpp
index 0ae258d..8fc480b 100644
--- a/cppcache/include/geode/CacheableFileName.hpp
+++ b/cppcache/include/geode/CacheableFileName.hpp
@@ -49,7 +49,7 @@ class APACHE_GEODE_EXPORT CacheableFileName : public CacheableString {
virtual void fromData(DataInput& input) override;
- virtual int8_t getDsCode() const override;
+ virtual DSCode getDsCode() const override;
/**
* @brief creation function for filenames.
diff --git a/cppcache/include/geode/CacheableObjectArray.hpp b/cppcache/include/geode/CacheableObjectArray.hpp
index 51ed158..df9b0d8 100644
--- a/cppcache/include/geode/CacheableObjectArray.hpp
+++ b/cppcache/include/geode/CacheableObjectArray.hpp
@@ -26,7 +26,7 @@
#include "internal/geode_globals.hpp"
#include "internal/DataSerializablePrimitive.hpp"
#include "Serializable.hpp"
-#include "GeodeTypeIds.hpp"
+#include "internal/DSCode.hpp"
/** @file
*/
@@ -58,8 +58,8 @@ class APACHE_GEODE_EXPORT CacheableObjectArray
return std::make_shared<CacheableObjectArray>();
}
- int8_t getDsCode() const override {
- return GeodeTypeIds::CacheableObjectArray;
+ internal::DSCode getDsCode() const override {
+ return internal::DSCode::CacheableObjectArray;
}
/**
diff --git a/cppcache/include/geode/CacheableString.hpp b/cppcache/include/geode/CacheableString.hpp
index ddff4e8..0eac76b 100644
--- a/cppcache/include/geode/CacheableString.hpp
+++ b/cppcache/include/geode/CacheableString.hpp
@@ -23,7 +23,7 @@
#include "internal/geode_globals.hpp"
#include "internal/DataSerializablePrimitive.hpp"
#include "CacheableKey.hpp"
-#include "GeodeTypeIds.hpp"
+#include "internal/DSCode.hpp"
/** @file
*/
@@ -41,7 +41,7 @@ class APACHE_GEODE_EXPORT CacheableString
public CacheableKey {
protected:
std::string m_str;
- int8_t m_type;
+ internal::DSCode m_type;
mutable int m_hashcode;
_GEODE_FRIEND_STD_SHARED_PTR(CacheableString)
@@ -51,7 +51,7 @@ class APACHE_GEODE_EXPORT CacheableString
void fromData(DataInput& input) override;
- int8_t getDsCode() const override { return m_type; }
+ DSCode getDsCode() const override { return m_type; }
/** creation function for strings */
static std::shared_ptr<Serializable> createDeserializable();
@@ -115,7 +115,7 @@ class APACHE_GEODE_EXPORT CacheableString
protected:
/** Default constructor. */
- inline CacheableString(int8_t type = GeodeTypeIds::CacheableASCIIString)
+ inline CacheableString(DSCode type = DSCode::CacheableASCIIString)
: m_str(), m_type(type), m_hashcode(0) {}
inline CacheableString(const std::string& value)
@@ -126,10 +126,10 @@ class APACHE_GEODE_EXPORT CacheableString
bool ascii = isAscii(m_str);
m_type = m_str.length() > std::numeric_limits<uint16_t>::max()
- ? ascii ? GeodeTypeIds::CacheableASCIIStringHuge
- : GeodeTypeIds::CacheableStringHuge
- : ascii ? GeodeTypeIds::CacheableASCIIString
- : GeodeTypeIds::CacheableString;
+ ? ascii ? DSCode::CacheableASCIIStringHuge
+ : DSCode::CacheableStringHuge
+ : ascii ? DSCode::CacheableASCIIString
+ : DSCode::CacheableString;
}
private:
diff --git a/cppcache/include/geode/CacheableUndefined.hpp b/cppcache/include/geode/CacheableUndefined.hpp
index b5bbd32..3df7033 100644
--- a/cppcache/include/geode/CacheableUndefined.hpp
+++ b/cppcache/include/geode/CacheableUndefined.hpp
@@ -25,7 +25,7 @@
#include "internal/DataSerializableFixedId.hpp"
#include "internal/geode_globals.hpp"
#include "Serializable.hpp"
-#include "GeodeTypeIds.hpp"
+#include "internal/DSFixedId.hpp"
/** @file
*/
@@ -39,8 +39,7 @@ class DataOutput;
class Serializable;
class APACHE_GEODE_EXPORT CacheableUndefined
- : public internal::DataSerializableFixedId_t<
- GeodeTypeIds::CacheableUndefined> {
+ : public internal::DataSerializableFixedId_t<internal::DSFid::CacheableUndefined> {
public:
void toData(DataOutput&) const override;
diff --git a/cppcache/include/geode/DataInput.hpp b/cppcache/include/geode/DataInput.hpp
index 17a0964..bd5d3b1 100644
--- a/cppcache/include/geode/DataInput.hpp
+++ b/cppcache/include/geode/DataInput.hpp
@@ -28,7 +28,7 @@
#include "internal/geode_globals.hpp"
#include "ExceptionTypes.hpp"
-#include "GeodeTypeIds.hpp"
+#include "internal/DSCode.hpp"
#include "ExceptionTypes.hpp"
/**
@@ -310,23 +310,26 @@ class APACHE_GEODE_EXPORT DataInput {
template <class CharT = char, class... Tail>
inline std::basic_string<CharT, Tail...> readString() {
std::basic_string<CharT, Tail...> value;
- const uint8_t type = read();
+ auto type = static_cast<internal::DSCode >(read());
switch (type) {
- case GeodeTypeIds::CacheableString:
+ case internal::DSCode::CacheableString:
readJavaModifiedUtf8(value);
break;
- case GeodeTypeIds::CacheableStringHuge:
+ case internal::DSCode::CacheableStringHuge:
readUtf16Huge(value);
break;
- case GeodeTypeIds::CacheableASCIIString:
+ case internal::DSCode::CacheableASCIIString:
readAscii(value);
break;
- case GeodeTypeIds::CacheableASCIIStringHuge:
+ case internal::DSCode::CacheableASCIIStringHuge:
readAsciiHuge(value);
break;
- case GeodeTypeIds::CacheableNullString:
+ case internal::DSCode::CacheableNullString:
// empty string
break;
+ // TODO: What's the right response here?
+ default:
+ break;
}
return value;
}
diff --git a/cppcache/include/geode/DataOutput.hpp b/cppcache/include/geode/DataOutput.hpp
index 0f9a01a..872ab6b 100644
--- a/cppcache/include/geode/DataOutput.hpp
+++ b/cppcache/include/geode/DataOutput.hpp
@@ -282,7 +282,7 @@ class APACHE_GEODE_EXPORT DataOutput {
inline void writeString(const _CharT* value) {
// TODO string should we convert to empty string?
if (nullptr == value) {
- write(static_cast<uint8_t>(GeodeTypeIds::CacheableNullString));
+ write(static_cast<uint8_t>(DSCode::CacheableNullString));
} else {
writeString(std::basic_string<_CharT>(value));
}
@@ -293,10 +293,10 @@ class APACHE_GEODE_EXPORT DataOutput {
// without scanning string, making worst case choices.
// TODO constexp for each string type to jmutf8 length conversion
if (value.length() * 3 <= std::numeric_limits<uint16_t>::max()) {
- write(static_cast<uint8_t>(GeodeTypeIds::CacheableString));
+ write(static_cast<uint8_t>(DSCode::CacheableString));
writeJavaModifiedUtf8(value);
} else {
- write(static_cast<uint8_t>(GeodeTypeIds::CacheableStringHuge));
+ write(static_cast<uint8_t>(DSCode::CacheableStringHuge));
writeUtf16Huge(value);
}
}
diff --git a/cppcache/include/geode/GeodeTypeIds.hpp b/cppcache/include/geode/GeodeTypeIds.hpp
deleted file mode 100644
index 97dcb1a..0000000
--- a/cppcache/include/geode/GeodeTypeIds.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GEODETYPEIDS_H_
-#define GEODE_GEODETYPEIDS_H_
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-namespace apache {
-namespace geode {
-namespace client {
-
-class GeodeTypeIds {
- public:
- // User visible IDs here
- // Internal IDs are in GeodeTypeIds.hpp
-
- enum IdValues {
- // Do not use IDs 7 and 8 which are used by .NET
- // ManagedObject and ManagedObjectXml. If those are
- // required then change those in GeodeTypeIdsM.hpp
- CacheableManagedObject = 7,
- CacheableManagedObjectXml = 8,
-
- // keep the following in alphabetical order please.
- EnumInfo = 9,
- CacheableLinkedList = 10,
- Properties = 11,
- PdxType = 17, // internal hack to read pdxtype in c# layer, look usuage in
- // TcrMessage and C# DistributedM.cpp
- BooleanArray = 26,
- CharArray = 27,
- RegionAttributes = 30, // because there's no equivalence in java
- CacheableUndefined = 31,
- Struct = 32,
- NullObj = 41,
- CacheableString = 42,
- CacheableBytes = 46,
- CacheableInt16Array = 47,
- CacheableInt32Array = 48,
- CacheableInt64Array = 49,
- CacheableFloatArray = 50,
- CacheableDoubleArray = 51,
- CacheableObjectArray = 52,
- CacheableBoolean = 53,
- CacheableCharacter = 54,
- CacheableByte = 55,
- CacheableInt16 = 56,
- CacheableInt32 = 57,
- CacheableInt64 = 58,
- CacheableFloat = 59,
- CacheableDouble = 60,
- CacheableDate = 61,
- CacheableFileName = 63,
- CacheableStringArray = 64,
- CacheableArrayList = 65,
- CacheableHashSet = 66,
- CacheableHashMap = 67,
- CacheableTimeUnit = 68,
- CacheableNullString = 69,
- CacheableHashTable = 70,
- CacheableVector = 71,
- CacheableIdentityHashMap = 72,
- CacheableLinkedHashSet = 73,
- CacheableStack = 74,
- CacheableASCIIString = 87,
- CacheableASCIIStringHuge = 88,
- CacheableStringHuge = 89,
- CacheableEnum = 94
- };
-};
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-#endif // GEODE_GEODETYPEIDS_H_
diff --git a/cppcache/include/geode/Properties.hpp b/cppcache/include/geode/Properties.hpp
index 5beca7c..b7eb295 100644
--- a/cppcache/include/geode/Properties.hpp
+++ b/cppcache/include/geode/Properties.hpp
@@ -144,7 +144,7 @@ class APACHE_GEODE_EXPORT Properties
void fromData(DataInput& input) override;
- int8_t getDsCode() const override;
+ DSCode getDsCode() const override;
~Properties() override = default;
Properties(const Properties&) = delete;
diff --git a/cppcache/include/geode/Serializer.hpp b/cppcache/include/geode/Serializer.hpp
index 5c3e9cd..9f4ec45 100644
--- a/cppcache/include/geode/Serializer.hpp
+++ b/cppcache/include/geode/Serializer.hpp
@@ -29,7 +29,6 @@
#include "internal/geode_globals.hpp"
#include "DataOutput.hpp"
#include "DataInput.hpp"
-#include "GeodeTypeIds.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/include/geode/Struct.hpp b/cppcache/include/geode/Struct.hpp
index 7b69280..2afe06d 100644
--- a/cppcache/include/geode/Struct.hpp
+++ b/cppcache/include/geode/Struct.hpp
@@ -47,7 +47,7 @@ class StructSet;
* is obtained from a Cache.
*/
class APACHE_GEODE_EXPORT Struct
- : public internal::DataSerializableFixedId_t<GeodeTypeIds::Struct> {
+ : public internal::DataSerializableFixedId_t<DSFid::Struct> {
public:
typedef std::vector<std::shared_ptr<Serializable>>::iterator iterator;
diff --git a/cppcache/include/geode/internal/DSCode.hpp b/cppcache/include/geode/internal/DSCode.hpp
new file mode 100644
index 0000000..aa9ef9a
--- /dev/null
+++ b/cppcache/include/geode/internal/DSCode.hpp
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef NATIVECLIENT_DSCODE_H
+#define NATIVECLIENT_DSCODE_H
+
+namespace apache {
+namespace geode {
+namespace client {
+namespace internal {
+
+enum class DSCode : int32_t {
+ FixedIDDefault = 0,
+ FixedIDByte = 1,
+ FixedIDInt = 3,
+ FixedIDNone = 4,
+ FixedIDShort = 2,
+ CacheableLinkedList = 10,
+ Properties = 11,
+ CacheableToken = 14, // because there's no equivalence in java
+ PdxType = 17, // internal hack to read pdxtype in c# layer, look usuage in
+ // TcrMessage and C# DistributedM.cpp
+ BooleanArray = 26,
+ CharArray = 27,
+ RegionAttributes = 30, // because there's no equivalence in java
+ NullObj = 41,
+ CacheableString = 42,
+ Class = 43,
+ JavaSerializable = 44,
+ DataSerializable = 45,
+ CacheableBytes = 46,
+ CacheableInt16Array = 47,
+ CacheableInt32Array = 48,
+ CacheableInt64Array = 49,
+ CacheableFloatArray = 50,
+ CacheableDoubleArray = 51,
+ CacheableObjectArray = 52,
+ CacheableBoolean = 53,
+ CacheableCharacter = 54,
+ CacheableByte = 55,
+ CacheableInt16 = 56,
+ CacheableInt32 = 57,
+ CacheableInt64 = 58,
+ CacheableFloat = 59,
+ CacheableDouble = 60,
+ CacheableDate = 61,
+ CacheableFileName = 63,
+ CacheableStringArray = 64,
+ CacheableArrayList = 65,
+ CacheableHashSet = 66,
+ CacheableHashMap = 67,
+ CacheableTimeUnit = 68,
+ CacheableNullString = 69,
+ CacheableHashTable = 70,
+ CacheableVector = 71,
+ CacheableIdentityHashMap = 72,
+ CacheableLinkedHashSet = 73,
+ CacheableStack = 74,
+ CacheableASCIIString = 87,
+ CacheableASCIIStringHuge = 88,
+ CacheableStringHuge = 89,
+ InternalDistributedMember = 92,
+ CacheableEnum = 94,
+ ClientProxyMembershipId = 38,
+ CacheableUserData = 39,
+ CacheableUserData2 = 38,
+ CacheableUserData4 = 37,
+ PDX = 93,
+ PDX_ENUM = 94,
+ InterestResultPolicy = 37,
+};
+
+} // namespace internal
+} // namespace client
+} // namespace geode
+} // namespace apache
+
+#endif //NATIVECLIENT_DSCODE_H
diff --git a/cppcache/include/geode/internal/DataSerializablePrimitive.hpp b/cppcache/include/geode/internal/DSFixedId.hpp
similarity index 57%
copy from cppcache/include/geode/internal/DataSerializablePrimitive.hpp
copy to cppcache/include/geode/internal/DSFixedId.hpp
index 940b1ca..0e5575c 100644
--- a/cppcache/include/geode/internal/DataSerializablePrimitive.hpp
+++ b/cppcache/include/geode/internal/DSFixedId.hpp
@@ -15,29 +15,37 @@
* limitations under the License.
*/
-#pragma once
-
-#ifndef GEODE_DATASERIALIZABLEPRIMITIVE_H_
-#define GEODE_DATASERIALIZABLEPRIMITIVE_H_
-
-#include "../Serializable.hpp"
+#ifndef NATIVECLIENT_DSFIXEDID_HPP
+#define NATIVECLIENT_DSFIXEDID_HPP
namespace apache {
namespace geode {
namespace client {
-
-class DataOutput;
-class DataInput;
-
namespace internal {
-class APACHE_GEODE_EXPORT DataSerializablePrimitive
- : public virtual Serializable {
- public:
- ~DataSerializablePrimitive() override = default;
- virtual void toData(DataOutput& dataOutput) const = 0;
- virtual void fromData(DataInput& dataInput) = 0;
- virtual int8_t getDsCode() const = 0;
+enum class DSFid : int32_t {
+ ClientHealthStats = -126,
+ VersionTag = -120,
+ CollectionTypeImpl = -59,
+ LocatorListRequest = -54,
+ ClientConnectionRequest = -53,
+ QueueConnectionRequest = -52,
+ LocatorListResponse = -51,
+ ClientConnectionResponse = -50,
+ QueueConnectionResponse = -49,
+ ClientReplacementRequest = -48,
+ GetAllServersRequest = -43,
+ GetAllServersResponse = -42,
+ VersionedObjectPartList = 7,
+ EnumInfo = 9,
+ CacheableObjectPartList = 25,
+ CacheableUndefined = 31,
+ Struct = 32,
+ EventId = 36,
+ InternalDistributedMember = 92,
+ TXCommitMessage = 110,
+ DiskVersionTag = 2131,
+ DiskStoreId = 2133
};
} // namespace internal
@@ -45,4 +53,4 @@ class APACHE_GEODE_EXPORT DataSerializablePrimitive
} // namespace geode
} // namespace apache
-#endif // GEODE_DATASERIALIZABLEPRIMITIVE_H_
+#endif //NATIVECLIENT_DSFIXEDID_HPP
diff --git a/cppcache/include/geode/internal/DataSerializableFixedId.hpp b/cppcache/include/geode/internal/DataSerializableFixedId.hpp
index bd28ece..97c6d29 100644
--- a/cppcache/include/geode/internal/DataSerializableFixedId.hpp
+++ b/cppcache/include/geode/internal/DataSerializableFixedId.hpp
@@ -21,6 +21,7 @@
#define GEODE_DATASERIALIZABLEFIXEDID_H_
#include "../Serializable.hpp"
+#include "DSFixedId.hpp"
namespace apache {
namespace geode {
@@ -40,16 +41,16 @@ class APACHE_GEODE_EXPORT DataSerializableFixedId
virtual void fromData(DataInput& dataInput) = 0;
- virtual int32_t getDSFID() const = 0;
+ virtual DSFid getDSFID() const = 0;
};
-template <int32_t _DSFID>
+template <DSFid _DSFID>
class APACHE_GEODE_EXPORT DataSerializableFixedId_t
: public DataSerializableFixedId {
public:
~DataSerializableFixedId_t() override = default;
- int32_t getDSFID() const final { return _DSFID; }
+ DSFid getDSFID() const final { return _DSFID; }
};
} // namespace internal
diff --git a/cppcache/include/geode/internal/DataSerializablePrimitive.hpp b/cppcache/include/geode/internal/DataSerializablePrimitive.hpp
index 940b1ca..0d1a0b7 100644
--- a/cppcache/include/geode/internal/DataSerializablePrimitive.hpp
+++ b/cppcache/include/geode/internal/DataSerializablePrimitive.hpp
@@ -21,6 +21,7 @@
#define GEODE_DATASERIALIZABLEPRIMITIVE_H_
#include "../Serializable.hpp"
+#include "DSCode.hpp"
namespace apache {
namespace geode {
@@ -37,7 +38,7 @@ class APACHE_GEODE_EXPORT DataSerializablePrimitive
~DataSerializablePrimitive() override = default;
virtual void toData(DataOutput& dataOutput) const = 0;
virtual void fromData(DataInput& dataInput) = 0;
- virtual int8_t getDsCode() const = 0;
+ virtual DSCode getDsCode() const = 0;
};
} // namespace internal
diff --git a/cppcache/src/Serializable.cpp b/cppcache/include/geode/internal/InternalId.hpp
similarity index 69%
copy from cppcache/src/Serializable.cpp
copy to cppcache/include/geode/internal/InternalId.hpp
index f24b9e5..111cd43 100644
--- a/cppcache/src/Serializable.cpp
+++ b/cppcache/include/geode/internal/InternalId.hpp
@@ -15,25 +15,26 @@
* limitations under the License.
*/
-#include <geode/internal/geode_globals.hpp>
-#include <geode/Serializable.hpp>
-#include <geode/CacheableString.hpp>
-
-#include "GeodeTypeIdsImpl.hpp"
-#include "SerializationRegistry.hpp"
-#include "Utils.hpp"
-#include "CacheImpl.hpp"
+#ifndef NATIVECLIENT_INTERNALID_HPP
+#define NATIVECLIENT_INTERNALID_HPP
namespace apache {
namespace geode {
namespace client {
+namespace internal {
-size_t Serializable::objectSize() const { return 0; }
+enum class InternalId : int8_t {
+ // Do not use IDs 7 and 8 which are used by .NET
+ // ManagedObject and ManagedObjectXml. If those are
+ // required then change those in GeodeTypeIdsM.hpp
+ CacheableManagedObject = 7,
+ CacheableManagedObjectXml = 8,
-std::string Serializable::toString() const {
- return Utils::demangleTypeName(typeid(*this).name());
-}
+};
+} // namespace internal
} // namespace client
} // namespace geode
} // namespace apache
+
+#endif //NATIVECLIENT_INTERNALID_HPP
diff --git a/cppcache/integration-test/BuiltinCacheableWrappers.hpp b/cppcache/integration-test/BuiltinCacheableWrappers.hpp
index 69573ec..e8f8b76 100644
--- a/cppcache/integration-test/BuiltinCacheableWrappers.hpp
+++ b/cppcache/integration-test/BuiltinCacheableWrappers.hpp
@@ -175,17 +175,17 @@ inline uint32_t crc32Array(const std::vector<TPRIM> arr) {
return crc32(output.getBuffer(), output.getBufferLength());
}
-inline bool isContainerTypeId(int8_t typeId) {
- 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);
+inline bool isContainerTypeId(DSCode typeId) {
+ return (typeId == DSCode::CacheableObjectArray) ||
+ (typeId == DSCode::CacheableVector) ||
+ (typeId == DSCode::CacheableHashMap) ||
+ (typeId == DSCode::CacheableHashSet) ||
+ (typeId == DSCode::CacheableStack) ||
+ (typeId == DSCode::CacheableArrayList) ||
+ (typeId == DSCode::CacheableHashTable) ||
+ (typeId == DSCode::CacheableIdentityHashMap) ||
+ (typeId == DSCode::CacheableLinkedHashSet) ||
+ (typeId == DSCode::CacheableLinkedList);
}
} // namespace CacheableHelper
@@ -701,27 +701,28 @@ class CacheableHashMapTypeWrapper : public CacheableWrapper {
auto keyTypeIds = CacheableWrapperFactory::getRegisteredKeyTypes();
auto valTypeIds = CacheableWrapperFactory::getRegisteredValueTypes();
- for (std::vector<int8_t>::iterator keyIter = keyTypeIds.begin();
+ for (std::vector<DSCode>::iterator keyIter = keyTypeIds.begin();
keyIter != keyTypeIds.end(); keyIter++) {
int item = 0;
- for (std::vector<int8_t>::iterator valIter = valTypeIds.begin();
+ for (std::vector<DSCode>::iterator valIter = valTypeIds.begin();
valIter != valTypeIds.end(); valIter++) {
- if (CacheableHelper::isContainerTypeId(*valIter)) {
+
+ if (CacheableHelper::isContainerTypeId(static_cast<DSCode>(*valIter))) {
continue;
}
- if ((*valIter == GeodeTypeIds::CacheableASCIIStringHuge ||
- *valIter == GeodeTypeIds::CacheableStringHuge) &&
- !(*keyIter == GeodeTypeIds::CacheableBoolean)) {
+ if ((*valIter == DSCode::CacheableASCIIStringHuge ||
+ *valIter == DSCode::CacheableStringHuge) &&
+ !(*keyIter == DSCode::CacheableBoolean)) {
continue;
}
- if ((*keyIter == GeodeTypeIds::CacheableASCIIStringHuge ||
- *keyIter == GeodeTypeIds::CacheableStringHuge) &&
- !(*valIter == GeodeTypeIds::CacheableBoolean)) {
+ if ((*keyIter == DSCode::CacheableASCIIStringHuge ||
+ *keyIter == DSCode::CacheableStringHuge) &&
+ !(*valIter == DSCode::CacheableBoolean)) {
continue;
}
// null object does not work on server side during deserialization
- if (*valIter == GeodeTypeIds::CacheableNullString) {
+ if (*valIter == DSCode::CacheableNullString) {
continue;
}
@@ -735,7 +736,7 @@ class CacheableHashMapTypeWrapper : public CacheableWrapper {
CacheableWrapperFactory::createInstance(*valIter));
ASSERT(valWrapper != nullptr,
"initRandomValue: valWrapper null object.");
- keyWrapper->initKey(((*keyIter) << 8) + item, maxSize);
+ keyWrapper->initKey(((static_cast<int8_t>(*keyIter)) << 8) + item, maxSize);
valWrapper->initRandomValue(maxSize);
chmp->emplace(
std::dynamic_pointer_cast<CacheableKey>(keyWrapper->getCacheable()),
@@ -801,7 +802,7 @@ class CacheableHashSetTypeWrapper : public CacheableWrapper {
size_t sizeOfTheVector = keyTypeIds.size();
maxSize = maxSize / static_cast<int32_t>(sizeOfTheVector) + 1;
for (size_t i = 0; i < sizeOfTheVector; i++) {
- int8_t keyTypeId = keyTypeIds[i];
+ DSCode keyTypeId = keyTypeIds[i];
auto wrapper = CacheableWrapperFactory::createInstance(keyTypeId);
wrapper->initRandomValue(maxSize);
auto cptr = wrapper->getCacheable();
@@ -1096,8 +1097,8 @@ class CacheableVectorTypeWrapper : public CacheableWrapper {
size_t sizeOfTheVector = valueTypeIds.size();
maxSize = maxSize / static_cast<int32_t>(sizeOfTheVector) + 1;
for (size_t i = 0; i < sizeOfTheVector; i++) {
- int8_t valueTypeId = valueTypeIds[i];
- if (!CacheableHelper::isContainerTypeId(valueTypeId)) {
+ DSCode valueTypeId = valueTypeIds[i];
+ if (!CacheableHelper::isContainerTypeId(static_cast<DSCode>(valueTypeId))) {
auto wrapper = CacheableWrapperFactory::createInstance(valueTypeId);
wrapper->initRandomValue(maxSize);
vec->push_back(wrapper->getCacheable());
@@ -1153,8 +1154,8 @@ class CacheableObjectArrayWrapper : public CacheableWrapper {
size_t sizeOfTheVector = valueTypeIds.size();
maxSize = maxSize / static_cast<int32_t>(sizeOfTheVector) + 1;
for (size_t i = 0; i < sizeOfTheVector; i++) {
- int8_t valueTypeId = valueTypeIds[i];
- if (!CacheableHelper::isContainerTypeId(valueTypeId)) {
+ DSCode valueTypeId = valueTypeIds[i];
+ if (!CacheableHelper::isContainerTypeId(static_cast<DSCode>(valueTypeId))) {
auto wrapper = CacheableWrapperFactory::createInstance(valueTypeId);
wrapper->initRandomValue(maxSize);
arr->push_back(wrapper->getCacheable());
@@ -1188,110 +1189,107 @@ void registerBuiltins(bool isRegisterFileName = false) {
srand(getpid() + static_cast<int>(time(0)));
// Register the builtin cacheable keys
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableBoolean,
+ CacheableWrapperFactory::registerType(DSCode::CacheableBoolean,
"CacheableBoolean",
CacheableBooleanWrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableByte,
+ CacheableWrapperFactory::registerType(DSCode::CacheableByte,
"CacheableByte",
CacheableByteWrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableDouble,
+ CacheableWrapperFactory::registerType(DSCode::CacheableDouble,
"CacheableDouble",
CacheableDoubleWrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableDate,
+ CacheableWrapperFactory::registerType(DSCode::CacheableDate,
"CacheableDate",
CacheableDateWrapper::create, true);
if (isRegisterFileName) {
#ifdef _WIN32
// TODO: windows requires some serious tweaking to get this to work
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableFileName, "CacheableFileName",
+ DSCode::CacheableFileName, "CacheableFileName",
CacheableFileNameWrapper::create, true);
#endif
}
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableFloat,
+ CacheableWrapperFactory::registerType(DSCode::CacheableFloat,
"CacheableFloat",
CacheableFloatWrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableInt16,
+ CacheableWrapperFactory::registerType(DSCode::CacheableInt16,
"CacheableInt16",
CacheableInt16Wrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableInt32,
+ CacheableWrapperFactory::registerType(DSCode::CacheableInt32,
"CacheableInt32",
CacheableInt32Wrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableInt64,
+ CacheableWrapperFactory::registerType(DSCode::CacheableInt64,
"CacheableInt64",
CacheableInt64Wrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableASCIIString,
+ CacheableWrapperFactory::registerType(DSCode::CacheableASCIIString,
"CacheableString",
CacheableStringWrapper::create, true);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableString, "CacheableUnicodeString",
+ DSCode::CacheableString, "CacheableUnicodeString",
CacheableUnicodeStringWrapper::create, true);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableASCIIStringHuge, "CacheableHugeString",
+ DSCode::CacheableASCIIStringHuge, "CacheableHugeString",
CacheableHugeStringWrapper::create, true);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableStringHuge, "CacheableHugeUnicodeString",
+ DSCode::CacheableStringHuge, "CacheableHugeUnicodeString",
CacheableHugeUnicodeStringWrapper::create, true);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableCharacter,
+ CacheableWrapperFactory::registerType(DSCode::CacheableCharacter,
"CacheableCharacter",
CacheableWideCharWrapper::create, true);
// Register other builtin cacheables
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableHashMap,
+ CacheableWrapperFactory::registerType(DSCode::CacheableHashMap,
"CacheableHashMap",
CacheableHashMapWrapper::create, false);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableHashSet,
+ CacheableWrapperFactory::registerType(DSCode::CacheableHashSet,
"CacheableHashSet",
CacheableHashSetWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableHashTable, "CacheableHashTable",
+ DSCode::CacheableHashTable, "CacheableHashTable",
CacheableHashTableWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableIdentityHashMap, "CacheableIdentityHashMap",
+ DSCode::CacheableIdentityHashMap, "CacheableIdentityHashMap",
CacheableIdentityHashMapWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableLinkedHashSet, "CacheableLinkedHashSet",
+ DSCode::CacheableLinkedHashSet, "CacheableLinkedHashSet",
CacheableLinkedHashSetWrapper::create, false);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableBytes,
+ CacheableWrapperFactory::registerType(DSCode::CacheableBytes,
"CacheableBytes",
CacheableBytesWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableDoubleArray, "CacheableDoubleArray",
+ DSCode::CacheableDoubleArray, "CacheableDoubleArray",
CacheableDoubleArrayWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableFloatArray, "CacheableFloatArray",
+ DSCode::CacheableFloatArray, "CacheableFloatArray",
CacheableFloatArrayWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableInt16Array, "CacheableInt16Array",
+ DSCode::CacheableInt16Array, "CacheableInt16Array",
CacheableInt16ArrayWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableInt32Array, "CacheableInt32Array",
+ DSCode::CacheableInt32Array, "CacheableInt32Array",
CacheableInt32ArrayWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableInt64Array, "CacheableInt64Array",
+ DSCode::CacheableInt64Array, "CacheableInt64Array",
CacheableInt64ArrayWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableNullString, "CacheableNullString",
+ DSCode::CacheableNullString, "CacheableNullString",
CacheableNullStringWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableObjectArray, "CacheableObjectArray",
+ DSCode::CacheableObjectArray, "CacheableObjectArray",
CacheableObjectArrayWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableStringArray, "CacheableStringArray",
+ DSCode::CacheableStringArray, "CacheableStringArray",
CacheableStringArrayWrapper::create, false);
- CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableUndefined, "CacheableUndefined",
- CacheableUndefinedWrapper::create, false);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableVector,
+ CacheableWrapperFactory::registerType(DSCode::CacheableVector,
"CacheableVector",
CacheableVectorWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableArrayList, "CacheableArrayList",
+ DSCode::CacheableArrayList, "CacheableArrayList",
CacheableArrayListWrapper::create, false);
CacheableWrapperFactory::registerType(
- GeodeTypeIds::CacheableLinkedList, "CacheableLinkedList",
+ DSCode::CacheableLinkedList, "CacheableLinkedList",
CacheableLinkedListWrapper::create, false);
- CacheableWrapperFactory::registerType(GeodeTypeIds::CacheableStack,
+ CacheableWrapperFactory::registerType(DSCode::CacheableStack,
"CacheableStack",
CacheableStackWrapper::create, false);
}
diff --git a/cppcache/integration-test/CacheableWrapper.cpp b/cppcache/integration-test/CacheableWrapper.cpp
index 48aa138..80867a4 100644
--- a/cppcache/integration-test/CacheableWrapper.cpp
+++ b/cppcache/integration-test/CacheableWrapper.cpp
@@ -21,13 +21,13 @@ void CacheableWrapper::initKey(int32_t, int32_t) {
throw IllegalArgumentException("Cannot call initKey.");
}
-std::map<int8_t, CacheableWrapperFunc>
+std::map<DSCode, CacheableWrapperFunc>
CacheableWrapperFactory::m_registeredKeyMap;
-std::map<int8_t, CacheableWrapperFunc>
+std::map<DSCode, CacheableWrapperFunc>
CacheableWrapperFactory::m_registeredValueMap;
-std::map<int8_t, std::string> CacheableWrapperFactory::m_typeIdNameMap;
+std::map<DSCode, std::string> CacheableWrapperFactory::m_typeIdNameMap;
-CacheableWrapper* CacheableWrapperFactory::createInstance(int8_t typeId) {
+CacheableWrapper* CacheableWrapperFactory::createInstance(DSCode typeId) {
if (m_registeredValueMap.find(typeId) != m_registeredValueMap.end()) {
CacheableWrapperFunc wrapperFunc = m_registeredValueMap[typeId];
return wrapperFunc();
@@ -36,7 +36,7 @@ CacheableWrapper* CacheableWrapperFactory::createInstance(int8_t typeId) {
}
void CacheableWrapperFactory::registerType(
- int8_t typeId, const std::string wrapperType,
+ DSCode typeId, const std::string wrapperType,
const CacheableWrapperFunc factoryFunc, const bool isKey) {
if (isKey) {
m_registeredKeyMap[typeId] = factoryFunc;
@@ -45,9 +45,9 @@ void CacheableWrapperFactory::registerType(
m_typeIdNameMap[typeId] = wrapperType;
}
-std::vector<int8_t> CacheableWrapperFactory::getRegisteredKeyTypes() {
- std::vector<int8_t> keyVector;
- std::map<int8_t, CacheableWrapperFunc>::iterator keyMapIterator;
+std::vector<DSCode> CacheableWrapperFactory::getRegisteredKeyTypes() {
+ std::vector<DSCode> keyVector;
+ std::map<DSCode, CacheableWrapperFunc>::iterator keyMapIterator;
for (keyMapIterator = m_registeredKeyMap.begin();
keyMapIterator != m_registeredKeyMap.end(); ++keyMapIterator) {
@@ -56,9 +56,9 @@ std::vector<int8_t> CacheableWrapperFactory::getRegisteredKeyTypes() {
return keyVector;
}
-std::vector<int8_t> CacheableWrapperFactory::getRegisteredValueTypes() {
- std::vector<int8_t> valueVector;
- std::map<int8_t, CacheableWrapperFunc>::iterator valueMapIterator;
+std::vector<DSCode> CacheableWrapperFactory::getRegisteredValueTypes() {
+ std::vector<DSCode> valueVector;
+ std::map<DSCode, CacheableWrapperFunc>::iterator valueMapIterator;
for (valueMapIterator = m_registeredValueMap.begin();
valueMapIterator != m_registeredValueMap.end(); ++valueMapIterator) {
@@ -67,8 +67,8 @@ std::vector<int8_t> CacheableWrapperFactory::getRegisteredValueTypes() {
return valueVector;
}
-std::string CacheableWrapperFactory::getTypeForId(int8_t typeId) {
- std::map<int8_t, std::string>::iterator findType =
+std::string CacheableWrapperFactory::getTypeForId(DSCode typeId) {
+ std::map<DSCode, std::string>::iterator findType =
m_typeIdNameMap.find(typeId);
if (findType != m_typeIdNameMap.end()) {
return findType->second;
diff --git a/cppcache/integration-test/CacheableWrapper.hpp b/cppcache/integration-test/CacheableWrapper.hpp
index c4630fc..eb51961 100644
--- a/cppcache/integration-test/CacheableWrapper.hpp
+++ b/cppcache/integration-test/CacheableWrapper.hpp
@@ -60,22 +60,22 @@ typedef CacheableWrapper* (*CacheableWrapperFunc)(void);
class CacheableWrapperFactory {
public:
- static CacheableWrapper* createInstance(int8_t typeId);
+ static CacheableWrapper* createInstance(DSCode typeId);
- static void registerType(int8_t typeId, const std::string wrapperType,
+ static void registerType(DSCode typeId, const std::string wrapperType,
const CacheableWrapperFunc wrapperFunc,
const bool isKey);
- static std::vector<int8_t> getRegisteredKeyTypes();
+ static std::vector<DSCode> getRegisteredKeyTypes();
- static std::vector<int8_t> getRegisteredValueTypes();
+ static std::vector<DSCode> getRegisteredValueTypes();
- static std::string getTypeForId(int8_t typeId);
+ static std::string getTypeForId(DSCode typeId);
private:
- static std::map<int8_t, CacheableWrapperFunc> m_registeredKeyMap;
- static std::map<int8_t, CacheableWrapperFunc> m_registeredValueMap;
- static std::map<int8_t, std::string> m_typeIdNameMap;
+ static std::map<DSCode, CacheableWrapperFunc> m_registeredKeyMap;
+ static std::map<DSCode, CacheableWrapperFunc> m_registeredValueMap;
+ static std::map<DSCode, std::string> m_typeIdNameMap;
};
diff --git a/cppcache/integration-test/testSerialization.cpp b/cppcache/integration-test/testSerialization.cpp
index c078d9e..9aa6a40 100644
--- a/cppcache/integration-test/testSerialization.cpp
+++ b/cppcache/integration-test/testSerialization.cpp
@@ -27,8 +27,6 @@
#include "SerializationRegistry.hpp"
#include <geode/CacheableString.hpp>
-#include <geode/GeodeTypeIds.hpp>
-#include "GeodeTypeIdsImpl.hpp"
// Use to init lib when testing components.
#include <CppCacheLibrary.hpp>
diff --git a/cppcache/integration-test/testThinClientCacheables.cpp b/cppcache/integration-test/testThinClientCacheables.cpp
index 9303d7a..4f23188 100644
--- a/cppcache/integration-test/testThinClientCacheables.cpp
+++ b/cppcache/integration-test/testThinClientCacheables.cpp
@@ -77,7 +77,7 @@ void createRegion(const char* name, bool ackMode,
LOG("Region created.");
}
-void checkGets(int maxKeys, int8_t keyTypeId, int8_t valTypeId,
+void checkGets(int maxKeys, DSCode keyTypeId, DSCode valTypeId,
const std::shared_ptr<Region>& dataReg,
const std::shared_ptr<Region>& verifyReg) {
for (int i = 0; i < maxKeys; i++) {
@@ -156,8 +156,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, PutsTask)
size_t keyTypeIndex = taskIndexPut / valueTypes.size();
size_t valueTypeIndex = taskIndexPut % valueTypes.size();
- int8_t keyTypeId = keyTypes[keyTypeIndex];
- int8_t valTypeId = valueTypes[valueTypeIndex];
+ DSCode keyTypeId = keyTypes[keyTypeIndex];
+ DSCode valTypeId = valueTypes[valueTypeIndex];
printf("PutsTask::keyType = %s and valType = %s and taskIndexPut = %d\n",
CacheableWrapperFactory::getTypeForId(keyTypeId).c_str(),
@@ -229,8 +229,8 @@ DUNIT_TASK_DEFINITION(CLIENT2, GetsTask)
size_t keyTypeIndex = taskIndexGet / valueTypes.size();
size_t valueTypeIndex = taskIndexGet % valueTypes.size();
- int8_t keyTypeId = keyTypes[keyTypeIndex];
- int8_t valTypeId = valueTypes[valueTypeIndex];
+ DSCode keyTypeId = keyTypes[keyTypeIndex];
+ DSCode valTypeId = valueTypes[valueTypeIndex];
printf("GetsTask::keyType = %s and valType = %s and taskIndexGet = %d\n",
CacheableWrapperFactory::getTypeForId(keyTypeId).c_str(),
diff --git a/cppcache/integration-test/testThinClientHeapLRU.cpp b/cppcache/integration-test/testThinClientHeapLRU.cpp
index 6b7c907..1e56a90 100644
--- a/cppcache/integration-test/testThinClientHeapLRU.cpp
+++ b/cppcache/integration-test/testThinClientHeapLRU.cpp
@@ -43,9 +43,9 @@ void createOnekEntries() {
auto dataReg = getHelper()->getRegion(_regionNames[0]);
for (int i = 0; i < 2048; i++) {
CacheableWrapper* tmpkey =
- CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableInt32);
+ CacheableWrapperFactory::createInstance(DSCode::CacheableInt32);
CacheableWrapper* tmpval =
- CacheableWrapperFactory::createInstance(GeodeTypeIds::CacheableBytes);
+ CacheableWrapperFactory::createInstance(DSCode::CacheableBytes);
tmpkey->initKey(i, 32);
tmpval->initRandomValue(1024);
ASSERT(tmpkey->getCacheable() != nullptr,
diff --git a/cppcache/integration-test/testThinClientPRSingleHop.cpp b/cppcache/integration-test/testThinClientPRSingleHop.cpp
index 6f18856..2ff2a44 100644
--- a/cppcache/integration-test/testThinClientPRSingleHop.cpp
+++ b/cppcache/integration-test/testThinClientPRSingleHop.cpp
@@ -444,8 +444,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, CheckPrSingleHopForAllKeysTask)
size_t keyTypeIndex = taskIndexPut / valueTypes.size();
size_t valueTypeIndex = taskIndexPut % valueTypes.size();
- int8_t keyTypeId = keyTypes[keyTypeIndex];
- int8_t valTypeId = valueTypes[valueTypeIndex];
+ DSCode keyTypeId = keyTypes[keyTypeIndex];
+ DSCode valTypeId = valueTypes[valueTypeIndex];
LOGDEBUG(
"CheckPrSingleHopForAllKeysTask::keyType = %s and valType = %s and "
diff --git a/cppcache/src/CacheAttributes.cpp b/cppcache/src/CacheAttributes.cpp
index e4dd7eb..14735d5 100644
--- a/cppcache/src/CacheAttributes.cpp
+++ b/cppcache/src/CacheAttributes.cpp
@@ -18,7 +18,6 @@
#include <string>
#include <cstdlib>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/CacheAttributes.hpp>
#include "Utils.hpp"
diff --git a/cppcache/src/CacheFactory.cpp b/cppcache/src/CacheFactory.cpp
index add1bef..f84131a 100644
--- a/cppcache/src/CacheFactory.cpp
+++ b/cppcache/src/CacheFactory.cpp
@@ -105,14 +105,15 @@ Cache CacheFactory::create() const {
std::bind(TXCommitMessage::create, memberListForVersionStamp));
serializationRegistry->addType(
- GeodeTypeIds::PdxType,
+ //TODO: This looks like the only thing to do here, but I'm not sure
+ static_cast<int64_t>(DSCode::PdxType),
std::bind(PdxType::CreateDeserializable, std::ref(*pdxTypeRegistry)));
serializationRegistry->addType2(
std::bind(VersionTag::createDeserializable, memberListForVersionStamp));
serializationRegistry->addType2(
- GeodeTypeIdsImpl::DiskVersionTag,
+ static_cast<int64_t>(DSFid::DiskVersionTag),
std::bind(DiskVersionTag::createDeserializable,
memberListForVersionStamp));
diff --git a/cppcache/src/CacheableDate.cpp b/cppcache/src/CacheableDate.cpp
index 60f0414..4e261af 100644
--- a/cppcache/src/CacheableDate.cpp
+++ b/cppcache/src/CacheableDate.cpp
@@ -21,7 +21,6 @@
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
#include <geode/ExceptionTypes.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <cwchar>
#include <ace/OS.h>
@@ -48,7 +47,7 @@ std::shared_ptr<Serializable> CacheableDate::createDeserializable() {
return std::make_shared<CacheableDate>();
}
-int8_t CacheableDate::getDsCode() const { return GeodeTypeIds::CacheableDate; }
+DSCode CacheableDate::getDsCode() const { return DSCode::CacheableDate; }
bool CacheableDate::operator==(const CacheableKey& other) const {
if (auto otherDate = dynamic_cast<const CacheableDate*>(&other)) {
diff --git a/cppcache/src/CacheableEnum.cpp b/cppcache/src/CacheableEnum.cpp
index e41d9d4..317d519 100644
--- a/cppcache/src/CacheableEnum.cpp
+++ b/cppcache/src/CacheableEnum.cpp
@@ -20,7 +20,6 @@
#include "Utils.hpp"
#include "PdxHelper.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "EnumInfo.hpp"
#include "CacheRegionHelper.hpp"
@@ -45,7 +44,7 @@ void CacheableEnum::toData(apache::geode::client::DataOutput& output) const {
int enumVal = PdxHelper::getEnumValue(
m_enumClassName.c_str(), m_enumName.c_str(), m_ordinal,
CacheRegionHelper::getCacheImpl(output.getCache())->getPdxTypeRegistry());
- output.write(static_cast<int8_t>(GeodeTypeIds::CacheableEnum));
+ output.write(static_cast<int8_t>(DSCode::CacheableEnum));
output.write(int8_t(enumVal >> 24));
output.writeArrayLen(enumVal & 0xFFFFFF);
}
diff --git a/cppcache/src/CacheableFileName.cpp b/cppcache/src/CacheableFileName.cpp
index 2ce1f22..55db979 100644
--- a/cppcache/src/CacheableFileName.cpp
+++ b/cppcache/src/CacheableFileName.cpp
@@ -15,7 +15,6 @@
* limitations under the License.
*/
#include <geode/CacheableFileName.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
@@ -27,17 +26,17 @@ namespace geode {
namespace client {
void CacheableFileName::toData(DataOutput& output) const {
- output.write(m_type);
+ output.write(static_cast<int8_t >(m_type));
CacheableString::toData(output);
}
void CacheableFileName::fromData(DataInput& input) {
- m_type = input.read();
+ m_type = static_cast<DSCode>(input.read());
CacheableString::fromData(input);
}
-int8_t CacheableFileName::getDsCode() const {
- return GeodeTypeIds::CacheableFileName;
+DSCode CacheableFileName::getDsCode() const {
+ return DSCode::CacheableFileName;
}
int32_t CacheableFileName::hashcode() const {
diff --git a/cppcache/src/CacheableObjectArray.cpp b/cppcache/src/CacheableObjectArray.cpp
index c951ef3..ae87b80 100644
--- a/cppcache/src/CacheableObjectArray.cpp
+++ b/cppcache/src/CacheableObjectArray.cpp
@@ -18,7 +18,6 @@
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
#include <geode/ExceptionTypes.hpp>
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
@@ -27,7 +26,7 @@ namespace client {
void CacheableObjectArray::toData(DataOutput& output) const {
int32_t len = static_cast<int32_t>(size());
output.writeArrayLen(len);
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::Class));
+ output.write(static_cast<int8_t>(DSCode::Class));
output.writeString("java.lang.Object");
for (const auto& iter : *this) {
output.writeObject(iter);
diff --git a/cppcache/src/CacheableObjectPartList.cpp b/cppcache/src/CacheableObjectPartList.cpp
index a60baed..feb8520 100644
--- a/cppcache/src/CacheableObjectPartList.cpp
+++ b/cppcache/src/CacheableObjectPartList.cpp
@@ -16,7 +16,6 @@
*/
#include "CacheableObjectPartList.hpp"
#include <geode/ExceptionTypes.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include <geode/CacheableString.hpp>
#include "ThinClientRegion.hpp"
#include "CacheableToken.hpp"
diff --git a/cppcache/src/CacheableObjectPartList.hpp b/cppcache/src/CacheableObjectPartList.hpp
index 52875e5..5339e1e 100644
--- a/cppcache/src/CacheableObjectPartList.hpp
+++ b/cppcache/src/CacheableObjectPartList.hpp
@@ -30,7 +30,6 @@
#include "geode/internal/DataSerializableFixedId.hpp"
#include "MapWithLock.hpp"
#include "HashMapOfException.hpp"
-#include "GeodeTypeIdsImpl.hpp"
/** @file
*/
@@ -117,8 +116,8 @@ class CacheableObjectPartList : public DataSerializableFixedId {
void fromData(DataInput& input) override;
- int32_t getDSFID() const override {
- return GeodeTypeIdsImpl::CacheableObjectPartList;
+ DSFid getDSFID() const override {
+ return DSFid::CacheableObjectPartList;
}
size_t objectSize() const override;
diff --git a/cppcache/src/CacheableString.cpp b/cppcache/src/CacheableString.cpp
index e054df3..5140a8f 100644
--- a/cppcache/src/CacheableString.cpp
+++ b/cppcache/src/CacheableString.cpp
@@ -27,7 +27,6 @@
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
#include <geode/ExceptionTypes.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include "DataOutputInternal.hpp"
#include "SerializationRegistry.hpp"
@@ -39,44 +38,44 @@ namespace geode {
namespace client {
void CacheableString::toData(DataOutput& output) const {
- if (m_type == GeodeTypeIds::CacheableASCIIString) {
+ if (m_type == DSCode::CacheableASCIIString) {
output.writeAscii(m_str);
- } else if (m_type == GeodeTypeIds::CacheableString) {
+ } else if (m_type == DSCode::CacheableString) {
output.writeJavaModifiedUtf8(m_str);
- } else if (m_type == GeodeTypeIds::CacheableASCIIStringHuge) {
+ } else if (m_type == DSCode::CacheableASCIIStringHuge) {
output.writeAsciiHuge(m_str);
- } else if (m_type == GeodeTypeIds::CacheableStringHuge) {
+ } else if (m_type == DSCode::CacheableStringHuge) {
output.writeUtf16Huge(m_str);
}
}
void CacheableString::fromData(DataInput& input) {
- if (m_type == GeodeTypeIds::CacheableASCIIString) {
+ if (m_type == DSCode::CacheableASCIIString) {
input.readAscii(m_str);
- } else if (m_type == GeodeTypeIds::CacheableString) {
+ } else if (m_type == DSCode::CacheableString) {
input.readJavaModifiedUtf8(m_str);
- } else if (m_type == GeodeTypeIds::CacheableASCIIStringHuge) {
+ } else if (m_type == DSCode::CacheableASCIIStringHuge) {
input.readAsciiHuge(m_str);
- } else if (m_type == GeodeTypeIds::CacheableStringHuge) {
+ } else if (m_type == DSCode::CacheableStringHuge) {
input.readUtf16Huge(m_str);
}
}
std::shared_ptr<Serializable> CacheableString::createDeserializable() {
- return std::make_shared<CacheableString>(GeodeTypeIds::CacheableASCIIString);
+ return std::make_shared<CacheableString>(DSCode::CacheableASCIIString);
}
std::shared_ptr<Serializable> CacheableString::createDeserializableHuge() {
return std::make_shared<CacheableString>(
- GeodeTypeIds::CacheableASCIIStringHuge);
+ DSCode::CacheableASCIIStringHuge);
}
std::shared_ptr<Serializable> CacheableString::createUTFDeserializable() {
- return std::make_shared<CacheableString>(GeodeTypeIds::CacheableString);
+ return std::make_shared<CacheableString>(DSCode::CacheableString);
}
std::shared_ptr<Serializable> CacheableString::createUTFDeserializableHuge() {
- return std::make_shared<CacheableString>(GeodeTypeIds::CacheableStringHuge);
+ return std::make_shared<CacheableString>(DSCode::CacheableStringHuge);
}
std::shared_ptr<CacheableString> CacheableString::create(
diff --git a/cppcache/src/CacheableToken.cpp b/cppcache/src/CacheableToken.cpp
index 73d8d7c..10461bd 100644
--- a/cppcache/src/CacheableToken.cpp
+++ b/cppcache/src/CacheableToken.cpp
@@ -21,7 +21,6 @@
#include <geode/DataInput.hpp>
#include <geode/DataOutput.hpp>
#include <geode/CacheableString.hpp>
-#include "GeodeTypeIdsImpl.hpp"
using namespace apache::geode::client;
@@ -50,7 +49,7 @@ void CacheableToken::fromData(DataInput& input) {
}
int8_t CacheableToken::getInternalId() const {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableToken);
+ return static_cast<int8_t>(DSCode::CacheableToken);
}
//------ ctor
diff --git a/cppcache/src/ClientConnectionRequest.cpp b/cppcache/src/ClientConnectionRequest.cpp
index 4333613..cc61713 100644
--- a/cppcache/src/ClientConnectionRequest.cpp
+++ b/cppcache/src/ClientConnectionRequest.cpp
@@ -18,7 +18,6 @@
#include "ClientConnectionRequest.hpp"
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
-#include "GeodeTypeIdsImpl.hpp"
using namespace apache::geode::client;
@@ -27,8 +26,8 @@ void ClientConnectionRequest::toData(DataOutput& output) const {
writeSetOfServerLocation(output);
}
-int32_t ClientConnectionRequest::getDSFID() const {
- return GeodeTypeIdsImpl::ClientConnectionRequest;
+DSFid ClientConnectionRequest::getDSFID() const {
+ return DSFid::ClientConnectionRequest;
}
void ClientConnectionRequest::writeSetOfServerLocation(
diff --git a/cppcache/src/ClientConnectionRequest.hpp b/cppcache/src/ClientConnectionRequest.hpp
index 98f8f55..91a1ef7 100644
--- a/cppcache/src/ClientConnectionRequest.hpp
+++ b/cppcache/src/ClientConnectionRequest.hpp
@@ -38,7 +38,7 @@ class ClientConnectionRequest : public ServerLocationRequest {
m_servergroup(servergroup),
m_excludeServergroup_serverLocation(excludeServergroup) {}
void toData(DataOutput& output) const override;
- int32_t getDSFID() const override;
+ DSFid getDSFID() const override;
std::string getServerGroup() const { return m_servergroup; }
const std::set<ServerLocation>& getExcludedServerGroup() const {
return m_excludeServergroup_serverLocation;
diff --git a/cppcache/src/ClientConnectionResponse.cpp b/cppcache/src/ClientConnectionResponse.cpp
index 85f3cec..d70f39d 100644
--- a/cppcache/src/ClientConnectionResponse.cpp
+++ b/cppcache/src/ClientConnectionResponse.cpp
@@ -27,8 +27,8 @@ void ClientConnectionResponse::fromData(DataInput& input) {
}
}
-int32_t ClientConnectionResponse::getDSFID() const {
- return GeodeTypeIdsImpl::ClientConnectionResponse;
+DSFid ClientConnectionResponse::getDSFID() const {
+ return DSFid::ClientConnectionResponse;
}
size_t ClientConnectionResponse::objectSize() const {
diff --git a/cppcache/src/ClientConnectionResponse.hpp b/cppcache/src/ClientConnectionResponse.hpp
index 80fbb0d..12c4ebd 100644
--- a/cppcache/src/ClientConnectionResponse.hpp
+++ b/cppcache/src/ClientConnectionResponse.hpp
@@ -32,7 +32,7 @@ class ClientConnectionResponse : public ServerLocationResponse {
public:
ClientConnectionResponse() : ServerLocationResponse(), m_serverFound(false) {}
void fromData(DataInput& input) override;
- int32_t getDSFID() const override;
+ DSFid getDSFID() const override;
size_t objectSize() const override;
virtual ServerLocation getServerLocation() const;
void printInfo() { m_server.printInfo(); }
diff --git a/cppcache/src/ClientHealthStats.hpp b/cppcache/src/ClientHealthStats.hpp
index 7d0fd5c..eb9f691 100644
--- a/cppcache/src/ClientHealthStats.hpp
+++ b/cppcache/src/ClientHealthStats.hpp
@@ -25,14 +25,13 @@
#include <geode/internal/DataSerializableFixedId.hpp>
#include "util/Log.hpp"
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
namespace client {
class ClientHealthStats : public internal::DataSerializableFixedId_t<
- GeodeTypeIdsImpl::ClientHealthStats> {
+ DSFid::ClientHealthStats> {
public:
void toData(DataOutput& output) const override;
diff --git a/cppcache/src/ClientProxyMembershipID.cpp b/cppcache/src/ClientProxyMembershipID.cpp
index 05dda12..4a4b655 100644
--- a/cppcache/src/ClientProxyMembershipID.cpp
+++ b/cppcache/src/ClientProxyMembershipID.cpp
@@ -23,10 +23,8 @@
#include <ace/OS.h>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/CacheableBuiltins.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include "DistributedSystem.hpp"
#include "DataOutputInternal.hpp"
#include "Version.hpp"
@@ -118,9 +116,8 @@ void ClientProxyMembershipID::initObjectVars(
}
m_vmViewId = vmViewId;
- m_memID.write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte));
- m_memID.write(
- static_cast<int8_t>(GeodeTypeIdsImpl::InternalDistributedMember));
+ m_memID.write(static_cast<int8_t>(DSCode::FixedIDByte));
+ m_memID.write(static_cast<int8_t>(DSCode::InternalDistributedMember));
m_memID.writeArrayLen(ADDRSIZE);
// writing first 4 bytes of the address. This will be same until
// IPV6 support is added in the client
diff --git a/cppcache/src/ClientProxyMembershipID.hpp b/cppcache/src/ClientProxyMembershipID.hpp
index e9eac68..cf7679f 100644
--- a/cppcache/src/ClientProxyMembershipID.hpp
+++ b/cppcache/src/ClientProxyMembershipID.hpp
@@ -28,7 +28,6 @@
#include <geode/DataOutput.hpp>
#include <geode/internal/functional.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include "DSMemberForVersionStamp.hpp"
namespace apache {
@@ -68,8 +67,8 @@ class ClientProxyMembershipID : public DSMemberForVersionStamp {
// Serializable interface:
void toData(DataOutput& output) const override;
void fromData(DataInput& input) override;
- int32_t getDSFID() const override {
- return GeodeTypeIdsImpl::InternalDistributedMember;
+ DSFid getDSFID() const override {
+ return DSFid::InternalDistributedMember;
}
size_t objectSize() const override { return 0; }
diff --git a/cppcache/src/ClientReplacementRequest.cpp b/cppcache/src/ClientReplacementRequest.cpp
index cbfa1bb..cd87e74 100644
--- a/cppcache/src/ClientReplacementRequest.cpp
+++ b/cppcache/src/ClientReplacementRequest.cpp
@@ -18,7 +18,6 @@
#include "ClientReplacementRequest.hpp"
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
-#include "GeodeTypeIdsImpl.hpp"
using namespace apache::geode::client;
@@ -27,6 +26,6 @@ void ClientReplacementRequest::toData(DataOutput& output) const {
this->m_serverLocation.toData(output);
}
-int32_t ClientReplacementRequest::getDSFID() const {
- return GeodeTypeIdsImpl::ClientReplacementRequest;
+DSFid ClientReplacementRequest::getDSFID() const {
+ return DSFid::ClientReplacementRequest;
}
diff --git a/cppcache/src/ClientReplacementRequest.hpp b/cppcache/src/ClientReplacementRequest.hpp
index 07349cf..181df0b 100644
--- a/cppcache/src/ClientReplacementRequest.hpp
+++ b/cppcache/src/ClientReplacementRequest.hpp
@@ -42,7 +42,7 @@ class ClientReplacementRequest : public ClientConnectionRequest {
~ClientReplacementRequest() override = default;
void toData(DataOutput& output) const override;
- int32_t getDSFID() const override;
+ DSFid getDSFID() const override;
private:
const ServerLocation m_serverLocation;
diff --git a/cppcache/src/DiskStoreId.hpp b/cppcache/src/DiskStoreId.hpp
index 330c923..4af4e71 100644
--- a/cppcache/src/DiskStoreId.hpp
+++ b/cppcache/src/DiskStoreId.hpp
@@ -23,7 +23,6 @@
#include <geode/internal/geode_globals.hpp>
#include <geode/DataInput.hpp>
#include "DSMemberForVersionStamp.hpp"
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
@@ -58,7 +57,7 @@ class DiskStoreId : public DSMemberForVersionStamp {
m_leastSig = input.readInt64();
}
- int32_t getDSFID() const override { return GeodeTypeIdsImpl::DiskStoreId; }
+ DSFid getDSFID() const override { return DSFid::DiskStoreId; }
int16_t compareTo(const DSMemberForVersionStamp& tagID) const override {
const DiskStoreId& otherDiskStoreId =
diff --git a/cppcache/src/DiskVersionTag.hpp b/cppcache/src/DiskVersionTag.hpp
index a415a03..bfeee2c 100644
--- a/cppcache/src/DiskVersionTag.hpp
+++ b/cppcache/src/DiskVersionTag.hpp
@@ -21,7 +21,6 @@
#define GEODE_DISKVERSIONTAG_H_
#include "VersionTag.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "DiskStoreId.hpp"
namespace apache {
@@ -55,7 +54,7 @@ class DiskVersionTag : public VersionTag {
DiskVersionTag(MemberListForVersionStamp& memberListForVersionStamp)
: VersionTag(memberListForVersionStamp) {}
- int32_t getDSFID() const override { return GeodeTypeIdsImpl::DiskVersionTag; }
+ DSFid getDSFID() const override { return DSFid::DiskVersionTag; }
static std::shared_ptr<Serializable> createDeserializable(
MemberListForVersionStamp& memberListForVersionStamp) {
diff --git a/cppcache/src/EnumInfo.cpp b/cppcache/src/EnumInfo.cpp
index cd88bc5..d007163 100644
--- a/cppcache/src/EnumInfo.cpp
+++ b/cppcache/src/EnumInfo.cpp
@@ -19,7 +19,6 @@
#include "EnumInfo.hpp"
#include "Utils.hpp"
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/EnumInfo.hpp b/cppcache/src/EnumInfo.hpp
index 457e178..fba2efc 100644
--- a/cppcache/src/EnumInfo.hpp
+++ b/cppcache/src/EnumInfo.hpp
@@ -20,7 +20,6 @@
#ifndef GEODE_ENUMINFO_H_
#define GEODE_ENUMINFO_H_
-#include <geode/GeodeTypeIds.hpp>
#include <geode/CacheableString.hpp>
#include <geode/CacheableKey.hpp>
@@ -31,7 +30,7 @@ namespace geode {
namespace client {
class APACHE_GEODE_EXPORT EnumInfo
- : public DataSerializableFixedId_t<GeodeTypeIds::EnumInfo>,
+ : public DataSerializableFixedId_t<DSFid::EnumInfo>,
public CacheableKey {
private:
std::shared_ptr<CacheableString> m_enumClassName;
diff --git a/cppcache/src/EventId.cpp b/cppcache/src/EventId.cpp
index e5830f1..f2ef85c 100644
--- a/cppcache/src/EventId.cpp
+++ b/cppcache/src/EventId.cpp
@@ -16,7 +16,6 @@
*/
#include <geode/DataInput.hpp>
#include "EventId.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "ClientProxyMembershipID.hpp"
#include <cstring>
diff --git a/cppcache/src/EventId.hpp b/cppcache/src/EventId.hpp
index cb0f70d..0c41110 100644
--- a/cppcache/src/EventId.hpp
+++ b/cppcache/src/EventId.hpp
@@ -26,8 +26,6 @@
#include <geode/internal/DataSerializableFixedId.hpp>
#include <geode/DataOutput.hpp>
-#include "GeodeTypeIdsImpl.hpp"
-
/** @file
*/
@@ -40,7 +38,7 @@ namespace client {
* Sequence ID
*/
class APACHE_GEODE_EXPORT EventId
- : public internal::DataSerializableFixedId_t<GeodeTypeIdsImpl::EventId> {
+ : public internal::DataSerializableFixedId_t<DSFid::EventId> {
private:
char m_eidMem[512];
int32_t m_eidMemLen;
diff --git a/cppcache/src/FarSideEntryOp.cpp b/cppcache/src/FarSideEntryOp.cpp
index bc220ff..05e15b5 100644
--- a/cppcache/src/FarSideEntryOp.cpp
+++ b/cppcache/src/FarSideEntryOp.cpp
@@ -55,7 +55,7 @@ void FarSideEntryOp::fromData(DataInput& input, bool largeModCount,
m_modSerialNum = input.read();
}
- if (input.read() != GeodeTypeIds::NullObj) {
+ if (input.read() != static_cast<int8_t>(DSCode::NullObj)) {
input.rewindCursor(1);
input.readObject(m_callbackArg);
}
@@ -72,7 +72,7 @@ void FarSideEntryOp::fromData(DataInput& input, bool largeModCount,
if (input.readBoolean()) {
int32_t rewind = 1;
int16_t fixedId = 0;
- if (input.read() == GeodeTypeIdsImpl::FixedIDShort) {
+ if (input.read() == static_cast<int8_t>(DSCode::FixedIDShort)) {
fixedId = input.readInt16();
rewind += 2;
}
@@ -116,11 +116,11 @@ void FarSideEntryOp::apply(std::shared_ptr<Region>& region) {
void FarSideEntryOp::skipFilterRoutingInfo(DataInput& input) {
std::shared_ptr<Cacheable> tmp;
- auto structType = input.read(); // this is DataSerializable (45)
+ auto structType = static_cast<DSCode>(input.read()); // this is DataSerializable (45)
- if (structType == GeodeTypeIds::NullObj) {
+ if (structType == DSCode::NullObj) {
return;
- } else if (structType == GeodeTypeIdsImpl::DataSerializable) {
+ } else if (structType == DSCode::DataSerializable) {
input.read(); // ignore classbyte
input.readObject(tmp);
int32_t size = input.readInt32();
diff --git a/cppcache/src/GeodeTypeIdsImpl.hpp b/cppcache/src/GeodeTypeIdsImpl.hpp
deleted file mode 100644
index 4c2b80d..0000000
--- a/cppcache/src/GeodeTypeIdsImpl.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GEODETYPEIDSIMPL_H_
-#define GEODE_GEODETYPEIDSIMPL_H_
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-namespace apache {
-namespace geode {
-namespace client {
-
-class GeodeTypeIdsImpl {
- public:
- // Internal IDs here
- // User visible IDs are in GeodeTypeIds.hpp
-
- enum IdValues {
- // keep the following in alphabetical order, please.
- CacheableObjectPartList = 25,
- CacheableObjectPartList66 = 2121,
- CacheableToken = 14, // because there's no equivalence in java
- CacheableUserClass = 40,
- CacheableUserData = 39,
- CacheableUserData2 = 38,
- CacheableUserData4 = 37,
- Class = 43,
- ClientConnectionRequest = -53,
- ClientConnectionResponse = -50,
- ClientHealthStats = -126,
- ClientProxyMembershipId = 38,
- ClientReplacementRequest = -48,
- CollectionTypeImpl = -59,
- DataSerializable = 45,
- DiskStoreId = 2133,
- DiskVersionTag = 2131,
- EntryEventImpl = 105,
- EventId = 36,
- FixedIDByte = 1,
- FixedIDDefault = 0,
- FixedIDInt = 3,
- FixedIDNone = 4,
- FixedIDShort = 2,
- GatewayEventCallbackArgument = -56, // 0xC8
- GatewaySenderEventCallbackArgument = -135, // 0xC8
- GetAllServersRequest = -43,
- GetAllServersResponse = -42,
- InterestResultPolicy = 37,
- InternalDistributedMember = 92,
- JavaSerializable = 44,
- LocatorListRequest = -54,
- LocatorListResponse = -51,
- ObjectTypeImpl = -61,
- PDX = 93,
- PDX_ENUM = 94,
- PreferBytesCachedDeserializable = -65,
- QueueConnectionRequest = -52,
- QueueConnectionResponse = -49,
- RegionEventImpl = 108,
- StructTypeImpl = -60,
- TXCommitMessage = 110,
- VersionedObjectPartList = 7,
- VersionTag = -120,
- VmCachedDeserializable = -64
- };
-};
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-#endif // GEODE_GEODETYPEIDSIMPL_H_
diff --git a/cppcache/src/GetAllServersRequest.hpp b/cppcache/src/GetAllServersRequest.hpp
index 2bf89f9..d955391 100644
--- a/cppcache/src/GetAllServersRequest.hpp
+++ b/cppcache/src/GetAllServersRequest.hpp
@@ -28,14 +28,13 @@
#include <geode/DataOutput.hpp>
#include <geode/CacheableString.hpp>
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
namespace client {
class GetAllServersRequest : public internal::DataSerializableFixedId_t<
- GeodeTypeIdsImpl::GetAllServersRequest> {
+ DSFid::GetAllServersRequest> {
std::shared_ptr<CacheableString> m_serverGroup;
public:
diff --git a/cppcache/src/GetAllServersResponse.hpp b/cppcache/src/GetAllServersResponse.hpp
index 9d87939..3b7967d 100644
--- a/cppcache/src/GetAllServersResponse.hpp
+++ b/cppcache/src/GetAllServersResponse.hpp
@@ -33,7 +33,7 @@ namespace geode {
namespace client {
class GetAllServersResponse : public internal::DataSerializableFixedId_t<
- GeodeTypeIdsImpl::GetAllServersResponse> {
+ DSFid::GetAllServersResponse> {
std::vector<ServerLocation> m_servers;
public:
diff --git a/cppcache/src/LocatorListRequest.cpp b/cppcache/src/LocatorListRequest.cpp
index a200705..fd8f78d 100644
--- a/cppcache/src/LocatorListRequest.cpp
+++ b/cppcache/src/LocatorListRequest.cpp
@@ -17,7 +17,6 @@
#include "LocatorListRequest.hpp"
#include <geode/DataInput.hpp>
#include <geode/DataOutput.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include <geode/CacheableString.hpp>
using namespace apache::geode::client;
@@ -29,6 +28,6 @@ void LocatorListRequest::toData(DataOutput& output) const {
output.writeString(m_servergroup);
}
-int32_t LocatorListRequest::getDSFID() const {
- return GeodeTypeIdsImpl::LocatorListRequest;
+DSFid LocatorListRequest::getDSFID() const {
+ return DSFid::LocatorListRequest;
}
diff --git a/cppcache/src/LocatorListRequest.hpp b/cppcache/src/LocatorListRequest.hpp
index ce63817..3bc040f 100644
--- a/cppcache/src/LocatorListRequest.hpp
+++ b/cppcache/src/LocatorListRequest.hpp
@@ -22,7 +22,6 @@
#include <string>
#include "ServerLocationRequest.hpp"
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
@@ -40,7 +39,7 @@ class LocatorListRequest : public ServerLocationRequest {
~LocatorListRequest() override = default;
void toData(DataOutput& output) const override;
- int32_t getDSFID() const override;
+ internal::DSFid getDSFID() const override;
};
} // namespace client
diff --git a/cppcache/src/LocatorListResponse.cpp b/cppcache/src/LocatorListResponse.cpp
index c437746..055d5bf 100644
--- a/cppcache/src/LocatorListResponse.cpp
+++ b/cppcache/src/LocatorListResponse.cpp
@@ -26,8 +26,8 @@ void LocatorListResponse::fromData(DataInput& input) {
m_isBalanced = input.readBoolean();
}
-int32_t LocatorListResponse::getDSFID() const {
- return GeodeTypeIdsImpl::LocatorListResponse;
+DSFid LocatorListResponse::getDSFID() const {
+ return DSFid::LocatorListResponse;
}
void LocatorListResponse::readList(DataInput& input) {
diff --git a/cppcache/src/LocatorListResponse.hpp b/cppcache/src/LocatorListResponse.hpp
index e487929..a5529af 100644
--- a/cppcache/src/LocatorListResponse.hpp
+++ b/cppcache/src/LocatorListResponse.hpp
@@ -21,7 +21,6 @@
#define GEODE_LOCATORLISTRESPONSE_H_
#include <vector>
-#include "GeodeTypeIdsImpl.hpp"
#include "ServerLocationResponse.hpp"
#include "ServerLocation.hpp"
@@ -42,7 +41,7 @@ class LocatorListResponse : public ServerLocationResponse {
~LocatorListResponse() override = default;
void fromData(DataInput& input) override;
- int32_t getDSFID() const override;
+ DSFid getDSFID() const override;
const std::vector<ServerLocation>& getLocators() const;
bool isBalanced() const;
diff --git a/cppcache/src/PdxFieldType.cpp b/cppcache/src/PdxFieldType.cpp
index de33cda..4803247 100644
--- a/cppcache/src/PdxFieldType.cpp
+++ b/cppcache/src/PdxFieldType.cpp
@@ -22,7 +22,6 @@
*/
#include "PdxFieldType.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "PdxTypes.hpp"
#include <geode/PdxFieldTypes.hpp>
//#include <malloc.h>
diff --git a/cppcache/src/PdxInstanceFactory.cpp b/cppcache/src/PdxInstanceFactory.cpp
index 6a2cd47..4d90e81 100644
--- a/cppcache/src/PdxInstanceFactory.cpp
+++ b/cppcache/src/PdxInstanceFactory.cpp
@@ -198,7 +198,7 @@ PdxInstanceFactory& PdxInstanceFactory::writeByteArray(
m_pdxType->addVariableLengthTypeField(fieldName, "byte[]",
PdxFieldTypes::BYTE_ARRAY);
auto cacheableObject =
- CacheableArray<int8_t, GeodeTypeIds::CacheableBytes>::create(value);
+ CacheableArray<int8_t, DSCode::CacheableBytes>::create(value);
m_FieldVsValues.emplace(fieldName, cacheableObject);
return *this;
}
diff --git a/cppcache/src/PdxInstanceImpl.cpp b/cppcache/src/PdxInstanceImpl.cpp
index d47baa4..20785f3 100644
--- a/cppcache/src/PdxInstanceImpl.cpp
+++ b/cppcache/src/PdxInstanceImpl.cpp
@@ -40,9 +40,9 @@ int8_t PdxInstanceImpl::m_FloatDefaultBytes[] = {0, 0, 0, 0};
int8_t PdxInstanceImpl::m_DoubleDefaultBytes[] = {0, 0, 0, 0, 0, 0, 0, 0};
int8_t PdxInstanceImpl::m_DateDefaultBytes[] = {-1, -1, -1, -1, -1, -1, -1, -1};
int8_t PdxInstanceImpl::m_StringDefaultBytes[] = {
- apache::geode::client::GeodeTypeIds::CacheableNullString};
+ static_cast<int8_t>(apache::geode::client::DSCode::CacheableNullString)};
int8_t PdxInstanceImpl::m_ObjectDefaultBytes[] = {
- apache::geode::client::GeodeTypeIds::NullObj};
+ static_cast<int8_t>(apache::geode::client::DSCode::NullObj)};
int8_t PdxInstanceImpl::m_NULLARRAYDefaultBytes[] = {-1};
std::shared_ptr<PdxFieldType> PdxInstanceImpl::m_DefaultPdxFieldType(
new PdxFieldType("default", "default", PdxFieldTypes::UNKNOWN,
@@ -157,7 +157,7 @@ void PdxInstanceImpl::writeField(PdxWriter& writer,
}
case PdxFieldTypes::BYTE_ARRAY: {
if (auto&& val = std::dynamic_pointer_cast<
- CacheableArray<int8_t, GeodeTypeIds::CacheableBytes>>(value)) {
+ CacheableArray<int8_t, DSCode::CacheableBytes>>(value)) {
writer.writeByteArray(fieldName, val->value());
}
break;
@@ -443,47 +443,49 @@ bool PdxInstanceImpl::deepArrayEquals(std::shared_ptr<Cacheable> obj,
if (auto primitive =
std::dynamic_pointer_cast<DataSerializablePrimitive>(obj)) {
switch (primitive->getDsCode()) {
- case GeodeTypeIds::CacheableObjectArray: {
+ case DSCode::CacheableObjectArray: {
auto objArrayPtr = std::dynamic_pointer_cast<CacheableObjectArray>(obj);
auto otherObjArrayPtr =
std::dynamic_pointer_cast<CacheableObjectArray>(otherObj);
return enumerateObjectArrayEquals(objArrayPtr, otherObjArrayPtr);
}
- case GeodeTypeIds::CacheableVector: {
+ case DSCode::CacheableVector: {
auto vec = std::dynamic_pointer_cast<CacheableVector>(obj);
auto otherVec = std::dynamic_pointer_cast<CacheableVector>(otherObj);
return enumerateVectorEquals(vec, otherVec);
}
- case GeodeTypeIds::CacheableArrayList: {
+ case DSCode::CacheableArrayList: {
auto arrList = std::dynamic_pointer_cast<CacheableArrayList>(obj);
auto otherArrList =
std::dynamic_pointer_cast<CacheableArrayList>(otherObj);
return enumerateArrayListEquals(arrList, otherArrList);
}
- case GeodeTypeIds::CacheableHashMap: {
+ case DSCode::CacheableHashMap: {
auto map = std::dynamic_pointer_cast<CacheableHashMap>(obj);
auto otherMap = std::dynamic_pointer_cast<CacheableHashMap>(otherObj);
return enumerateMapEquals(map, otherMap);
}
- case GeodeTypeIds::CacheableHashSet: {
+ case DSCode::CacheableHashSet: {
auto hashset = std::dynamic_pointer_cast<CacheableHashSet>(obj);
auto otherHashset =
std::dynamic_pointer_cast<CacheableHashSet>(otherObj);
return enumerateSetEquals(hashset, otherHashset);
}
- case GeodeTypeIds::CacheableLinkedHashSet: {
+ case DSCode::CacheableLinkedHashSet: {
auto linkedHashset =
std::dynamic_pointer_cast<CacheableLinkedHashSet>(obj);
auto otherLinkedHashset =
std::dynamic_pointer_cast<CacheableLinkedHashSet>(otherObj);
return enumerateLinkedSetEquals(linkedHashset, otherLinkedHashset);
}
- case GeodeTypeIds::CacheableHashTable: {
+ case DSCode::CacheableHashTable: {
auto hashTable = std::dynamic_pointer_cast<CacheableHashTable>(obj);
auto otherhashTable =
std::dynamic_pointer_cast<CacheableHashTable>(otherObj);
return enumerateHashTableEquals(hashTable, otherhashTable);
}
+ default:
+ break;
}
}
@@ -587,39 +589,41 @@ int PdxInstanceImpl::deepArrayHashCode(std::shared_ptr<Cacheable> obj) {
if (auto primitive =
std::dynamic_pointer_cast<DataSerializablePrimitive>(obj)) {
switch (primitive->getDsCode()) {
- case GeodeTypeIds::CacheableObjectArray: {
+ case DSCode::CacheableObjectArray: {
return enumerateObjectArrayHashCode(
std::dynamic_pointer_cast<CacheableObjectArray>(obj));
}
- case GeodeTypeIds::CacheableVector: {
+ case DSCode::CacheableVector: {
return enumerateVectorHashCode(
std::dynamic_pointer_cast<CacheableVector>(obj));
}
- case GeodeTypeIds::CacheableArrayList: {
+ case DSCode::CacheableArrayList: {
return enumerateArrayListHashCode(
std::dynamic_pointer_cast<CacheableArrayList>(obj));
}
- case GeodeTypeIds::CacheableLinkedList: {
+ case DSCode::CacheableLinkedList: {
return enumerateLinkedListHashCode(
std::dynamic_pointer_cast<CacheableLinkedList>(obj));
}
- case GeodeTypeIds::CacheableHashMap: {
+ case DSCode::CacheableHashMap: {
return enumerateMapHashCode(
std::dynamic_pointer_cast<CacheableHashMap>(obj));
}
- case GeodeTypeIds::CacheableHashSet: {
+ case DSCode::CacheableHashSet: {
return enumerateSetHashCode(
std::dynamic_pointer_cast<CacheableHashSet>(obj));
}
- case GeodeTypeIds::CacheableLinkedHashSet: {
+ case DSCode::CacheableLinkedHashSet: {
auto linkedHashSet =
std::dynamic_pointer_cast<CacheableLinkedHashSet>(obj);
return enumerateLinkedSetHashCode(linkedHashSet);
}
- case GeodeTypeIds::CacheableHashTable: {
+ case DSCode::CacheableHashTable: {
return enumerateHashTableCode(
std::dynamic_pointer_cast<CacheableHashTable>(obj));
}
+ default:
+ break;
}
}
@@ -1815,7 +1819,7 @@ void PdxInstanceImpl::setField(const std::string& fieldName,
(pft != nullptr ? pft->toString() : ""));
}
auto cacheableObject =
- CacheableArray<int8_t, GeodeTypeIds::CacheableBytes>::create(value);
+ CacheableArray<int8_t, DSCode::CacheableBytes>::create(value);
m_updatedFields[fieldName] = cacheableObject;
}
diff --git a/cppcache/src/PdxLocalWriter.cpp b/cppcache/src/PdxLocalWriter.cpp
index 9cd27fd..da5eac7 100644
--- a/cppcache/src/PdxLocalWriter.cpp
+++ b/cppcache/src/PdxLocalWriter.cpp
@@ -25,7 +25,6 @@
#include "PdxHelper.hpp"
#include "PdxTypeRegistry.hpp"
#include <geode/CacheableEnum.hpp>
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
@@ -231,9 +230,9 @@ PdxWriter& PdxLocalWriter::writeObject(const std::string&,
enumValPtr->toData(*m_dataOutput);
} else if (auto objectArray =
std::dynamic_pointer_cast<CacheableObjectArray>(value)) {
- m_dataOutput->write(objectArray->getDsCode());
+ m_dataOutput->write(static_cast<int8_t>(objectArray->getDsCode()));
m_dataOutput->writeArrayLen(static_cast<int32_t>(objectArray->size()));
- m_dataOutput->write(static_cast<int8_t>(GeodeTypeIdsImpl::Class));
+ m_dataOutput->write(static_cast<int8_t>(DSCode::Class));
auto iter = objectArray->begin();
const auto actualObjPtr = std::dynamic_pointer_cast<PdxSerializable>(*iter);
diff --git a/cppcache/src/PdxSerializable.cpp b/cppcache/src/PdxSerializable.cpp
index a7c800f..88816c5 100644
--- a/cppcache/src/PdxSerializable.cpp
+++ b/cppcache/src/PdxSerializable.cpp
@@ -19,7 +19,6 @@
#include <geode/CacheableString.hpp>
#include <geode/internal/CacheableKeys.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include "PdxHelper.hpp"
namespace apache {
diff --git a/cppcache/src/PdxType.cpp b/cppcache/src/PdxType.cpp
index aeec013..9da1d95 100644
--- a/cppcache/src/PdxType.cpp
+++ b/cppcache/src/PdxType.cpp
@@ -23,7 +23,6 @@
#include "PdxType.hpp"
#include "PdxHelper.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "PdxFieldType.hpp"
#include "Utils.hpp"
#include "PdxTypeRegistry.hpp"
@@ -59,8 +58,8 @@ PdxType::PdxType(PdxTypeRegistry& pdxTypeRegistry,
m_pdxTypeRegistry(pdxTypeRegistry) {}
void PdxType::toData(DataOutput& output) const {
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::DataSerializable)); // 45
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::Class)); // 43
+ output.write(static_cast<int8_t>(DSCode::DataSerializable)); // 45
+ output.write(static_cast<int8_t>(DSCode::Class)); // 43
output.writeString(m_javaPdxClass);
// m_className
diff --git a/cppcache/src/PdxType.hpp b/cppcache/src/PdxType.hpp
index fdbe320..5c5f7d4 100644
--- a/cppcache/src/PdxType.hpp
+++ b/cppcache/src/PdxType.hpp
@@ -113,7 +113,7 @@ class PdxType : public DataSerializableInternal,
void fromData(DataInput& input) override;
- int8_t getInternalId() const override { return GeodeTypeIds::PdxType; }
+ int8_t getInternalId() const override { return static_cast<int8_t>(DSCode::PdxType); }
static std::shared_ptr<Serializable> CreateDeserializable(
PdxTypeRegistry& pdxTypeRegistry) {
diff --git a/cppcache/src/Properties.cpp b/cppcache/src/Properties.cpp
index 5cf9ecc..d703a56 100644
--- a/cppcache/src/Properties.cpp
+++ b/cppcache/src/Properties.cpp
@@ -16,7 +16,6 @@
*/
#include <geode/Properties.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/CacheableKey.hpp>
#include <geode/CacheableString.hpp>
#include <geode/ExceptionTypes.hpp>
@@ -196,7 +195,7 @@ std::shared_ptr<Serializable> Properties::createDeserializable() {
return std::make_shared<Properties>();
}
-int8_t Properties::getDsCode() const { return GeodeTypeIds::Properties; }
+DSCode Properties::getDsCode() const { return DSCode::Properties; }
void Properties::toData(DataOutput& output) const {
output.writeArrayLen(static_cast<uint32_t>(m_map.size()));
diff --git a/cppcache/src/QueueConnectionRequest.cpp b/cppcache/src/QueueConnectionRequest.cpp
index b6450c8..bc19f0b 100644
--- a/cppcache/src/QueueConnectionRequest.cpp
+++ b/cppcache/src/QueueConnectionRequest.cpp
@@ -16,7 +16,6 @@
*/
#include "QueueConnectionRequest.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include <geode/DataInput.hpp>
#include <geode/DataOutput.hpp>
@@ -24,8 +23,8 @@ using namespace apache::geode::client;
void QueueConnectionRequest::toData(DataOutput& output) const {
output.writeString(m_serverGp);
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte));
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::ClientProxyMembershipId));
+ output.write(static_cast<int8_t>(DSCode::FixedIDByte));
+ output.write(static_cast<int8_t>(DSCode::ClientProxyMembershipId));
uint32_t buffLen;
const char* buff = m_membershipID.getDSMemberId(buffLen);
output.writeBytes((uint8_t*)buff, buffLen);
@@ -35,8 +34,8 @@ void QueueConnectionRequest::toData(DataOutput& output) const {
output.writeBoolean(m_findDurable);
}
-int32_t QueueConnectionRequest::getDSFID() const {
- return GeodeTypeIdsImpl::QueueConnectionRequest;
+DSFid QueueConnectionRequest::getDSFID() const {
+ return DSFid::QueueConnectionRequest;
}
std::set<ServerLocation> QueueConnectionRequest::getExcludedServer() const {
diff --git a/cppcache/src/QueueConnectionRequest.hpp b/cppcache/src/QueueConnectionRequest.hpp
index 272b9f3..0025670 100644
--- a/cppcache/src/QueueConnectionRequest.hpp
+++ b/cppcache/src/QueueConnectionRequest.hpp
@@ -44,7 +44,7 @@ class QueueConnectionRequest : public ServerLocationRequest {
m_serverGp(serverGp) {} // No need for default constructor as creating
// request with it does not make sense.
void toData(DataOutput& output) const override;
- int32_t getDSFID() const override;
+ DSFid getDSFID() const override;
virtual std::set<ServerLocation> getExcludedServer() const;
virtual const ClientProxyMembershipID& getProxyMemberShipId() const;
diff --git a/cppcache/src/QueueConnectionResponse.cpp b/cppcache/src/QueueConnectionResponse.cpp
index db519ff..5c65082 100644
--- a/cppcache/src/QueueConnectionResponse.cpp
+++ b/cppcache/src/QueueConnectionResponse.cpp
@@ -16,7 +16,6 @@
*/
#include "QueueConnectionResponse.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include <geode/DataInput.hpp>
#include "ServerLocation.hpp"
@@ -27,8 +26,8 @@ void QueueConnectionResponse::fromData(DataInput& input) {
readList(input);
}
-int32_t QueueConnectionResponse::getDSFID() const {
- return GeodeTypeIdsImpl::QueueConnectionResponse;
+DSFid QueueConnectionResponse::getDSFID() const {
+ return DSFid::QueueConnectionResponse;
}
void QueueConnectionResponse::readList(DataInput& input) {
diff --git a/cppcache/src/QueueConnectionResponse.hpp b/cppcache/src/QueueConnectionResponse.hpp
index 4a5a06d..589ddc9 100644
--- a/cppcache/src/QueueConnectionResponse.hpp
+++ b/cppcache/src/QueueConnectionResponse.hpp
@@ -37,7 +37,7 @@ class QueueConnectionResponse : public ServerLocationResponse {
void fromData(DataInput& input) override;
- int32_t getDSFID() const override;
+ DSFid getDSFID() const override;
virtual std::list<ServerLocation> getServers() { return m_list; }
diff --git a/cppcache/src/RegionAttributes.cpp b/cppcache/src/RegionAttributes.cpp
index 47ff400..f912a6c 100644
--- a/cppcache/src/RegionAttributes.cpp
+++ b/cppcache/src/RegionAttributes.cpp
@@ -23,7 +23,6 @@
#include <geode/Cache.hpp>
#include <geode/DataOutput.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/DataInput.hpp>
#include <geode/Properties.hpp>
@@ -282,7 +281,7 @@ std::shared_ptr<Serializable> RegionAttributes::createDeserializable() {
}
int8_t RegionAttributes::getInternalId() const {
- return GeodeTypeIds::RegionAttributes;
+ return static_cast<int8_t>(DSCode::RegionAttributes);
}
namespace impl {
diff --git a/cppcache/src/Serializable.cpp b/cppcache/src/Serializable.cpp
index f24b9e5..dc1d2b6 100644
--- a/cppcache/src/Serializable.cpp
+++ b/cppcache/src/Serializable.cpp
@@ -19,7 +19,6 @@
#include <geode/Serializable.hpp>
#include <geode/CacheableString.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include "SerializationRegistry.hpp"
#include "Utils.hpp"
#include "CacheImpl.hpp"
diff --git a/cppcache/src/SerializationRegistry.cpp b/cppcache/src/SerializationRegistry.cpp
index 55ea50c..15e93d3 100644
--- a/cppcache/src/SerializationRegistry.cpp
+++ b/cppcache/src/SerializationRegistry.cpp
@@ -32,7 +32,6 @@
#include <geode/Struct.hpp>
#include <geode/DataInput.hpp>
#include <geode/DataOutput.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/Region.hpp>
#include <geode/Properties.hpp>
#include <geode/ExceptionTypes.hpp>
@@ -66,7 +65,7 @@ namespace client {
void TheTypeMap::setup() {
// Register Geode builtins here!!
- // update type ids in GeodeTypeIds.hpp
+ // update type ids in DSCode.hpp
bind(CacheableByte::createDeserializable);
bind(CacheableBoolean::createDeserializable);
@@ -121,61 +120,64 @@ void TheTypeMap::setup() {
std::shared_ptr<Serializable> SerializationRegistry::deserialize(
DataInput& input, int8_t typeId) const {
bool findinternal = false;
- auto currentTypeId = typeId;
+ auto typedTypeId = static_cast<DSCode>(typeId);
+ int64_t compId = typeId;
if (typeId == -1) {
- currentTypeId = input.read();
+ compId = input.read();
+ typedTypeId = static_cast<DSCode>(compId);
}
- int64_t compId = currentTypeId;
- LOGDEBUG("SerializationRegistry::deserialize typeid = %d currentTypeId= %d",
- typeId, currentTypeId);
+ LOGDEBUG("SerializationRegistry::deserialize typeid = %d currentTypeId= %" PRId8,
+ typeId, typedTypeId);
- switch (compId) {
- case GeodeTypeIds::NullObj: {
- return nullptr;
- }
- case GeodeTypeIds::CacheableNullString: {
+ switch (typedTypeId) {
+ case DSCode::CacheableNullString: {
return std::shared_ptr<Serializable>(
CacheableString::createDeserializable());
}
- case GeodeTypeIdsImpl::PDX: {
+ case DSCode::PDX: {
return pdxTypeHandler->deserialize(input);
}
- case GeodeTypeIds::CacheableEnum: {
+ case DSCode::CacheableEnum: {
auto enumObject = CacheableEnum::create(" ", " ", 0);
enumObject->fromData(input);
return enumObject;
}
- case GeodeTypeIdsImpl::CacheableUserData: {
+ case DSCode::CacheableUserData: {
compId |= ((static_cast<int64_t>(input.read())) << 32);
break;
}
- case GeodeTypeIdsImpl::CacheableUserData2: {
+ case DSCode::CacheableUserData2: {
compId |= ((static_cast<int64_t>(input.readInt16())) << 32);
break;
}
- case GeodeTypeIdsImpl::CacheableUserData4: {
+ case DSCode::CacheableUserData4: {
int32_t classId = input.readInt32();
compId |= ((static_cast<int64_t>(classId)) << 32);
break;
}
- case GeodeTypeIdsImpl::FixedIDByte: {
+ case DSCode::FixedIDByte: {
compId = input.read();
findinternal = true;
break;
}
- case GeodeTypeIdsImpl::FixedIDShort: {
+ case DSCode::FixedIDShort: {
compId = input.readInt16();
findinternal = true;
break;
}
- case GeodeTypeIdsImpl::FixedIDInt: {
+ case DSCode::FixedIDInt: {
int32_t fixedId = input.readInt32();
compId = fixedId;
findinternal = true;
break;
}
+ case DSCode::NullObj: {
+ return nullptr;
+ }
+ default:
+ break;
}
TypeFactoryMethod createType = nullptr;
diff --git a/cppcache/src/SerializationRegistry.hpp b/cppcache/src/SerializationRegistry.hpp
index 50b2ced..f4cc5fb 100644
--- a/cppcache/src/SerializationRegistry.hpp
+++ b/cppcache/src/SerializationRegistry.hpp
@@ -31,7 +31,6 @@
#include <geode/internal/DataSerializableInternal.hpp>
#include <geode/Serializable.hpp>
#include <geode/PdxSerializer.hpp>
-#include <geode/GeodeTypeIds.hpp>
#include <geode/DataOutput.hpp>
#include <geode/ExceptionTypes.hpp>
#include <geode/Delta.hpp>
@@ -40,7 +39,6 @@
#include "util/concurrent/spinlock_mutex.hpp"
#include "NonCopyable.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "MemberListForVersionStamp.hpp"
#include "config.h"
@@ -160,7 +158,7 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
inline void serialize(const Serializable* obj, DataOutput& output,
bool isDelta = false) const {
if (obj == nullptr) {
- output.write(static_cast<int8_t>(GeodeTypeIds::NullObj));
+ output.write(static_cast<int8_t>(DSCode::NullObj));
} else if (const auto dataSerializableFixedId =
dynamic_cast<const DataSerializableFixedId*>(obj)) {
serialize(dataSerializableFixedId, output);
@@ -183,7 +181,7 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
inline void serialize(const std::shared_ptr<Serializable>& obj, DataOutput& output,
bool isDelta = false) const {
if (obj == nullptr) {
- output.write(static_cast<int8_t>(GeodeTypeIds::NullObj));
+ output.write(static_cast<int8_t>(DSCode::NullObj));
} else if (auto&& pdxSerializable =
std::dynamic_pointer_cast<PdxSerializable>(obj)) {
serialize(pdxSerializable, output);
@@ -285,17 +283,17 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
inline void serialize(const DataSerializableFixedId* obj,
DataOutput& output) const {
- auto id = obj->getDSFID();
+ auto id = static_cast<int32_t>(obj->getDSFID());
if (id <= std::numeric_limits<int8_t>::max() &&
id >= std::numeric_limits<int8_t>::min()) {
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte));
+ output.write(static_cast<int8_t>(DSCode::FixedIDByte));
output.write(static_cast<int8_t>(id));
} else if (id <= std::numeric_limits<int16_t>::max() &&
id >= std::numeric_limits<int16_t>::min()) {
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDShort));
+ output.write(static_cast<int8_t>(DSCode::FixedIDShort));
output.writeInt(static_cast<int16_t>(id));
} else {
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDInt));
+ output.write(static_cast<int8_t>(DSCode::FixedIDInt));
output.writeInt(static_cast<int32_t>(id));
}
@@ -325,15 +323,15 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
auto id = obj->getClassId();
auto dsCode = getSerializableDataDsCode(id);
- output.write(dsCode);
+ output.write(static_cast<int8_t>(dsCode));
switch (dsCode) {
- case GeodeTypeIdsImpl::CacheableUserData:
+ case DSCode::CacheableUserData:
output.write(static_cast<int8_t>(id));
break;
- case GeodeTypeIdsImpl::CacheableUserData2:
+ case DSCode::CacheableUserData2:
output.writeInt(static_cast<int16_t>(id));
break;
- case GeodeTypeIdsImpl::CacheableUserData4:
+ case DSCode::CacheableUserData4:
output.writeInt(static_cast<int32_t>(id));
break;
default:
@@ -354,7 +352,7 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
}
inline void serialize(const std::shared_ptr<PdxSerializable>& obj, DataOutput& output) const {
- output.write(static_cast<int8_t>(GeodeTypeIdsImpl::PDX));
+ output.write(static_cast<int8_t>(DSCode::PDX));
serializeWithoutHeader(obj, output);
}
@@ -373,15 +371,15 @@ class APACHE_GEODE_EXPORT SerializationRegistry {
}
public:
- static inline int8_t getSerializableDataDsCode(int32_t classId) {
+ static inline DSCode getSerializableDataDsCode(int32_t classId) {
if (classId <= std::numeric_limits<int8_t>::max() &&
classId >= std::numeric_limits<int8_t>::min()) {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableUserData);
+ return DSCode::CacheableUserData;
} else if (classId <= std::numeric_limits<int16_t>::max() &&
classId >= std::numeric_limits<int16_t>::min()) {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableUserData2);
+ return DSCode::CacheableUserData2;
} else {
- return static_cast<int8_t>(GeodeTypeIdsImpl::CacheableUserData4);
+ return DSCode::CacheableUserData4;
}
}
diff --git a/cppcache/src/ServerLocation.hpp b/cppcache/src/ServerLocation.hpp
index e7b43c9..409eff7 100644
--- a/cppcache/src/ServerLocation.hpp
+++ b/cppcache/src/ServerLocation.hpp
@@ -30,7 +30,6 @@
#include <geode/CacheableBuiltins.hpp>
#include "Utils.hpp"
-#include "GeodeTypeIdsImpl.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/Struct.cpp b/cppcache/src/Struct.cpp
index 4e703cf..f0c6144 100644
--- a/cppcache/src/Struct.cpp
+++ b/cppcache/src/Struct.cpp
@@ -18,7 +18,6 @@
#include <string>
#include <geode/Struct.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include <geode/DataInput.hpp>
namespace apache {
@@ -30,7 +29,7 @@ Struct::Struct(StructSet* ssPtr,
: m_parent(ssPtr), m_fieldValues(fieldValues) {}
void Struct::skipClassName(DataInput& input) {
- if (input.read() == GeodeTypeIdsImpl::Class) {
+ if (input.read() == static_cast<int8_t>(DSCode::Class)) {
input.read(); // ignore string type id - assuming its a normal
// (under 64k) string.
uint16_t len = input.readInt16();
diff --git a/cppcache/src/TXCommitMessage.cpp b/cppcache/src/TXCommitMessage.cpp
index 1a2aa28..b2ffe34 100644
--- a/cppcache/src/TXCommitMessage.cpp
+++ b/cppcache/src/TXCommitMessage.cpp
@@ -76,10 +76,10 @@ void TXCommitMessage::fromData(DataInput& input) {
m_regions.push_back(rc);
}
- const auto fixedId = input.read();
- if (fixedId == GeodeTypeIdsImpl::FixedIDByte) {
- const auto dfsid = input.read();
- if (dfsid == GeodeTypeIdsImpl::ClientProxyMembershipId) {
+ const auto fixedId = static_cast<const DSCode>(input.read());
+ if (fixedId == DSCode::FixedIDByte) {
+ const auto dscode = static_cast<const DSCode>(input.read());
+ if (dscode == DSCode::ClientProxyMembershipId) {
ClientProxyMembershipID memId1;
input.advanceCursor(input.readArrayLength());
@@ -87,16 +87,16 @@ void TXCommitMessage::fromData(DataInput& input) {
input.readInt32();
} else {
LOGERROR(
- "TXCommitMessage::fromData Unexpected type id: %d while "
+ "TXCommitMessage::fromData Unexpected type id: %" PRId8 "while "
"desirializing commit response",
- dfsid);
+ dscode);
GfErrTypeThrowException(
"TXCommitMessage::fromData Unable to handle commit response",
GF_CACHE_ILLEGAL_STATE_EXCEPTION);
}
- } else if (fixedId != GeodeTypeIds::NullObj) {
+ } else if (fixedId != DSCode::NullObj) {
LOGERROR(
- "TXCommitMessage::fromData Unexpected type id: %d while desirializing "
+ "TXCommitMessage::fromData Unexpected type id: %" PRId8 "while desirializing "
"commit response",
fixedId);
GfErrTypeThrowException(
diff --git a/cppcache/src/TXCommitMessage.hpp b/cppcache/src/TXCommitMessage.hpp
index 72b0d62..cc61826 100644
--- a/cppcache/src/TXCommitMessage.hpp
+++ b/cppcache/src/TXCommitMessage.hpp
@@ -29,7 +29,7 @@ namespace geode {
namespace client {
class TXCommitMessage
- : public DataSerializableFixedId_t<GeodeTypeIdsImpl::TXCommitMessage> {
+ : public DataSerializableFixedId_t<DSFid::TXCommitMessage> {
public:
TXCommitMessage(MemberListForVersionStamp& memberListForVersionStamp);
~TXCommitMessage() override = default;
diff --git a/cppcache/src/TcrConnection.cpp b/cppcache/src/TcrConnection.cpp
index 4d232c3..7ca564c 100644
--- a/cppcache/src/TcrConnection.cpp
+++ b/cppcache/src/TcrConnection.cpp
@@ -29,7 +29,6 @@
#include "ClientProxyMembershipID.hpp"
#include "ThinClientPoolHADM.hpp"
#include "TcrEndpoint.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "TcrConnectionManager.hpp"
#include "DistributedSystemImpl.hpp"
#include "Version.hpp"
@@ -144,11 +143,11 @@ bool TcrConnection::InitTcrConnection(
}
// Write header for byte FixedID since GFE 5.7
- handShakeMsg.write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte));
+ handShakeMsg.write(static_cast<int8_t>(DSCode::FixedIDByte));
// Writing byte for ClientProxyMembershipID class id=38 as registered on the
// java server.
handShakeMsg.write(
- static_cast<int8_t>(GeodeTypeIdsImpl::ClientProxyMembershipId));
+ static_cast<int8_t>(DSCode::ClientProxyMembershipId));
if (endpointObj->getPoolHADM()) {
ClientProxyMembershipID* memId =
endpointObj->getPoolHADM()->getMembershipId();
@@ -1333,11 +1332,11 @@ std::shared_ptr<CacheableString> TcrConnection::readHandshakeString(
LOGDEBUG("Received string typeid as %d", cstypeid);
uint32_t length = 0;
- switch (static_cast<int8_t>(cstypeid)) {
- case GeodeTypeIds::CacheableNullString: {
+ switch (static_cast<DSCode>(cstypeid)) {
+ case DSCode::CacheableNullString: {
return nullptr;
}
- case GeodeTypeIds::CacheableASCIIString: {
+ case DSCode::CacheableASCIIString: {
auto lenBytes = readHandshakeData(2, connectTimeout);
auto lenDI = m_connectionManager->getCacheImpl()->createDataInput(
reinterpret_cast<const uint8_t*>(lenBytes.data()), lenBytes.size());
diff --git a/cppcache/src/TcrMessage.cpp b/cppcache/src/TcrMessage.cpp
index c6833b6..5356b1a 100644
--- a/cppcache/src/TcrMessage.cpp
+++ b/cppcache/src/TcrMessage.cpp
@@ -81,8 +81,8 @@ void TcrMessage::setKeepAlive(bool keepalive) {
void TcrMessage::writeInterestResultPolicyPart(InterestResultPolicy policy) {
m_request->writeInt((int32_t)3); // size
m_request->write(static_cast<int8_t>(1)); // isObject
- m_request->write(static_cast<int8_t>(GeodeTypeIdsImpl::FixedIDByte));
- m_request->write(static_cast<int8_t>(GeodeTypeIdsImpl::InterestResultPolicy));
+ m_request->write(static_cast<int8_t>(DSCode::FixedIDByte));
+ m_request->write(static_cast<int8_t>(DSCode::InterestResultPolicy));
m_request->write(static_cast<int8_t>(policy.getOrdinal()));
}
@@ -142,20 +142,20 @@ void TcrMessage::readPrMetaData(DataInput& input) {
std::shared_ptr<VersionTag> TcrMessage::readVersionTagPart(
DataInput& input, uint16_t endpointMemId,
MemberListForVersionStamp& memberListForVersionStamp) {
- auto isObj = input.read();
+ auto isObj = static_cast<DSCode>(input.read());
std::shared_ptr<VersionTag> versionTag;
- if (isObj == GeodeTypeIds::NullObj) return versionTag;
+ if (isObj == DSCode::NullObj) return versionTag;
- if (isObj == GeodeTypeIdsImpl::FixedIDByte) {
+ if (isObj == DSCode::FixedIDByte) {
versionTag = std::make_shared<VersionTag>(memberListForVersionStamp);
- if (input.read() == GeodeTypeIdsImpl::VersionTag) {
+ if (static_cast<DSFid>(input.read()) == DSFid::VersionTag) {
versionTag->fromData(input);
versionTag->replaceNullMemberId(endpointMemId);
return versionTag;
}
- } else if (isObj == GeodeTypeIdsImpl::FixedIDShort) {
- if (input.readInt16() == GeodeTypeIdsImpl::DiskVersionTag) {
+ } else if (isObj == DSCode::FixedIDShort) {
+ if (input.readInt16() == static_cast<int16_t>(DSFid::DiskVersionTag)) {
DiskVersionTag* disk = new DiskVersionTag(memberListForVersionStamp);
disk->fromData(input);
versionTag.reset(disk);
@@ -423,7 +423,7 @@ std::shared_ptr<Serializable> TcrMessage::readCacheableBytes(DataInput& input,
}
return input.readDirectObject(
- static_cast<int8_t>(apache::geode::client::GeodeTypeIds::CacheableBytes));
+ static_cast<int8_t>(apache::geode::client::DSCode::CacheableBytes));
}
bool TcrMessage::readExceptionPart(DataInput& input, uint8_t isLastChunk,
@@ -497,10 +497,10 @@ void TcrMessage::writeObjectPart(
*m_request);
} else {
if (getAllKeyList != nullptr) {
- int8_t typeId = GeodeTypeIds::CacheableObjectArray;
+ int8_t typeId = static_cast<int8_t>(DSCode::CacheableObjectArray);
m_request->write(typeId);
m_request->writeArrayLen(static_cast<int32_t>(getAllKeyList->size()));
- m_request->write(static_cast<int8_t>(GeodeTypeIdsImpl::Class));
+ m_request->write(static_cast<int8_t>(DSCode::Class));
m_request->writeString("java.lang.Object");
for (const auto& key : *getAllKeyList) {
m_request->writeObject(key);
@@ -936,7 +936,7 @@ void TcrMessage::handleByteArrayResponse(
// PdxType will come in response
input.advanceCursor(5); // part header
m_value =
- serializationRegistry.deserialize(input, GeodeTypeIds::PdxType);
+ serializationRegistry.deserialize(input, static_cast<int8_t>(DSCode::PdxType));
} else if (m_msgTypeRequest == TcrMessage::GET_PDX_ENUM_BY_ID) {
// PdxType will come in response
input.advanceCursor(5); // part header
@@ -1216,7 +1216,7 @@ void TcrMessage::handleByteArrayResponse(
int32_t bits32 = input.readInt32(); // partlen;
input.read(); // isObj;
auto bits8 = input.read(); // cacheable vector typeid
- LOGDEBUG("Expected typeID %d, got %d", GeodeTypeIds::CacheableArrayList,
+ LOGDEBUG("Expected typeID %d, got %d", DSCode::CacheableArrayList,
bits8);
bits32 = input.readArrayLength(); // array length
@@ -2873,8 +2873,8 @@ std::shared_ptr<DSMemberForVersionStamp> TcrMessage::readDSMember(
apache::geode::client::DataInput& input) {
uint8_t typeidLen = input.read();
if (typeidLen == 1) {
- uint8_t typeidofMember = input.read();
- if (typeidofMember != GeodeTypeIdsImpl::InternalDistributedMember) {
+ auto typeidofMember = static_cast<DSCode>(input.read());
+ if (typeidofMember != DSCode::InternalDistributedMember) {
throw Exception(
"Reading DSMember. Expecting type id 92 for "
"InternalDistributedMember. ");
@@ -2885,8 +2885,8 @@ std::shared_ptr<DSMemberForVersionStamp> TcrMessage::readDSMember(
memId->fromData(input);
return (std::shared_ptr<DSMemberForVersionStamp>)memId;
} else if (typeidLen == 2) {
- uint16_t typeidofMember = input.readInt16();
- if (typeidofMember != GeodeTypeIdsImpl::DiskStoreId) {
+ auto typeidofMember = input.readInt16();
+ if (typeidofMember != static_cast<int16_t>(DSFid::DiskStoreId)) {
throw Exception(
"Reading DSMember. Expecting type id 2133 for DiskStoreId. ");
}
@@ -2903,7 +2903,7 @@ void TcrMessage::readHashMapForGCVersions(
apache::geode::client::DataInput& input,
std::shared_ptr<CacheableHashMap>& value) {
uint8_t hashmaptypeid = input.read();
- if (hashmaptypeid != GeodeTypeIds::CacheableHashMap) {
+ if (hashmaptypeid != static_cast<int8_t>(DSCode::CacheableHashMap)) {
throw Exception(
"Reading HashMap For GC versions. Expecting type id of hash map. ");
}
@@ -2936,7 +2936,7 @@ void TcrMessage::readHashSetForGCVersions(
apache::geode::client::DataInput& input,
std::shared_ptr<CacheableHashSet>& value) {
auto hashsettypeid = input.read();
- if (hashsettypeid != GeodeTypeIds::CacheableHashSet) {
+ if (hashsettypeid != static_cast<int8_t>(DSCode::CacheableHashSet)) {
throw Exception(
"Reading HashSet For GC versions. Expecting type id of hash set. ");
}
diff --git a/cppcache/src/TcrMessage.hpp b/cppcache/src/TcrMessage.hpp
index 9e4e1bb..bd5e524 100644
--- a/cppcache/src/TcrMessage.hpp
+++ b/cppcache/src/TcrMessage.hpp
@@ -24,6 +24,8 @@
#include <string>
#include <map>
#include <vector>
+#define __STDC_FORMAT_MACROS
+#include <cinttypes>
#include <ace/OS.h>
@@ -41,7 +43,6 @@
#include "EventId.hpp"
#include "EventIdMap.hpp"
#include "TcrChunkedContext.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "BucketServerLocation.hpp"
#include "FixedPartitionAttributesImpl.hpp"
#include "VersionTag.hpp"
@@ -1233,7 +1234,7 @@ class TcrMessageHelper {
/**
* result types returned by readChunkPartHeader
*/
- enum ChunkObjectType { OBJECT = 0, EXCEPTION = 1, NULL_OBJECT = 2 };
+ enum class ChunkObjectType { OBJECT = 0, EXCEPTION = 1, NULL_OBJECT = 2 };
/**
* Tries to read an exception part and returns true if the exception
@@ -1256,7 +1257,7 @@ class TcrMessageHelper {
* message type is encountered in the header.
*/
inline static ChunkObjectType readChunkPartHeader(
- TcrMessage& msg, DataInput& input, uint8_t expectedFirstType,
+ TcrMessage& msg, DataInput& input, DSCode expectedFirstType,
int32_t expectedPartType, const char* methodName, uint32_t& partLen,
uint8_t isLastChunk) {
partLen = input.readInt32();
@@ -1264,7 +1265,7 @@ class TcrMessageHelper {
if (partLen == 0) {
// special null object is case for scalar query result
- return NULL_OBJECT;
+ return ChunkObjectType::NULL_OBJECT;
} else if (!isObj) {
// otherwise we're currently always expecting an object
char exMsg[256];
@@ -1274,18 +1275,19 @@ class TcrMessageHelper {
methodName);
LOGDEBUG("%s ", exMsg);
// throw MessageException(exMsg);
- return EXCEPTION;
+ return ChunkObjectType::EXCEPTION;
}
- uint8_t partType = input.read();
- int32_t compId = partType;
+ auto rawByte = input.read();
+ auto partType = static_cast<DSCode>(rawByte);
+ auto compId = static_cast<int32_t>(partType);
// ugly hack to check for exception chunk
- if (partType == GeodeTypeIdsImpl::JavaSerializable) {
+ if (partType == DSCode::JavaSerializable) {
input.reset();
if (TcrMessageHelper::readExceptionPart(msg, input, isLastChunk)) {
msg.setMessageType(TcrMessage::EXCEPTION);
- return EXCEPTION;
+ return ChunkObjectType::EXCEPTION;
} else {
char exMsg[256];
ACE_OS::snprintf(
@@ -1295,42 +1297,41 @@ class TcrMessageHelper {
methodName);
throw MessageException(exMsg);
}
- } else if (partType == GeodeTypeIds::NullObj) {
+ } else if (partType == DSCode::NullObj) {
// special null object is case for scalar query result
- return NULL_OBJECT;
+ return ChunkObjectType::NULL_OBJECT;
}
- if (expectedFirstType > 0) {
+ // TODO enum - wtf?
+ if (expectedFirstType > DSCode::FixedIDDefault) {
if (partType != expectedFirstType) {
char exMsg[256];
ACE_OS::snprintf(exMsg, 255,
"TcrMessageHelper::readChunkPartHeader: "
- "%s: got unhandled object class = %d",
- methodName, partType);
+ "%s: got unhandled object class = %" PRId8,
+ methodName, static_cast<int8_t>(partType));
throw MessageException(exMsg);
}
// This is for GETALL
- if (expectedFirstType == GeodeTypeIdsImpl::FixedIDShort) {
+ if (expectedFirstType == DSCode::FixedIDShort) {
compId = input.readInt16();
- ;
} // This is for QUERY or REGISTER INTEREST.
- else if (expectedFirstType == GeodeTypeIdsImpl::FixedIDByte ||
- expectedFirstType == 0) {
- partType = input.read();
- compId = partType;
+ else if (expectedFirstType == DSCode::FixedIDByte) {
+ compId = input.read();
}
}
if (compId != expectedPartType) {
char exMsg[256];
ACE_OS::snprintf(exMsg, 255,
"TcrMessageHelper::readChunkPartHeader: "
- "%s: got unhandled object type = %d",
- methodName, compId);
+ "%s: got unhandled object type = %d, expected = %d, raw = %d",
+ methodName, compId, expectedPartType, rawByte);
throw MessageException(exMsg);
}
- return OBJECT;
+ return ChunkObjectType::OBJECT;
}
- inline static int8_t readChunkPartHeader(TcrMessage& msg, DataInput& input,
+
+ inline static ChunkObjectType readChunkPartHeader(TcrMessage& msg, DataInput& input,
const char* methodName,
uint32_t& partLen,
uint8_t isLastChunk) {
@@ -1339,7 +1340,7 @@ class TcrMessageHelper {
if (partLen == 0) {
// special null object is case for scalar query result
- return static_cast<int8_t>(NULL_OBJECT);
+ return ChunkObjectType::NULL_OBJECT;
} else if (!isObj) {
// otherwise we're currently always expecting an object
char exMsg[256];
@@ -1350,13 +1351,13 @@ class TcrMessageHelper {
throw MessageException(exMsg);
}
- const auto partType = input.read();
+ const auto partType = static_cast<const DSCode>(input.read());
// ugly hack to check for exception chunk
- if (partType == GeodeTypeIdsImpl::JavaSerializable) {
+ if (partType == DSCode::JavaSerializable) {
input.reset();
if (TcrMessageHelper::readExceptionPart(msg, input, isLastChunk)) {
msg.setMessageType(TcrMessage::EXCEPTION);
- return static_cast<int8_t>(EXCEPTION);
+ return ChunkObjectType::EXCEPTION;
} else {
char exMsg[256];
ACE_OS::snprintf(
@@ -1366,11 +1367,11 @@ class TcrMessageHelper {
methodName);
throw MessageException(exMsg);
}
- } else if (partType == GeodeTypeIds::NullObj) {
+ } else if (partType == DSCode::NullObj) {
// special null object is case for scalar query result
- return static_cast<int8_t>(NULL_OBJECT);
+ return ChunkObjectType::NULL_OBJECT;
}
- return partType;
+ return ChunkObjectType::OBJECT;
}
};
} // namespace client
diff --git a/cppcache/src/ThinClientRegion.cpp b/cppcache/src/ThinClientRegion.cpp
index b2e1738..be10c52 100644
--- a/cppcache/src/ThinClientRegion.cpp
+++ b/cppcache/src/ThinClientRegion.cpp
@@ -35,7 +35,6 @@
#include "RegionGlobalLocks.hpp"
#include "ReadWriteLock.hpp"
#include "RemoteQuery.hpp"
-#include "GeodeTypeIdsImpl.hpp"
#include "AutoDelete.hpp"
#include "UserAttributes.hpp"
#include "PutAllPartialResultServerException.hpp"
@@ -3339,9 +3338,9 @@ void ChunkedInterestResponse::handleChunk(const uint8_t* chunk,
uint32_t partLen;
if (TcrMessageHelper::readChunkPartHeader(
- m_msg, input, 0, GeodeTypeIds::CacheableArrayList,
+ m_msg, input, DSCode::FixedIDDefault, static_cast<int32_t>(DSCode::CacheableArrayList),
"ChunkedInterestResponse", partLen,
- isLastChunkWithSecurity) != TcrMessageHelper::OBJECT) {
+ isLastChunkWithSecurity) != TcrMessageHelper::ChunkObjectType::OBJECT) {
// encountered an exception part, so return without reading more
m_replyMsg.readSecureObjectPart(input, false, true,
isLastChunkWithSecurity);
@@ -3370,9 +3369,9 @@ void ChunkedKeySetResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
uint32_t partLen;
if (TcrMessageHelper::readChunkPartHeader(
- m_msg, input, 0, GeodeTypeIds::CacheableArrayList,
+ m_msg, input, DSCode::FixedIDDefault, static_cast<int32_t>(DSCode::CacheableArrayList),
"ChunkedKeySetResponse", partLen,
- isLastChunkWithSecurity) != TcrMessageHelper::OBJECT) {
+ isLastChunkWithSecurity) != TcrMessageHelper::ChunkObjectType::OBJECT) {
// encountered an exception part, so return without reading more
m_replyMsg.readSecureObjectPart(input, false, true,
isLastChunkWithSecurity);
@@ -3408,10 +3407,10 @@ void ChunkedQueryResponse::readObjectPartList(DataInput& input,
input.readObject(value);
m_queryResults->push_back(value);
} else {
- auto arrayType = input.read();
- if (arrayType == GeodeTypeIdsImpl::FixedIDByte) {
- arrayType = input.read();
- if (arrayType != GeodeTypeIdsImpl::CacheableObjectPartList) {
+ auto code = static_cast<DSCode>(input.read());
+ if (code == DSCode::FixedIDByte) {
+ auto arrayType = static_cast<DSFid>(input.read());
+ if (arrayType != DSFid::CacheableObjectPartList) {
LOGERROR(
"Query response got unhandled message format %d while "
"expecting struct set object part list; possible serialization "
@@ -3424,9 +3423,9 @@ void ChunkedQueryResponse::readObjectPartList(DataInput& input,
readObjectPartList(input, true);
} else {
LOGERROR(
- "Query response got unhandled message format %d while expecting "
+ "Query response got unhandled message format %" PRId8 "while expecting "
"struct set object part list; possible serialization mismatch",
- arrayType);
+ code);
throw MessageException(
"Query response got unhandled message format while expecting "
"struct set object part list; possible serialization mismatch");
@@ -3437,22 +3436,21 @@ void ChunkedQueryResponse::readObjectPartList(DataInput& input,
}
void ChunkedQueryResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
- uint8_t isLastChunkWithSecurity,
- const CacheImpl* cacheImpl) {
+ uint8_t isLastChunkWithSecurity,
+ const CacheImpl* cacheImpl) {
LOGDEBUG("ChunkedQueryResponse::handleChunk..");
auto input = cacheImpl->createDataInput(chunk, chunkLen, m_msg.getPool());
uint32_t partLen;
- TcrMessageHelper::ChunkObjectType objType;
- if ((objType = TcrMessageHelper::readChunkPartHeader(
- m_msg, input, GeodeTypeIdsImpl::FixedIDByte,
- static_cast<uint8_t>(GeodeTypeIdsImpl::CollectionTypeImpl),
- "ChunkedQueryResponse", partLen, isLastChunkWithSecurity)) ==
- TcrMessageHelper::EXCEPTION) {
+ TcrMessageHelper::ChunkObjectType objType = TcrMessageHelper::readChunkPartHeader(
+ m_msg, input, DSCode::FixedIDByte,
+ static_cast<int32_t>(DSFid::CollectionTypeImpl),
+ "ChunkedQueryResponse" , partLen, isLastChunkWithSecurity);
+ if (objType == TcrMessageHelper::ChunkObjectType::EXCEPTION) {
// encountered an exception part, so return without reading more
m_msg.readSecureObjectPart(input, false, true, isLastChunkWithSecurity);
return;
- } else if (objType == TcrMessageHelper::NULL_OBJECT) {
+ } else if (objType == TcrMessageHelper::ChunkObjectType::NULL_OBJECT) {
// special case for scalar result
partLen = input.readInt32();
input.read();
@@ -3514,9 +3512,9 @@ void ChunkedQueryResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
bool isResultSet = (m_structFieldNames.size() == 0);
- auto arrayType = input.read();
+ auto arrayType = static_cast<DSCode>(input.read());
- if (arrayType == GeodeTypeIds::CacheableObjectArray) {
+ if (arrayType == DSCode::CacheableObjectArray) {
int32_t arraySize = input.readArrayLength();
skipClass(input);
for (int32_t arrayItem = 0; arrayItem < arraySize; ++arrayItem) {
@@ -3534,9 +3532,9 @@ void ChunkedQueryResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
}
}
}
- } else if (arrayType == GeodeTypeIdsImpl::FixedIDByte) {
- arrayType = input.read();
- if (arrayType != GeodeTypeIdsImpl::CacheableObjectPartList) {
+ } else if (arrayType == DSCode::FixedIDByte) {
+ arrayType = static_cast<DSCode>(input.read());
+ if (static_cast<int32_t>(arrayType) != static_cast<int32_t>(DSFid::CacheableObjectPartList)) {
LOGERROR(
"Query response got unhandled message format %d while expecting "
"object part list; possible serialization mismatch",
@@ -3560,8 +3558,8 @@ void ChunkedQueryResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
}
void ChunkedQueryResponse::skipClass(DataInput& input) {
- uint8_t classByte = input.read();
- if (classByte == GeodeTypeIdsImpl::Class) {
+ auto classByte = static_cast<DSCode>(input.read());
+ if (classByte == DSCode::Class) {
// ignore string type id - assuming its a normal (under 64k) string.
input.read();
uint16_t classLen = input.readInt16();
@@ -3585,11 +3583,10 @@ void ChunkedFunctionExecutionResponse::handleChunk(
uint32_t partLen;
- int8_t arrayType;
- if ((arrayType = static_cast<TcrMessageHelper::ChunkObjectType>(
- TcrMessageHelper::readChunkPartHeader(
+ TcrMessageHelper::ChunkObjectType arrayType;
+ if ((arrayType = TcrMessageHelper::readChunkPartHeader(
m_msg, input, "ChunkedFunctionExecutionResponse", partLen,
- isLastChunkWithSecurity))) == TcrMessageHelper::EXCEPTION) {
+ isLastChunkWithSecurity)) == TcrMessageHelper::ChunkObjectType::EXCEPTION) {
// encountered an exception part, so return without reading more
m_msg.readSecureObjectPart(input, false, true, isLastChunkWithSecurity);
return;
@@ -3600,7 +3597,7 @@ void ChunkedFunctionExecutionResponse::handleChunk(
}
if (static_cast<TcrMessageHelper::ChunkObjectType>(arrayType) ==
- TcrMessageHelper::NULL_OBJECT) {
+ TcrMessageHelper::ChunkObjectType::NULL_OBJECT) {
LOGDEBUG("ChunkedFunctionExecutionResponse::handleChunk nullptr object");
// m_functionExecutionResults->push_back(nullptr);
m_msg.readSecureObjectPart(input, false, true, isLastChunkWithSecurity);
@@ -3615,7 +3612,7 @@ void ChunkedFunctionExecutionResponse::handleChunk(
// read a byte to determine whether to read exception part for sendException
// or read objects.
- uint8_t partType = input.read();
+ auto partType = static_cast<DSCode>(input.read());
bool isExceptionPart = false;
// See If partType is JavaSerializable
const int CHUNK_HDR_LEN = 5;
@@ -3625,7 +3622,7 @@ void ChunkedFunctionExecutionResponse::handleChunk(
"ChunkedFunctionExecutionResponse::handleChunk chunkLen = %d & partLen = "
"%d ",
chunkLen, partLen);
- if (partType == GeodeTypeIdsImpl::JavaSerializable) {
+ if (partType == DSCode::JavaSerializable) {
isExceptionPart = true;
// reset the input.
input.reset();
@@ -3654,7 +3651,7 @@ void ChunkedFunctionExecutionResponse::handleChunk(
// Since it is contained as a part of other results, read arrayType which
// is arrayList = 65.
- arrayType = input.read();
+ int8_t ignored = input.read();
// read and ignore its len which is 2
input.readArrayLength();
@@ -3719,9 +3716,9 @@ void ChunkedGetAllResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
uint32_t partLen;
if (TcrMessageHelper::readChunkPartHeader(
- m_msg, input, GeodeTypeIdsImpl::FixedIDByte,
- GeodeTypeIdsImpl::VersionedObjectPartList, "ChunkedGetAllResponse",
- partLen, isLastChunkWithSecurity) != TcrMessageHelper::OBJECT) {
+ m_msg, input, DSCode::FixedIDByte,
+ static_cast<int32_t>(DSFid::VersionedObjectPartList), "ChunkedGetAllResponse",
+ partLen, isLastChunkWithSecurity) != TcrMessageHelper::ChunkObjectType::OBJECT) {
// encountered an exception part, so return without reading more
m_msg.readSecureObjectPart(input, false, true, isLastChunkWithSecurity);
return;
@@ -3772,21 +3769,19 @@ void ChunkedPutAllResponse::handleChunk(const uint8_t* chunk, int32_t chunkLen,
auto input = cacheImpl->createDataInput(chunk, chunkLen, m_msg.getPool());
uint32_t partLen;
- int8_t chunkType;
- if ((chunkType = (TcrMessageHelper::ChunkObjectType)
- TcrMessageHelper::readChunkPartHeader(
- m_msg, input, GeodeTypeIdsImpl::FixedIDByte,
- GeodeTypeIdsImpl::VersionedObjectPartList,
+ TcrMessageHelper::ChunkObjectType chunkType;
+ if ((chunkType = TcrMessageHelper::readChunkPartHeader(
+ m_msg, input, DSCode::FixedIDByte,
+ static_cast<int32_t>(DSFid::VersionedObjectPartList),
"ChunkedPutAllResponse", partLen, isLastChunkWithSecurity)) ==
- TcrMessageHelper::NULL_OBJECT) {
+ TcrMessageHelper::ChunkObjectType::NULL_OBJECT) {
LOGDEBUG("ChunkedPutAllResponse::handleChunk nullptr object");
// No issues it will be empty in case of disabled caching.
m_msg.readSecureObjectPart(input, false, true, isLastChunkWithSecurity);
return;
}
- if (static_cast<TcrMessageHelper::ChunkObjectType>(chunkType) ==
- TcrMessageHelper::OBJECT) {
+ if (chunkType == TcrMessageHelper::ChunkObjectType::OBJECT) {
LOGDEBUG("ChunkedPutAllResponse::handleChunk object");
ACE_Recursive_Thread_Mutex responseLock;
auto vcObjPart = std::make_shared<VersionedCacheableObjectPartList>(
@@ -3832,21 +3827,19 @@ void ChunkedRemoveAllResponse::handleChunk(const uint8_t* chunk,
auto input = cacheImpl->createDataInput(chunk, chunkLen, m_msg.getPool());
uint32_t partLen;
- int8_t chunkType;
- if ((chunkType = (TcrMessageHelper::ChunkObjectType)
- TcrMessageHelper::readChunkPartHeader(
- m_msg, input, GeodeTypeIdsImpl::FixedIDByte,
- GeodeTypeIdsImpl::VersionedObjectPartList,
+ TcrMessageHelper::ChunkObjectType chunkType;
+ if ((chunkType = TcrMessageHelper::readChunkPartHeader(
+ m_msg, input, DSCode::FixedIDByte,
+ static_cast<int32_t>(DSFid::VersionedObjectPartList),
"ChunkedRemoveAllResponse", partLen, isLastChunkWithSecurity)) ==
- TcrMessageHelper::NULL_OBJECT) {
+ TcrMessageHelper::ChunkObjectType::NULL_OBJECT) {
LOGDEBUG("ChunkedRemoveAllResponse::handleChunk nullptr object");
// No issues it will be empty in case of disabled caching.
m_msg.readSecureObjectPart(input, false, true, isLastChunkWithSecurity);
return;
}
- if (static_cast<TcrMessageHelper::ChunkObjectType>(chunkType) ==
- TcrMessageHelper::OBJECT) {
+ if (chunkType == TcrMessageHelper::ChunkObjectType::OBJECT) {
LOGDEBUG("ChunkedRemoveAllResponse::handleChunk object");
ACE_Recursive_Thread_Mutex responseLock;
auto vcObjPart = std::make_shared<VersionedCacheableObjectPartList>(
diff --git a/cppcache/src/VersionTag.hpp b/cppcache/src/VersionTag.hpp
index f4889dd..97db64d 100644
--- a/cppcache/src/VersionTag.hpp
+++ b/cppcache/src/VersionTag.hpp
@@ -21,7 +21,6 @@
#define GEODE_VERSIONTAG_H_
#include <geode/Serializable.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include "MemberListForVersionStamp.hpp"
namespace apache {
@@ -62,8 +61,8 @@ class VersionTag : public DataSerializableFixedId {
void fromData(DataInput& input) override;
- virtual int32_t getDSFID() const override {
- return GeodeTypeIdsImpl::VersionTag;
+ DSFid getDSFID() const override {
+ return DSFid::VersionTag;
}
static std::shared_ptr<Serializable> createDeserializable(
diff --git a/cppcache/src/VersionedCacheableObjectPartList.cpp b/cppcache/src/VersionedCacheableObjectPartList.cpp
index 7315e87..4495830 100644
--- a/cppcache/src/VersionedCacheableObjectPartList.cpp
+++ b/cppcache/src/VersionedCacheableObjectPartList.cpp
@@ -16,7 +16,6 @@
*/
#include "VersionedCacheableObjectPartList.hpp"
#include <geode/ExceptionTypes.hpp>
-#include "GeodeTypeIdsImpl.hpp"
#include <geode/CacheableString.hpp>
#include "ThinClientRegion.hpp"
#include "CacheableToken.hpp"
diff --git a/cppcache/src/VersionedCacheableObjectPartList.hpp b/cppcache/src/VersionedCacheableObjectPartList.hpp
index fb07196..c3b8ad3 100644
--- a/cppcache/src/VersionedCacheableObjectPartList.hpp
+++ b/cppcache/src/VersionedCacheableObjectPartList.hpp
@@ -252,8 +252,8 @@ class VersionedCacheableObjectPartList : public CacheableObjectPartList {
void fromData(DataInput& input) override;
- int32_t getDSFID() const override {
- return GeodeTypeIdsImpl::VersionedObjectPartList;
+ DSFid getDSFID() const override {
+ return DSFid::VersionedObjectPartList;
}
};