You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2018/01/22 16:30:27 UTC
[geode-native] 01/01: GEODE-4282: Remove createKey/Value templates.
This is an automated email from the ASF dual-hosted git repository.
jbarrett pushed a commit to branch wip/createValue-2
in repository https://gitbox.apache.org/repos/asf/geode-native.git
commit c6b424670a13015d44ce594b7e5e175c259bbbd9
Author: Jacob Barrett <jb...@pivotal.io>
AuthorDate: Wed Jan 10 12:15:26 2018 -0800
GEODE-4282: Remove createKey/Value templates.
- Use Serializable::create to specialize for creating cacheable objects.
- Use CacheableKey::create to specialize for creating key objects.
---
cppcache/include/geode/Cacheable.hpp | 6 -
cppcache/include/geode/CacheableBuiltins.hpp | 20 ++-
cppcache/include/geode/CacheableDate.hpp | 10 +-
cppcache/include/geode/CacheableKey.hpp | 24 +++-
cppcache/include/geode/CacheableString.hpp | 83 ++++++++---
cppcache/include/geode/Region.hpp | 59 ++++----
cppcache/include/geode/Serializable.hpp | 38 +++--
cppcache/integration-test/ThinClientDistOps.hpp | 16 +--
cppcache/integration-test/ThinClientFailover.hpp | 6 +-
cppcache/integration-test/ThinClientFailover2.hpp | 6 +-
cppcache/integration-test/ThinClientFailover3.hpp | 6 +-
.../ThinClientFailoverInterest.hpp | 6 +-
.../ThinClientFailoverInterest2.hpp | 6 +-
.../ThinClientFailoverInterestAllWithCache.hpp | 6 +-
.../integration-test/ThinClientFailoverRegex.hpp | 6 +-
cppcache/integration-test/ThinClientHelper.hpp | 61 ++++----
.../integration-test/ThinClientInterestList.hpp | 6 +-
.../integration-test/ThinClientInterestList2.hpp | 6 +-
.../integration-test/ThinClientNotification.hpp | 6 +-
cppcache/integration-test/ThinClientPutAll.hpp | 6 +-
.../ThinClientPutAllWithCallBack.hpp | 6 +-
cppcache/integration-test/ThinClientRegex.hpp | 6 +-
cppcache/integration-test/ThinClientRegex2.hpp | 6 +-
cppcache/integration-test/ThinClientRegex3.hpp | 6 +-
cppcache/integration-test/ThinClientSSL.hpp | 6 +-
.../integration-test/ThinClientSSLWithPassword.hpp | 6 +-
cppcache/integration-test/ThinClientTXFailover.hpp | 6 +-
.../integration-test/ThinClientTransactions.hpp | 38 ++---
.../integration-test/ThinClientTransactionsXA.hpp | 38 ++---
cppcache/integration-test/testCacheless.cpp | 10 +-
.../testThinClientAfterRegionLive.cpp | 2 +-
.../integration-test/testThinClientCqDelta.cpp | 2 +-
.../testThinClientDeltaWithNotification.cpp | 12 +-
.../testThinClientDisconnectionListioner.cpp | 2 +-
.../integration-test/testThinClientHADistOps.cpp | 6 +-
.../testThinClientHAEventIDMap.cpp | 8 +-
.../integration-test/testThinClientHAFailover.cpp | 6 +-
.../testThinClientHAFailoverRegex.cpp | 6 +-
.../testThinClientHAMixedRedundancy.cpp | 6 +-
.../testThinClientHAPeriodicAck.cpp | 8 +-
.../testThinClientIntResPolKeysInv.cpp | 6 +-
...ThinClientNotificationWithDeltaWithoutcache.cpp | 4 +-
.../testThinClientPdxDeltaWithNotification.cpp | 12 +-
.../testThinClientPoolRedundancy.cpp | 2 +-
.../testThinClientPutWithDelta.cpp | 4 +-
.../integration-test/testThinClientRemoveOps.cpp | 10 +-
.../testThinClientSSLAuthCorrupt.cpp | 2 +-
.../integration-test/testThinClientSSLAuthFail.cpp | 2 +-
.../testThinClientSSLAuthUntrusted.cpp | 2 +-
.../testThinClientSSLWithSecurityAuthz.cpp | 2 +-
.../testThinClientSecurityAuthentication.cpp | 48 +++----
.../testThinClientSecurityAuthorization.cpp | 2 +-
.../testThinClientSecurityAuthorizationMU.cpp | 2 +-
.../testThinClientWriterException.cpp | 2 +-
cppcache/src/CacheableBuiltins.cpp | 1 +
cppcache/src/CacheableString.cpp | 1 -
cppcache/src/ProxyRegion.hpp | 57 ++++----
cppcache/test/CacheableKeyCreateTests.cpp | 158 +++++++++++++++++++++
cppcache/test/SerializableCreateTests.cpp | 157 ++++++++++++++++++++
cppcache/test/gtest_extensions.h | 2 +-
60 files changed, 708 insertions(+), 337 deletions(-)
diff --git a/cppcache/include/geode/Cacheable.hpp b/cppcache/include/geode/Cacheable.hpp
index 132593b..c465bb7 100644
--- a/cppcache/include/geode/Cacheable.hpp
+++ b/cppcache/include/geode/Cacheable.hpp
@@ -34,12 +34,6 @@ namespace client {
typedef Serializable Cacheable;
-template <typename TVALUE>
-inline std::shared_ptr<Cacheable> createValue(
- const std::shared_ptr<TVALUE>& value) {
- return std::dynamic_pointer_cast<Cacheable>(value);
-}
-
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/include/geode/CacheableBuiltins.hpp b/cppcache/include/geode/CacheableBuiltins.hpp
index 325775c..f189578 100644
--- a/cppcache/include/geode/CacheableBuiltins.hpp
+++ b/cppcache/include/geode/CacheableBuiltins.hpp
@@ -53,6 +53,8 @@ class CacheableKeyType : public CacheableKey {
inline CacheableKeyType(const TObj value) : m_value(value) {}
public:
+ typedef TObj value_type;
+
/** Gets the contained value. */
inline TObj value() const { return m_value; }
@@ -199,6 +201,8 @@ class CacheableArrayType : public Cacheable {
}
public:
+ typedef TObj value_type;
+
/** Get the underlying array. */
inline const TObj* value() const { return m_value; }
@@ -342,10 +346,12 @@ class CacheableContainerType : public Cacheable, public TBase {
return std::make_shared<k>(value); \
} \
}; \
- inline std::shared_ptr<CacheableKey> createKey(const p value) { \
+ template <> \
+ inline std::shared_ptr<CacheableKey> CacheableKey::create(p value) { \
return k::create(value); \
} \
- inline std::shared_ptr<Cacheable> createValue(const p value) { \
+ template <> \
+ inline std::shared_ptr<Cacheable> Serializable::create(p value) { \
return k::create(value); \
}
@@ -632,16 +638,6 @@ _GEODE_CACHEABLE_CONTAINER_TYPE_DEF_(HashSetOfCacheableKey,
*/
_GEODE_CACHEABLE_CONTAINER_TYPE_(HashSetOfCacheableKey, CacheableLinkedHashSet);
-template <>
-inline std::shared_ptr<CacheableKey> CacheableKey::create(int32_t value) {
- return CacheableInt32::create(value);
-}
-
-template <>
-inline std::shared_ptr<Serializable> Serializable::create(int32_t value) {
- return CacheableInt32::create(value);
-}
-
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/include/geode/CacheableDate.hpp b/cppcache/include/geode/CacheableDate.hpp
index f19dac3..b1b7b99 100644
--- a/cppcache/include/geode/CacheableDate.hpp
+++ b/cppcache/include/geode/CacheableDate.hpp
@@ -152,13 +152,15 @@ class _GEODE_EXPORT CacheableDate : public CacheableKey {
_GEODE_FRIEND_STD_SHARED_PTR(CacheableDate)
};
-inline std::shared_ptr<CacheableKey> createKey(
- const CacheableDate::time_point& value) {
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(
+ CacheableDate::time_point value) {
return CacheableDate::create(value);
}
-inline std::shared_ptr<Cacheable> createValue(
- const CacheableDate::time_point& value) {
+template <>
+inline std::shared_ptr<Serializable> Serializable::create(
+ CacheableDate::time_point value) {
return CacheableDate::create(value);
}
diff --git a/cppcache/include/geode/CacheableKey.hpp b/cppcache/include/geode/CacheableKey.hpp
index 8aac592..30c06ee 100644
--- a/cppcache/include/geode/CacheableKey.hpp
+++ b/cppcache/include/geode/CacheableKey.hpp
@@ -36,6 +36,8 @@ namespace apache {
namespace geode {
namespace client {
+class CacheableKey;
+
/** Represents a cacheable key */
class _GEODE_EXPORT CacheableKey : public Cacheable {
protected:
@@ -57,13 +59,17 @@ class _GEODE_EXPORT CacheableKey : public Cacheable {
/**
* Factory method that creates the key type that matches the type of value.
*
- * For customer defined derivations of CacheableKey, the method
- * apache::geode::client::createKey may be overloaded. For pointer types (e.g.
- * char*)
- * the method apache::geode::client::createKeyArr may be overloaded.
+ * For user defined derivations of CacheableKey, the method
+ * apache::geode::client::CacheableKey::create may be overloaded.
*/
- template <class PRIM>
- inline static std::shared_ptr<CacheableKey> create(const PRIM value);
+ template <class _T>
+ static std::shared_ptr<CacheableKey> create(_T value);
+
+ template <class _T>
+ inline static std::shared_ptr<CacheableKey> create(
+ const std::shared_ptr<_T>& value) {
+ return value;
+ }
struct hash {
inline std::size_t operator()(const CacheableKey& s) const {
@@ -103,6 +109,12 @@ class _GEODE_EXPORT CacheableKey : public Cacheable {
void operator=(const CacheableKey& other);
};
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(
+ const std::shared_ptr<CacheableKey>& value) {
+ return value;
+}
+
using namespace apache::geode::client::internal;
typedef std::unordered_map<std::shared_ptr<CacheableKey>,
diff --git a/cppcache/include/geode/CacheableString.hpp b/cppcache/include/geode/CacheableString.hpp
index b530f46..4512b2f 100644
--- a/cppcache/include/geode/CacheableString.hpp
+++ b/cppcache/include/geode/CacheableString.hpp
@@ -141,7 +141,6 @@ class _GEODE_EXPORT CacheableString : public CacheableKey {
virtual size_t objectSize() const override;
protected:
-
/** Default constructor. */
inline CacheableString(int8_t type = GeodeTypeIds::CacheableASCIIString)
: m_str(), m_type(type), m_hashcode(0) {}
@@ -167,46 +166,86 @@ class _GEODE_EXPORT CacheableString : public CacheableKey {
static bool isAscii(const std::string& str);
};
-inline std::shared_ptr<CacheableKey> createKeyArr(const std::string& value) {
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(const char* value) {
return CacheableString::create(value);
}
-inline std::shared_ptr<CacheableKey> createKeyArr(std::string&& value) {
- return CacheableString::create(std::move(value));
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(const char* value) {
+ return CacheableString::create(value);
}
-inline std::shared_ptr<Cacheable> createValueArr(const std::string& value) {
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(char* value) {
return CacheableString::create(value);
}
-inline std::shared_ptr<Cacheable> createValueArr(std::string&& value) {
- return CacheableString::create(std::move(value));
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(char* value) {
+ return CacheableString::create(value);
+}
+
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(
+ const char16_t* value) {
+ return CacheableString::create(value);
}
-template <typename TVALUE>
-inline std::shared_ptr<Cacheable> createValue(const TVALUE* value) {
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(const char16_t* value) {
return CacheableString::create(value);
}
-template <class TKEY>
-inline std::shared_ptr<CacheableKey> createKey(
- const std::shared_ptr<TKEY>& value) {
- return std::shared_ptr<CacheableKey>(value);
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(char16_t* value) {
+ return CacheableString::create(value);
}
-template <typename TKEY>
-inline std::shared_ptr<CacheableKey> createKey(const TKEY* value) {
- return createKeyArr(value);
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(char16_t* value) {
+ return CacheableString::create(value);
}
-template <class PRIM>
-inline std::shared_ptr<CacheableKey> CacheableKey::create(const PRIM value) {
- return createKey(value);
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(
+ const char32_t* value) {
+ return CacheableString::create(value);
}
-template <class PRIM>
-inline std::shared_ptr<Serializable> Serializable::create(const PRIM value) {
- return createKey(value);
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(const char32_t* value) {
+ return CacheableString::create(value);
+}
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(char32_t* value) {
+ return CacheableString::create(value);
+}
+
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(char32_t* value) {
+ return CacheableString::create(value);
+}
+
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(
+ const wchar_t* value) {
+ return CacheableString::create(value);
+}
+
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(const wchar_t* value) {
+ return CacheableString::create(value);
+}
+
+template <>
+inline std::shared_ptr<CacheableKey> CacheableKey::create(wchar_t* value) {
+ return CacheableString::create(value);
+}
+
+template <>
+inline std::shared_ptr<Cacheable> Serializable::create(wchar_t* value) {
+ return CacheableString::create(value);
}
} // namespace client
diff --git a/cppcache/include/geode/Region.hpp b/cppcache/include/geode/Region.hpp
index e026de6..cf3bff1 100644
--- a/cppcache/include/geode/Region.hpp
+++ b/cppcache/include/geode/Region.hpp
@@ -270,7 +270,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
/** Convenience method allowing key to be a const char* */
template <class KEYTYPE>
inline std::shared_ptr<RegionEntry> getEntry(const KEYTYPE& key) {
- return getEntry(createKey(key));
+ return getEntry(CacheableKey::create(key));
}
/** Returns the value associated with the specified key, passing the callback
@@ -323,7 +323,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline std::shared_ptr<Cacheable> get(
const KEYTYPE& key,
const std::shared_ptr<Serializable>& callbackArg = nullptr) {
- return get(createKey(key), callbackArg);
+ return get(CacheableKey::create(key), callbackArg);
}
/** Places a new value into an entry in this region with the specified key,
@@ -380,14 +380,14 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE, class VALUETYPE>
inline void put(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- put(createKey(key), createValue(value), arg);
+ put(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
template <class KEYTYPE>
inline void put(const KEYTYPE& key, const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- put(createKey(key), value, arg);
+ put(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -395,7 +395,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void put(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- put(key, createValue(value), arg);
+ put(key, Serializable::create(value), arg);
}
/**
@@ -454,7 +454,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE, class VALUETYPE>
inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localPut(createKey(key), createValue(value), arg);
+ localPut(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -462,7 +462,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void localPut(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localPut(createKey(key), value, arg);
+ localPut(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -470,7 +470,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void localPut(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localPut(key, createValue(value), arg);
+ localPut(key, Serializable::create(value), arg);
}
/** Creates a new entry in this region with the specified key and value,
@@ -528,7 +528,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE, class VALUETYPE>
inline void create(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- create(createKey(key), createValue(value), arg);
+ create(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -536,7 +536,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void create(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- create(createKey(key), value, arg);
+ create(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -544,7 +544,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void create(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- create(key, createValue(value), arg);
+ create(key, Serializable::create(value), arg);
}
/** Creates a new entry in this region with the specified key and value
@@ -581,7 +581,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE, class VALUETYPE>
inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localCreate(createKey(key), createValue(value), arg);
+ localCreate(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -589,7 +589,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void localCreate(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localCreate(createKey(key), value, arg);
+ localCreate(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -597,7 +597,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline void localCreate(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localCreate(key, createValue(value), arg);
+ localCreate(key, Serializable::create(value), arg);
}
/** Invalidates the entry with the specified key,
@@ -630,7 +630,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE>
inline void invalidate(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- invalidate(createKey(key), arg);
+ invalidate(CacheableKey::create(key), arg);
}
/** Invalidates the entry with the specified key in the local cache only,
@@ -661,7 +661,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE>
inline void localInvalidate(
const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
- localInvalidate(createKey(key), arg);
+ localInvalidate(CacheableKey::create(key), arg);
}
/** Destroys the entry with the specified key, and provides a user-defined
@@ -716,7 +716,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE>
inline void destroy(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- destroy(createKey(key), arg);
+ destroy(CacheableKey::create(key), arg);
}
/** Destroys the entry with the specified key in the local cache only,
@@ -751,7 +751,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE>
inline void localDestroy(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localDestroy(createKey(key), arg);
+ localDestroy(CacheableKey::create(key), arg);
}
/** Removes the entry with the specified key, value and provides a
@@ -811,7 +811,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE, class VALUETYPE>
inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return remove(createKey(key), createValue(value), arg);
+ return remove(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -819,7 +819,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline bool remove(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return remove(createKey(key), value, arg);
+ return remove(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -827,7 +827,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline bool remove(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return remove(key, createValue(value), arg);
+ return remove(key, Serializable::create(value), arg);
}
bool remove(const std::shared_ptr<CacheableKey>& key) { return removeEx(key); }
@@ -835,7 +835,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
/** Convenience method allowing both key and value to be a const char* */
template <class KEYTYPE>
inline bool remove(const KEYTYPE& key) {
- return remove(createKey(key));
+ return remove(CacheableKey::create(key));
}
/** Removes the entry with the specified key and provides a user-defined
@@ -892,7 +892,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE>
inline bool removeEx(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return removeEx(createKey(key), arg);
+ return removeEx(CacheableKey::create(key), arg);
}
/** Removes the entry with the specified key and value in the local cache
@@ -931,7 +931,8 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE, class VALUETYPE>
inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemove(createKey(key), createValue(value), arg);
+ return localRemove(CacheableKey::create(key), Serializable::create(value),
+ arg);
}
/** Convenience method allowing key to be a const char* */
@@ -939,7 +940,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline bool localRemove(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemove(createKey(key), value, arg);
+ return localRemove(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -947,7 +948,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
inline bool localRemove(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemove(key, createValue(value), arg);
+ return localRemove(key, Serializable::create(value), arg);
}
/** Removes the entry with the specified key in the local cache only,
@@ -984,7 +985,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
template <class KEYTYPE>
inline bool localRemoveEx(
const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemoveEx(createKey(key), arg);
+ return localRemoveEx(CacheableKey::create(key), arg);
}
/**
@@ -1051,7 +1052,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
*/
template <class KEYTYPE>
inline bool containsValueForKey(const KEYTYPE& key) const {
- return containsValueForKey(createKey(key));
+ return containsValueForKey(CacheableKey::create(key));
}
/**
@@ -1089,7 +1090,7 @@ class _GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
*/
template <class KEYTYPE>
inline bool containsKey(const KEYTYPE& key) const {
- return containsKey(createKey(key));
+ return containsKey(CacheableKey::create(key));
}
/**
diff --git a/cppcache/include/geode/Serializable.hpp b/cppcache/include/geode/Serializable.hpp
index e670ef7..8650a56 100644
--- a/cppcache/include/geode/Serializable.hpp
+++ b/cppcache/include/geode/Serializable.hpp
@@ -26,6 +26,7 @@
#include <functional>
#include <memory>
+#include <string>
#include "internal/geode_globals.hpp"
@@ -38,7 +39,6 @@ class DataInput;
class Cache;
class PdxSerializable;
class Serializable;
-class CacheableString;
typedef void (*CliCallbackMethod)(Cache &cache);
@@ -47,27 +47,27 @@ typedef void (*CliCallbackMethod)(Cache &cache);
* will typically be initialized immediately after creation by a call to
* fromData().
*/
-using TypeFactoryMethod = std::function<Serializable *()>;
+using TypeFactoryMethod = std::function<Serializable*()>;
+
+typedef PdxSerializable* (*TypeFactoryMethodPdx)();
-typedef PdxSerializable *(*TypeFactoryMethodPdx)();
/**
* @class Serializable Serializable.hpp
* This abstract base class is the superclass of all user objects
* in the cache that can be serialized.
*/
-
class _GEODE_EXPORT Serializable
: public std::enable_shared_from_this<Serializable> {
public:
/**
*@brief serialize this object
**/
- virtual void toData(DataOutput &output) const = 0;
+ virtual void toData(DataOutput& output) const = 0;
/**
*@brief deserialize this object.
**/
- virtual void fromData(DataInput &input) = 0;
+ virtual void fromData(DataInput& input) = 0;
/**
*@brief Return the classId of the instance being serialized.
@@ -118,13 +118,17 @@ class _GEODE_EXPORT Serializable
/** Factory method that creates the Serializable object that matches the type
* of value.
- * For customer defined derivations of Serializable, the method
- * apache::geode::client::createValue
- * may be overloaded. For pointer types (e.g. char*) the method
- * apache::geode::client::createValueArr may be overloaded.
+ * For user defined derivations of Serializable, the method
+ * apache::geode::client::Serializable::create may be overloaded.
*/
- template <class PRIM>
- inline static std::shared_ptr<Serializable> create(const PRIM value);
+ template <class _T>
+ static std::shared_ptr<Serializable> create(_T value);
+
+ template <class _T>
+ inline static std::shared_ptr<Serializable> create(
+ const std::shared_ptr<_T>& value) {
+ return value;
+ }
/**
* @brief destructor
@@ -133,10 +137,16 @@ class _GEODE_EXPORT Serializable
protected:
Serializable() = default;
- Serializable(const Serializable &other) = default;
- Serializable &operator=(const Serializable &other) = default;
+ Serializable(const Serializable& other) = default;
+ Serializable& operator=(const Serializable& other) = default;
};
+template <>
+inline std::shared_ptr<Serializable> Serializable::create(
+ const std::shared_ptr<Serializable>& value) {
+ return value;
+}
+
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/integration-test/ThinClientDistOps.hpp b/cppcache/integration-test/ThinClientDistOps.hpp
index 73ae799..b4eca6e 100644
--- a/cppcache/integration-test/ThinClientDistOps.hpp
+++ b/cppcache/integration-test/ThinClientDistOps.hpp
@@ -118,7 +118,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (noKey == false) { // need to find the key!
@@ -249,7 +249,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -404,7 +404,7 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
sprintf(message, "Creating entry -- key: %s value: %s in region %s\n", key,
value, name);
LOG(message);
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
regPtr->create(keyPtr, valPtr);
@@ -427,7 +427,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -752,7 +752,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool)
false);
auto reg = getHelper()->getRegion(regionNames[2]);
LOG("REGION Created with Caching Enabled false");
- auto keyPtr = createKey(CREATE_TWICE_KEY);
+ auto keyPtr = CacheableKey::create(CREATE_TWICE_KEY);
auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
try {
reg->create(keyPtr, valPtr);
@@ -780,13 +780,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool_Sticky)
false, false);
auto reg = getHelper()->getRegion(regionNames[2]);
LOG("REGION Created with Caching Enabled false");
- auto keyPtr = createKey(CREATE_TWICE_KEY);
+ auto keyPtr = CacheableKey::create(CREATE_TWICE_KEY);
auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
auto reg0 = getHelper()->getRegion(regionNames[0]);
auto reg1 = getHelper()->getRegion(regionNames[1]);
- reg0->localInvalidate(createKey(keys[1]));
- reg1->localInvalidate(createKey(keys[3]));
+ reg0->localInvalidate(CacheableKey::create(keys[1]));
+ reg1->localInvalidate(CacheableKey::create(keys[3]));
auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
ASSERT(pool != nullptr, "Pool Should have been found");
doNetsearch(regionNames[0], keys[1], nvals[1]);
diff --git a/cppcache/integration-test/ThinClientFailover.hpp b/cppcache/integration-test/ThinClientFailover.hpp
index 1ebb9a6..27376cd 100644
--- a/cppcache/integration-test/ThinClientFailover.hpp
+++ b/cppcache/integration-test/ThinClientFailover.hpp
@@ -87,7 +87,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
LOG("_verifyEntry =================");
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (noKey == false) { // need to find the key!
ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -194,7 +194,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -219,7 +219,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientFailover2.hpp b/cppcache/integration-test/ThinClientFailover2.hpp
index ff1de68..ea1c2f8 100644
--- a/cppcache/integration-test/ThinClientFailover2.hpp
+++ b/cppcache/integration-test/ThinClientFailover2.hpp
@@ -89,7 +89,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (noKey == false) { // need to find the key!
ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -201,7 +201,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -226,7 +226,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientFailover3.hpp b/cppcache/integration-test/ThinClientFailover3.hpp
index 0f83c85..5ca04be 100644
--- a/cppcache/integration-test/ThinClientFailover3.hpp
+++ b/cppcache/integration-test/ThinClientFailover3.hpp
@@ -87,7 +87,7 @@ void _verifyEntry(const char *name, const char *key, const char *val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (noKey == false) { // need to find the key!
ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -168,7 +168,7 @@ void createEntry(const char *name, const char *key, const char *value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -193,7 +193,7 @@ void updateEntry(const char *name, const char *key, const char *value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientFailoverInterest.hpp b/cppcache/integration-test/ThinClientFailoverInterest.hpp
index e46b332..1abc4d0 100644
--- a/cppcache/integration-test/ThinClientFailoverInterest.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterest.hpp
@@ -88,7 +88,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -207,7 +207,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -232,7 +232,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientFailoverInterest2.hpp b/cppcache/integration-test/ThinClientFailoverInterest2.hpp
index d0efae4..bd52903 100644
--- a/cppcache/integration-test/ThinClientFailoverInterest2.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterest2.hpp
@@ -87,7 +87,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -206,7 +206,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -231,7 +231,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp b/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
index 80ec2d4..7429b07 100644
--- a/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
+++ b/cppcache/integration-test/ThinClientFailoverInterestAllWithCache.hpp
@@ -92,7 +92,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -197,7 +197,7 @@ void createEntry(const char* name, const char* key, const char* value) {
LOGINFO("Creating entry -- key: %s value: %s in region %s", key, value,
name);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -221,7 +221,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
LOGINFO("Updating entry -- key: %s value: %s in region %s", key, value,
name);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientFailoverRegex.hpp b/cppcache/integration-test/ThinClientFailoverRegex.hpp
index e6080c2..22faea9 100644
--- a/cppcache/integration-test/ThinClientFailoverRegex.hpp
+++ b/cppcache/integration-test/ThinClientFailoverRegex.hpp
@@ -88,7 +88,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -207,7 +207,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -232,7 +232,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientHelper.hpp b/cppcache/integration-test/ThinClientHelper.hpp
index 844be06..9c9b8ea 100644
--- a/cppcache/integration-test/ThinClientHelper.hpp
+++ b/cppcache/integration-test/ThinClientHelper.hpp
@@ -181,7 +181,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (noKey == false) { // need to find the key!
ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -288,7 +288,7 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -498,23 +498,23 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
- auto valPtr = CacheableString::create(value);
+ auto keyPtr = CacheableKey::create(key);
+ auto valPtr = CacheableString::create(value);
- auto regPtr = getHelper()->getRegion(name);
- ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
- ASSERT(!regPtr->containsKey(keyPtr),
- "Key should not have been found in region.");
- ASSERT(!regPtr->containsValueForKey(keyPtr),
- "Value should not have been found in region.");
+ ASSERT(!regPtr->containsKey(keyPtr),
+ "Key should not have been found in region.");
+ ASSERT(!regPtr->containsValueForKey(keyPtr),
+ "Value should not have been found in region.");
- // regPtr->create( keyPtr, valPtr );
- regPtr->put(keyPtr, valPtr);
- LOG("Created entry.");
+ // regPtr->create( keyPtr, valPtr );
+ regPtr->put(keyPtr, valPtr);
+ LOG("Created entry.");
- verifyEntry(name, key, value);
- LOG("Entry created.");
+ verifyEntry(name, key, value);
+ LOG("Entry created.");
}
void updateEntry(const char* name, const char* key, const char* value,
@@ -524,14 +524,15 @@ void updateEntry(const char* name, const char* key, const char* value,
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
- auto valPtr = CacheableString::create(value);
+ auto keyPtr = CacheableKey::create(key);
+ auto valPtr = CacheableString::create(value);
- auto regPtr = getHelper()->getRegion(name);
- ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
- if (checkKey) {
- ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
+ if (checkKey) {
+ ASSERT(regPtr->containsKey(keyPtr),
+ "Key should have been found in region.");
}
if (checkVal) {
ASSERT(regPtr->containsValueForKey(keyPtr),
@@ -592,17 +593,17 @@ void createIntEntry(const char* name, const char* key, const int value,
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
- auto valPtr = CacheableInt32::create(value);
+ auto keyPtr = CacheableKey::create(key);
+ auto valPtr = CacheableInt32::create(value);
- auto regPtr = getHelper()->getRegion(name);
- ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
- if (onlyCreate) {
- ASSERT(!regPtr->containsKey(keyPtr),
- "Key should not have been found in region.");
- ASSERT(!regPtr->containsValueForKey(keyPtr),
- "Value should not have been found in region.");
+ if (onlyCreate) {
+ ASSERT(!regPtr->containsKey(keyPtr),
+ "Key should not have been found in region.");
+ ASSERT(!regPtr->containsValueForKey(keyPtr),
+ "Value should not have been found in region.");
}
regPtr->put(keyPtr, valPtr);
diff --git a/cppcache/integration-test/ThinClientInterestList.hpp b/cppcache/integration-test/ThinClientInterestList.hpp
index 87c5189..7cd8792 100644
--- a/cppcache/integration-test/ThinClientInterestList.hpp
+++ b/cppcache/integration-test/ThinClientInterestList.hpp
@@ -86,7 +86,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -214,7 +214,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -242,7 +242,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientInterestList2.hpp b/cppcache/integration-test/ThinClientInterestList2.hpp
index c91cb84..cf98d0d 100644
--- a/cppcache/integration-test/ThinClientInterestList2.hpp
+++ b/cppcache/integration-test/ThinClientInterestList2.hpp
@@ -86,7 +86,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -214,7 +214,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -242,7 +242,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientNotification.hpp b/cppcache/integration-test/ThinClientNotification.hpp
index bfce4db..ebf14a8 100644
--- a/cppcache/integration-test/ThinClientNotification.hpp
+++ b/cppcache/integration-test/ThinClientNotification.hpp
@@ -82,7 +82,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
LOG("Before contains key");
// if the region is no ack, then we may need to wait...
@@ -188,7 +188,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -213,7 +213,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientPutAll.hpp b/cppcache/integration-test/ThinClientPutAll.hpp
index 5ee16e6..b04566a 100644
--- a/cppcache/integration-test/ThinClientPutAll.hpp
+++ b/cppcache/integration-test/ThinClientPutAll.hpp
@@ -94,7 +94,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -246,7 +246,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -274,7 +274,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp b/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
index ff42363..82f576c 100644
--- a/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
+++ b/cppcache/integration-test/ThinClientPutAllWithCallBack.hpp
@@ -93,7 +93,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -245,7 +245,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -273,7 +273,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientRegex.hpp b/cppcache/integration-test/ThinClientRegex.hpp
index 9e74e9d..ccf604c 100644
--- a/cppcache/integration-test/ThinClientRegex.hpp
+++ b/cppcache/integration-test/ThinClientRegex.hpp
@@ -85,7 +85,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -213,7 +213,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -241,7 +241,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientRegex2.hpp b/cppcache/integration-test/ThinClientRegex2.hpp
index 4326a67..85c5f46 100644
--- a/cppcache/integration-test/ThinClientRegex2.hpp
+++ b/cppcache/integration-test/ThinClientRegex2.hpp
@@ -86,7 +86,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -224,7 +224,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -252,7 +252,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientRegex3.hpp b/cppcache/integration-test/ThinClientRegex3.hpp
index a5d72c2..1d39589 100644
--- a/cppcache/integration-test/ThinClientRegex3.hpp
+++ b/cppcache/integration-test/ThinClientRegex3.hpp
@@ -86,7 +86,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -224,7 +224,7 @@ void createEntry(const char* name, const char* key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -252,7 +252,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientSSL.hpp b/cppcache/integration-test/ThinClientSSL.hpp
index bd6e3a7..9cdddeb 100644
--- a/cppcache/integration-test/ThinClientSSL.hpp
+++ b/cppcache/integration-test/ThinClientSSL.hpp
@@ -91,7 +91,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
LOG("Before contains key");
// if the region is no ack, then we may need to wait...
@@ -197,7 +197,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -222,7 +222,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientSSLWithPassword.hpp b/cppcache/integration-test/ThinClientSSLWithPassword.hpp
index b202c6d..9c4e041 100644
--- a/cppcache/integration-test/ThinClientSSLWithPassword.hpp
+++ b/cppcache/integration-test/ThinClientSSLWithPassword.hpp
@@ -93,7 +93,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
LOG("Before contains key");
// if the region is no ack, then we may need to wait...
@@ -211,7 +211,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -236,7 +236,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientTXFailover.hpp b/cppcache/integration-test/ThinClientTXFailover.hpp
index f268b0d..1c2807c 100644
--- a/cppcache/integration-test/ThinClientTXFailover.hpp
+++ b/cppcache/integration-test/ThinClientTXFailover.hpp
@@ -87,7 +87,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (noKey == false) { // need to find the key!
ASSERT(regPtr->containsKey(keyPtr), "Key not found in region.");
@@ -194,7 +194,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -219,7 +219,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/ThinClientTransactions.hpp b/cppcache/integration-test/ThinClientTransactions.hpp
index 342d4c2..5618780 100644
--- a/cppcache/integration-test/ThinClientTransactions.hpp
+++ b/cppcache/integration-test/ThinClientTransactions.hpp
@@ -108,7 +108,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (noKey == false) { // need to find the key!
@@ -239,7 +239,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -263,7 +263,7 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
sprintf(message, "Creating entry -- key: %s value: %s in region %s\n", key,
value, name);
LOG(message);
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
regPtr->create(keyPtr, valPtr);
@@ -286,7 +286,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -467,9 +467,9 @@ class ResumeTransactionThread : public ACE_Task_Base {
THREADERRORCHECK(regPtr0 != nullptr,
"In ResumeTransactionThread - Region not found.");
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
- auto keyPtr6 = createKey(keys[6]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
+ auto keyPtr6 = CacheableKey::create(keys[6]);
auto regPtr1 = getHelper()->getRegion(regionNames[1]);
THREADERRORCHECK(regPtr1 != nullptr,
@@ -602,9 +602,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeCommit)
ASSERT(regPtr0 != nullptr, "In SuspendResumeCommit - Region not found.");
auto regPtr1 = getHelper()->getRegion(regionNames[1]);
ASSERT(regPtr1 != nullptr, "In SuspendResumeCommit - Region not found.");
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
- auto keyPtr6 = createKey(keys[6]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
+ auto keyPtr6 = CacheableKey::create(keys[6]);
txManager->begin();
createEntry(regionNames[0], keys[4], vals[4]);
@@ -674,8 +674,8 @@ END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, SuspendTimeOut)
{
auto txManager = getHelper()->getCache()->getCacheTransactionManager();
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
auto regPtr0 = getHelper()->getRegion(regionNames[0]);
ASSERT(regPtr0 != nullptr, "In SuspendTimeOut - Region not found.");
@@ -714,9 +714,9 @@ END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeRollback)
{
auto txManager = getHelper()->getCache()->getCacheTransactionManager();
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
- auto keyPtr6 = createKey(keys[6]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
+ auto keyPtr6 = CacheableKey::create(keys[6]);
auto regPtr0 = getHelper()->getRegion(regionNames[0]);
ASSERT(regPtr0 != nullptr, "In SuspendResumeRollback - Region not found.");
@@ -1033,7 +1033,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1KeyThriceWithoutSticky)
false);
auto reg = getHelper()->getRegion(regionNames[2]);
LOG("REGION Created with Caching Enabled false");
- auto keyPtr = createKey(CREATE_TWICE_KEY);
+ auto keyPtr = CacheableKey::create(CREATE_TWICE_KEY);
auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
try {
reg->create(keyPtr, valPtr);
@@ -1061,13 +1061,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, CreateClient1KeyThriceWithSticky)
false, false);
auto reg = getHelper()->getRegion(regionNames[2]);
LOG("REGION Created with Caching Enabled false");
- auto keyPtr = createKey(CREATE_TWICE_KEY);
+ auto keyPtr = CacheableKey::create(CREATE_TWICE_KEY);
auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
auto reg0 = getHelper()->getRegion(regionNames[0]);
auto reg1 = getHelper()->getRegion(regionNames[1]);
- reg0->localInvalidate(createKey(keys[1]));
- reg1->localInvalidate(createKey(keys[3]));
+ reg0->localInvalidate(CacheableKey::create(keys[1]));
+ reg1->localInvalidate(CacheableKey::create(keys[3]));
auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
ASSERT(pool != nullptr, "Pool Should have been found");
doNetsearch(regionNames[0], keys[1], nvals[1]);
diff --git a/cppcache/integration-test/ThinClientTransactionsXA.hpp b/cppcache/integration-test/ThinClientTransactionsXA.hpp
index 546b37d..3e8cb63 100644
--- a/cppcache/integration-test/ThinClientTransactionsXA.hpp
+++ b/cppcache/integration-test/ThinClientTransactionsXA.hpp
@@ -106,7 +106,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (noKey == false) { // need to find the key!
@@ -237,7 +237,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -261,7 +261,7 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
sprintf(message, "Creating entry -- key: %s value: %s in region %s\n", key,
value, name);
LOG(message);
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
regPtr->create(keyPtr, valPtr);
@@ -284,7 +284,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -467,9 +467,9 @@ class ResumeTransactionThread : public ACE_Task_Base {
THREADERRORCHECK(regPtr0 != nullptr,
"In ResumeTransactionThread - Region not found.");
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
- auto keyPtr6 = createKey(keys[6]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
+ auto keyPtr6 = CacheableKey::create(keys[6]);
auto regPtr1 = getHelper()->getRegion(regionNames[1]);
THREADERRORCHECK(regPtr1 != nullptr,
@@ -608,9 +608,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeCommit)
ASSERT(regPtr0 != nullptr, "In SuspendResumeCommit - Region not found.");
auto regPtr1 = getHelper()->getRegion(regionNames[1]);
ASSERT(regPtr1 != nullptr, "In SuspendResumeCommit - Region not found.");
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
- auto keyPtr6 = createKey(keys[6]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
+ auto keyPtr6 = CacheableKey::create(keys[6]);
txManager->begin();
createEntry(regionNames[0], keys[4], vals[4]);
@@ -683,8 +683,8 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendTimeOut)
auto txManager =
std::dynamic_pointer_cast<InternalCacheTransactionManager2PC>(
getHelper()->getCache()->getCacheTransactionManager());
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
auto regPtr0 = getHelper()->getRegion(regionNames[0]);
ASSERT(regPtr0 != nullptr, "In SuspendTimeOut - Region not found.");
@@ -726,9 +726,9 @@ DUNIT_TASK_DEFINITION(CLIENT1, SuspendResumeRollback)
auto txManager =
std::dynamic_pointer_cast<InternalCacheTransactionManager2PC>(
getHelper()->getCache()->getCacheTransactionManager());
- auto keyPtr4 = createKey(keys[4]);
- auto keyPtr5 = createKey(keys[5]);
- auto keyPtr6 = createKey(keys[6]);
+ auto keyPtr4 = CacheableKey::create(keys[4]);
+ auto keyPtr5 = CacheableKey::create(keys[5]);
+ auto keyPtr6 = CacheableKey::create(keys[6]);
auto regPtr0 = getHelper()->getRegion(regionNames[0]);
ASSERT(regPtr0 != nullptr, "In SuspendResumeRollback - Region not found.");
@@ -1055,7 +1055,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool)
false);
auto reg = getHelper()->getRegion(regionNames[2]);
LOG("REGION Created with Caching Enabled false");
- auto keyPtr = createKey(CREATE_TWICE_KEY);
+ auto keyPtr = CacheableKey::create(CREATE_TWICE_KEY);
auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
try {
reg->create(keyPtr, valPtr);
@@ -1083,13 +1083,13 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepEight_Pool_Sticky)
false, false);
auto reg = getHelper()->getRegion(regionNames[2]);
LOG("REGION Created with Caching Enabled false");
- auto keyPtr = createKey(CREATE_TWICE_KEY);
+ auto keyPtr = CacheableKey::create(CREATE_TWICE_KEY);
auto valPtr = CacheableString::create(CREATE_TWICE_VALUE);
auto reg0 = getHelper()->getRegion(regionNames[0]);
auto reg1 = getHelper()->getRegion(regionNames[1]);
- reg0->localInvalidate(createKey(keys[1]));
- reg1->localInvalidate(createKey(keys[3]));
+ reg0->localInvalidate(CacheableKey::create(keys[1]));
+ reg1->localInvalidate(CacheableKey::create(keys[3]));
auto pool = getHelper()->getCache()->getPoolManager().find("__TESTPOOL1_");
ASSERT(pool != nullptr, "Pool Should have been found");
doNetsearch(regionNames[0], keys[1], nvals[1]);
diff --git a/cppcache/integration-test/testCacheless.cpp b/cppcache/integration-test/testCacheless.cpp
index f569ad3..24900bd 100644
--- a/cppcache/integration-test/testCacheless.cpp
+++ b/cppcache/integration-test/testCacheless.cpp
@@ -74,12 +74,12 @@ class RegionWrapper {
void test(int key, int value, int line) {
char keybuf[100];
sprintf(keybuf, "key%d", key);
- auto keyPtr = createKey(keybuf);
+ auto keyPtr = CacheableKey::create(keybuf);
- if (value == -1) {
- char ebuf[1024];
- sprintf(ebuf, "unexpected key found at %d", line);
- ASSERT(!m_regionPtr->containsKey(keyPtr), ebuf);
+ if (value == -1) {
+ char ebuf[1024];
+ sprintf(ebuf, "unexpected key found at %d", line);
+ ASSERT(!m_regionPtr->containsKey(keyPtr), ebuf);
} else if (value == 0) {
waitForKey(keyPtr);
ASSERT(m_regionPtr->containsKey(keyPtr), "missing key.");
diff --git a/cppcache/integration-test/testThinClientAfterRegionLive.cpp b/cppcache/integration-test/testThinClientAfterRegionLive.cpp
index d76aded..ec5d879 100644
--- a/cppcache/integration-test/testThinClientAfterRegionLive.cpp
+++ b/cppcache/integration-test/testThinClientAfterRegionLive.cpp
@@ -186,7 +186,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, populateServer)
{
SLEEP(10000);
auto regPtr = getHelper()->getRegion(regionNames[0]);
- auto keyPtr = createKey("PXR");
+ auto keyPtr = CacheableKey::create("PXR");
auto valPtr = CacheableString::create("PXR1");
regPtr->create(keyPtr, valPtr);
}
diff --git a/cppcache/integration-test/testThinClientCqDelta.cpp b/cppcache/integration-test/testThinClientCqDelta.cpp
index e223466..0293f3e 100644
--- a/cppcache/integration-test/testThinClientCqDelta.cpp
+++ b/cppcache/integration-test/testThinClientCqDelta.cpp
@@ -237,7 +237,7 @@ END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
{
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
auto dptr = std::make_shared<DeltaTestImpl>();
std::shared_ptr<Cacheable> valPtr(dptr);
auto regPtr = getHelper()->getRegion(regionNames[0]);
diff --git a/cppcache/integration-test/testThinClientDeltaWithNotification.cpp b/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
index e7f0bd9..4aab6c7 100644
--- a/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
+++ b/cppcache/integration-test/testThinClientDeltaWithNotification.cpp
@@ -234,7 +234,7 @@ END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
{
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
DeltaEx* ptr = new DeltaEx();
auto pdxobj = std::make_shared<PdxDeltaEx>();
std::shared_ptr<Cacheable> valPtr(ptr);
@@ -247,7 +247,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
DeltaEx* ptr1 = new DeltaEx();
std::shared_ptr<Cacheable> valPtr1(ptr1);
- auto keyPtr1 = createKey(keys[1]);
+ auto keyPtr1 = CacheableKey::create(keys[1]);
regPtr->put(keyPtr1, valPtr1);
// Client 2: fromDataCount = 2, fromDeltaCount = 1;
ptr1->setDelta(true);
@@ -263,10 +263,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
// For LRU with notification and disc overflow.
LOG("LRU with notification");
- auto keyPtr2 = createKey(keys[2]);
- auto keyPtr3 = createKey(keys[3]);
- auto keyPtr4 = createKey("LRUKEY4");
- auto keyPtr5 = createKey("LRUKEY5");
+ auto keyPtr2 = CacheableKey::create(keys[2]);
+ auto keyPtr3 = CacheableKey::create(keys[3]);
+ auto keyPtr4 = CacheableKey::create("LRUKEY4");
+ auto keyPtr5 = CacheableKey::create("LRUKEY5");
auto regPtr1 = getHelper()->getRegion(regionNames[1]);
regPtr1->put(keyPtr2, valPtr1);
diff --git a/cppcache/integration-test/testThinClientDisconnectionListioner.cpp b/cppcache/integration-test/testThinClientDisconnectionListioner.cpp
index c4849ee..0c54da3 100644
--- a/cppcache/integration-test/testThinClientDisconnectionListioner.cpp
+++ b/cppcache/integration-test/testThinClientDisconnectionListioner.cpp
@@ -61,7 +61,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, populateServer)
{
SLEEP(10000);
auto regPtr = getHelper()->getRegion(regionNames[0]);
- auto keyPtr = createKey("PXR");
+ auto keyPtr = CacheableKey::create("PXR");
auto valPtr = CacheableString::create("PXR1");
regPtr->create(keyPtr, valPtr);
}
diff --git a/cppcache/integration-test/testThinClientHADistOps.cpp b/cppcache/integration-test/testThinClientHADistOps.cpp
index fe73cb0..ac3048c 100644
--- a/cppcache/integration-test/testThinClientHADistOps.cpp
+++ b/cppcache/integration-test/testThinClientHADistOps.cpp
@@ -107,7 +107,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (noKey == false) { // need to find the key!
@@ -244,7 +244,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -269,7 +269,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientHAEventIDMap.cpp b/cppcache/integration-test/testThinClientHAEventIDMap.cpp
index 4b90975..bb57085 100644
--- a/cppcache/integration-test/testThinClientHAEventIDMap.cpp
+++ b/cppcache/integration-test/testThinClientHAEventIDMap.cpp
@@ -142,7 +142,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -233,7 +233,7 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -353,7 +353,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -378,7 +378,7 @@ void createIntEntry(const char* name, const char* key, const int value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableInt32::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientHAFailover.cpp b/cppcache/integration-test/testThinClientHAFailover.cpp
index 8c04d4d..f9a54ec 100644
--- a/cppcache/integration-test/testThinClientHAFailover.cpp
+++ b/cppcache/integration-test/testThinClientHAFailover.cpp
@@ -108,7 +108,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -215,7 +215,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -240,7 +240,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientHAFailoverRegex.cpp b/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
index cb90ba9..d3f54f2 100644
--- a/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
+++ b/cppcache/integration-test/testThinClientHAFailoverRegex.cpp
@@ -86,7 +86,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -193,7 +193,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -218,7 +218,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp b/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
index 43cc7ce..32b7d20 100644
--- a/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
+++ b/cppcache/integration-test/testThinClientHAMixedRedundancy.cpp
@@ -91,7 +91,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -199,7 +199,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -224,7 +224,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientHAPeriodicAck.cpp b/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
index 8234ae6..f6ebc9c 100644
--- a/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
+++ b/cppcache/integration-test/testThinClientHAPeriodicAck.cpp
@@ -155,7 +155,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -246,7 +246,7 @@ void _verifyIntEntry(const char* name, const char* key, const int val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -366,7 +366,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -391,7 +391,7 @@ void createIntEntry(const char* name, const char* key, const int value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableInt32::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp b/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
index fcbc1c0..9aa1b34 100644
--- a/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
+++ b/cppcache/integration-test/testThinClientIntResPolKeysInv.cpp
@@ -79,7 +79,7 @@ void _verifyEntry(const char *name, const char *key, const char *val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (!isCreated) {
@@ -204,7 +204,7 @@ void createEntry(const char *name, const char *key,
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
if (value == nullptr) {
value = "";
}
@@ -232,7 +232,7 @@ void updateEntry(const char *name, const char *key, const char *value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientNotificationWithDeltaWithoutcache.cpp b/cppcache/integration-test/testThinClientNotificationWithDeltaWithoutcache.cpp
index 70eb91e..2ce0fdf 100644
--- a/cppcache/integration-test/testThinClientNotificationWithDeltaWithoutcache.cpp
+++ b/cppcache/integration-test/testThinClientNotificationWithDeltaWithoutcache.cpp
@@ -174,7 +174,7 @@ DUNIT_TASK_DEFINITION(CLIENT2, Client2_RegisterInterest)
{
auto regPtr = getHelper()->getRegion(regionNames[0]);
std::vector<std::shared_ptr<CacheableKey>> vec;
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
vec.push_back(keyPtr);
regPtr->registerKeys(vec);
}
@@ -182,7 +182,7 @@ END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, Client1_Put)
{
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
DeltaEx* ptr = new DeltaEx();
std::shared_ptr<Cacheable> valPtr(ptr);
diff --git a/cppcache/integration-test/testThinClientPdxDeltaWithNotification.cpp b/cppcache/integration-test/testThinClientPdxDeltaWithNotification.cpp
index 545a271..a600ef7 100644
--- a/cppcache/integration-test/testThinClientPdxDeltaWithNotification.cpp
+++ b/cppcache/integration-test/testThinClientPdxDeltaWithNotification.cpp
@@ -229,7 +229,7 @@ END_TASK_DEFINITION
DUNIT_TASK_DEFINITION(CLIENT1, Client1_PdxPut)
{
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
PdxDeltaEx* ptr = new PdxDeltaEx();
// auto pdxobj = std::make_shared<PdxDeltaEx>();
std::shared_ptr<Cacheable> valPtr(ptr);
@@ -242,7 +242,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_PdxPut)
PdxDeltaEx* ptr1 = new PdxDeltaEx();
std::shared_ptr<Cacheable> valPtr1(ptr1);
- auto keyPtr1 = createKey(keys[1]);
+ auto keyPtr1 = CacheableKey::create(keys[1]);
regPtr->put(keyPtr1, valPtr1);
// Client 2: fromDataCount = 2, fromDeltaCount = 1;
ptr1->setDelta(true);
@@ -259,10 +259,10 @@ DUNIT_TASK_DEFINITION(CLIENT1, Client1_PdxPut)
// For LRU with notification and disc overflow.
LOG("LRU with notification");
- auto keyPtr2 = createKey(keys[2]);
- auto keyPtr3 = createKey(keys[3]);
- auto keyPtr4 = createKey("LRUKEY4");
- auto keyPtr5 = createKey("LRUKEY5");
+ auto keyPtr2 = CacheableKey::create(keys[2]);
+ auto keyPtr3 = CacheableKey::create(keys[3]);
+ auto keyPtr4 = CacheableKey::create("LRUKEY4");
+ auto keyPtr5 = CacheableKey::create("LRUKEY5");
auto regPtr1 = getHelper()->getRegion(regionNames[1]);
regPtr1->put(keyPtr2, valPtr1);
diff --git a/cppcache/integration-test/testThinClientPoolRedundancy.cpp b/cppcache/integration-test/testThinClientPoolRedundancy.cpp
index e02b339..9bb9900 100644
--- a/cppcache/integration-test/testThinClientPoolRedundancy.cpp
+++ b/cppcache/integration-test/testThinClientPoolRedundancy.cpp
@@ -270,7 +270,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, VerifyK1C1New2)
{
auto regPtr = getHelper()->getRegion(poolRegNames[2]);
- auto keyPtr = createKey(keys[1]);
+ auto keyPtr = CacheableKey::create(keys[1]);
auto checkPtr =
std::dynamic_pointer_cast<CacheableString>(regPtr->get(keyPtr));
diff --git a/cppcache/integration-test/testThinClientPutWithDelta.cpp b/cppcache/integration-test/testThinClientPutWithDelta.cpp
index 3bfebc2..3c1e552 100644
--- a/cppcache/integration-test/testThinClientPutWithDelta.cpp
+++ b/cppcache/integration-test/testThinClientPutWithDelta.cpp
@@ -121,7 +121,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepOne)
DeltaEx::toDeltaCount = 0;
DeltaEx::toDataCount = 0;
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
auto valPtr = std::make_shared<DeltaEx>();
auto regPtr = getHelper()->getRegion(regionNames[0]);
regPtr->put(keyPtr, valPtr);
@@ -157,7 +157,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, StepOne_DisableDelta)
} catch (IllegalStateException&) {
// Ignore the exception caused by re-registration of DeltaEx.
}
- auto keyPtr = createKey(keys[0]);
+ auto keyPtr = CacheableKey::create(keys[0]);
auto valPtr = std::make_shared<DeltaEx>();
auto regPtr = getHelper()->getRegion(regionNames[0]);
regPtr->put(keyPtr, valPtr);
diff --git a/cppcache/integration-test/testThinClientRemoveOps.cpp b/cppcache/integration-test/testThinClientRemoveOps.cpp
index 6aa6ec7..dae8252 100644
--- a/cppcache/integration-test/testThinClientRemoveOps.cpp
+++ b/cppcache/integration-test/testThinClientRemoveOps.cpp
@@ -100,7 +100,7 @@ void _verifyEntry(const char* name, const char* key, const char* val,
auto regPtr = getHelper()->getRegion(name);
ASSERT(regPtr != nullptr, "Region not found.");
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
// if the region is no ack, then we may need to wait...
if (noKey == false) { // need to find the key!
@@ -218,7 +218,7 @@ void putEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Put entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -242,7 +242,7 @@ void localPutEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Put entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
@@ -261,7 +261,7 @@ void createEntryTwice(const char* name, const char* key, const char* value) {
sprintf(message, "Creating entry -- key: %s value: %s in region %s\n", key,
value, name);
LOG(message);
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
regPtr->create(keyPtr, valPtr);
@@ -284,7 +284,7 @@ void updateEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientSSLAuthCorrupt.cpp b/cppcache/integration-test/testThinClientSSLAuthCorrupt.cpp
index e9f3517..9497f31 100644
--- a/cppcache/integration-test/testThinClientSSLAuthCorrupt.cpp
+++ b/cppcache/integration-test/testThinClientSSLAuthCorrupt.cpp
@@ -83,7 +83,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientSSLAuthFail.cpp b/cppcache/integration-test/testThinClientSSLAuthFail.cpp
index 96a35e0..7142aa5 100644
--- a/cppcache/integration-test/testThinClientSSLAuthFail.cpp
+++ b/cppcache/integration-test/testThinClientSSLAuthFail.cpp
@@ -83,7 +83,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientSSLAuthUntrusted.cpp b/cppcache/integration-test/testThinClientSSLAuthUntrusted.cpp
index 880e83f..8c48180 100644
--- a/cppcache/integration-test/testThinClientSSLAuthUntrusted.cpp
+++ b/cppcache/integration-test/testThinClientSSLAuthUntrusted.cpp
@@ -84,7 +84,7 @@ void createEntry(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
+ auto keyPtr = CacheableKey::create(key);
auto valPtr = CacheableString::create(value);
auto regPtr = getHelper()->getRegion(name);
diff --git a/cppcache/integration-test/testThinClientSSLWithSecurityAuthz.cpp b/cppcache/integration-test/testThinClientSSLWithSecurityAuthz.cpp
index 839440d..fe0ed06 100644
--- a/cppcache/integration-test/testThinClientSSLWithSecurityAuthz.cpp
+++ b/cppcache/integration-test/testThinClientSSLWithSecurityAuthz.cpp
@@ -431,7 +431,7 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
rptr = getHelper()->getRegion(regionNamesAuth[0]);
sprintf(buf, "%s: %d", rptr->getName().c_str(), i);
- auto key = createKey(buf);
+ auto key = CacheableKey::create(buf);
sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), i);
auto valuePtr = buf;
try {
diff --git a/cppcache/integration-test/testThinClientSecurityAuthentication.cpp b/cppcache/integration-test/testThinClientSecurityAuthentication.cpp
index 10ceb5e..98754fe 100644
--- a/cppcache/integration-test/testThinClientSecurityAuthentication.cpp
+++ b/cppcache/integration-test/testThinClientSecurityAuthentication.cpp
@@ -328,23 +328,23 @@ void createEntryTx(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Create entry, verify entry is correct
- auto keyPtr = createKey(key);
- auto valPtr = CacheableString::create(value);
+ auto keyPtr = CacheableKey::create(key);
+ auto valPtr = CacheableString::create(value);
- auto regPtr = getHelper()->getRegion(name);
- ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
- // ASSERT( !regPtr->containsKey( keyPtr ), "Key should not have been found in
- // region." );
- // ASSERT( !regPtr->containsValueForKey( keyPtr ), "Value should not have been
- // found in region." );
+ // ASSERT( !regPtr->containsKey( keyPtr ), "Key should not have been found in
+ // region." );
+ // ASSERT( !regPtr->containsValueForKey( keyPtr ), "Value should not have been
+ // found in region." );
- // regPtr->create( keyPtr, valPtr );
- regPtr->put(keyPtr, valPtr);
- LOG("Created entry.");
+ // regPtr->create( keyPtr, valPtr );
+ regPtr->put(keyPtr, valPtr);
+ LOG("Created entry.");
- // verifyEntry( name, key, value );
- LOG("Entry created.");
+ // verifyEntry( name, key, value );
+ LOG("Entry created.");
}
void updateEntryTx(const char* name, const char* key, const char* value) {
@@ -353,21 +353,21 @@ void updateEntryTx(const char* name, const char* key, const char* value) {
value, name);
fflush(stdout);
// Update entry, verify entry is correct
- auto keyPtr = createKey(key);
- auto valPtr = CacheableString::create(value);
+ auto keyPtr = CacheableKey::create(key);
+ auto valPtr = CacheableString::create(value);
- auto regPtr = getHelper()->getRegion(name);
- ASSERT(regPtr != nullptr, "Region not found.");
+ auto regPtr = getHelper()->getRegion(name);
+ ASSERT(regPtr != nullptr, "Region not found.");
- ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
- ASSERT(regPtr->containsValueForKey(keyPtr),
- "Value should have been found in region.");
+ ASSERT(regPtr->containsKey(keyPtr), "Key should have been found in region.");
+ ASSERT(regPtr->containsValueForKey(keyPtr),
+ "Value should have been found in region.");
- regPtr->put(keyPtr, valPtr);
- LOG("Put entry.");
+ regPtr->put(keyPtr, valPtr);
+ LOG("Put entry.");
- verifyEntry(name, key, value);
- LOG("Entry updated.");
+ verifyEntry(name, key, value);
+ LOG("Entry updated.");
}
DUNIT_TASK_DEFINITION(CLIENT1, StepEight)
diff --git a/cppcache/integration-test/testThinClientSecurityAuthorization.cpp b/cppcache/integration-test/testThinClientSecurityAuthorization.cpp
index 9bde7ae..d3bf5ac 100644
--- a/cppcache/integration-test/testThinClientSecurityAuthorization.cpp
+++ b/cppcache/integration-test/testThinClientSecurityAuthorization.cpp
@@ -457,7 +457,7 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
rptr = getHelper()->getRegion(regionNamesAuth[0]);
sprintf(buf, "%s: %d", rptr->getName().c_str(), i);
- auto key = createKey(buf);
+ auto key = CacheableKey::create(buf);
sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), i);
auto valuePtr = buf;
try {
diff --git a/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp b/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp
index ba1d475..3aed453 100644
--- a/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp
+++ b/cppcache/integration-test/testThinClientSecurityAuthorizationMU.cpp
@@ -893,7 +893,7 @@ DUNIT_TASK_DEFINITION(READER_CLIENT, StepThree)
// rptr = getHelper()->getRegion(regionNamesAuth[0]);
sprintf(buf, "%s: %d", rptr->getName().c_str(), i);
- auto key = createKey(buf);
+ auto key = CacheableKey::create(buf);
sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), i);
auto valuePtr = buf;
try {
diff --git a/cppcache/integration-test/testThinClientWriterException.cpp b/cppcache/integration-test/testThinClientWriterException.cpp
index 7fe2a75..67d8ce6 100644
--- a/cppcache/integration-test/testThinClientWriterException.cpp
+++ b/cppcache/integration-test/testThinClientWriterException.cpp
@@ -165,7 +165,7 @@ void startClient() {
rptr = getHelper()->getRegion(regionNamesAuth[0]);
rptr->registerAllKeys();
sprintf(buf, "%s: %d", rptr->getName().c_str(), i);
- auto key = createKey(buf);
+ auto key = CacheableKey::create(buf);
sprintf(buf, "testUpdate::%s: value of %d", rptr->getName().c_str(), i);
auto valuePtr = buf;
try {
diff --git a/cppcache/src/CacheableBuiltins.cpp b/cppcache/src/CacheableBuiltins.cpp
index b094018..adfc4ec 100644
--- a/cppcache/src/CacheableBuiltins.cpp
+++ b/cppcache/src/CacheableBuiltins.cpp
@@ -39,6 +39,7 @@ _GF_CACHEABLE_KEY_DEF_(CacheableInt16, "%" PRIi16);
_GF_CACHEABLE_KEY_DEF_(CacheableInt32, "%" PRIi32);
_GF_CACHEABLE_KEY_DEF_(CacheableInt64, "%" PRIi64);
_GF_CACHEABLE_KEY_DEF_(CacheableCharacter, "%lc");
+
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/src/CacheableString.cpp b/cppcache/src/CacheableString.cpp
index a95a063..dfd9d12 100644
--- a/cppcache/src/CacheableString.cpp
+++ b/cppcache/src/CacheableString.cpp
@@ -140,7 +140,6 @@ bool CacheableString::isAscii(const std::string& str) {
return true;
}
-
CacheableString::~CacheableString() {}
size_t CacheableString::objectSize() const {
diff --git a/cppcache/src/ProxyRegion.hpp b/cppcache/src/ProxyRegion.hpp
index e4bd89a..3cc0b55 100644
--- a/cppcache/src/ProxyRegion.hpp
+++ b/cppcache/src/ProxyRegion.hpp
@@ -156,7 +156,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
/** Convenience method allowing key to be a const char* */
template <class KEYTYPE>
inline std::shared_ptr<RegionEntry> getEntry(const KEYTYPE& key) {
- return getEntry(createKey(key));
+ return getEntry(CacheableKey::create(key));
}
virtual std::shared_ptr<Cacheable> get(
@@ -172,7 +172,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline std::shared_ptr<Cacheable> get(
const KEYTYPE& key,
const std::shared_ptr<Serializable>& callbackArg = nullptr) {
- return get(createKey(key), callbackArg);
+ return get(CacheableKey::create(key), callbackArg);
}
virtual void put(const std::shared_ptr<CacheableKey>& key,
@@ -187,14 +187,14 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE, class VALUETYPE>
inline void put(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- put(createKey(key), createValue(value), arg);
+ put(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
template <class KEYTYPE>
inline void put(const KEYTYPE& key, const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- put(createKey(key), value, arg);
+ put(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -202,7 +202,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void put(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- put(key, createValue(value), arg);
+ put(key, Serializable::create(value), arg);
}
virtual void putAll(
@@ -225,7 +225,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE, class VALUETYPE>
inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localPut(createKey(key), createValue(value), arg);
+ localPut(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -233,7 +233,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void localPut(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localPut(createKey(key), value, arg);
+ localPut(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -241,7 +241,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void localPut(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localPut(key, createValue(value), arg);
+ localPut(key, Serializable::create(value), arg);
}
virtual void create(const std::shared_ptr<CacheableKey>& key,
@@ -256,7 +256,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE, class VALUETYPE>
inline void create(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- create(createKey(key), createValue(value), arg);
+ create(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -264,7 +264,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void create(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- create(createKey(key), value, arg);
+ create(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -272,7 +272,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void create(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- create(key, createValue(value), arg);
+ create(key, Serializable::create(value), arg);
}
virtual void localCreate(const std::shared_ptr<CacheableKey>& key,
@@ -286,7 +286,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE, class VALUETYPE>
inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localCreate(createKey(key), createValue(value), arg);
+ localCreate(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -294,7 +294,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void localCreate(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localCreate(createKey(key), value, arg);
+ localCreate(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -302,7 +302,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline void localCreate(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localCreate(key, createValue(value), arg);
+ localCreate(key, Serializable::create(value), arg);
}
virtual void invalidate(const std::shared_ptr<CacheableKey>& key,
@@ -316,7 +316,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE>
inline void invalidate(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- invalidate(createKey(key), arg);
+ invalidate(CacheableKey::create(key), arg);
}
virtual void localInvalidate(const std::shared_ptr<CacheableKey>& key,
@@ -329,7 +329,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE>
inline void localInvalidate(
const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
- localInvalidate(createKey(key), arg);
+ localInvalidate(CacheableKey::create(key), arg);
}
virtual void destroy(const std::shared_ptr<CacheableKey>& key,
@@ -343,7 +343,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE>
inline void destroy(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- destroy(createKey(key), arg);
+ destroy(CacheableKey::create(key), arg);
}
virtual void localDestroy(const std::shared_ptr<CacheableKey>& key,
@@ -356,7 +356,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE>
inline void localDestroy(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- localDestroy(createKey(key), arg);
+ localDestroy(CacheableKey::create(key), arg);
}
virtual bool remove(const std::shared_ptr<CacheableKey>& key,
@@ -371,7 +371,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE, class VALUETYPE>
inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return remove(createKey(key), createValue(value), arg);
+ return remove(CacheableKey::create(key), Serializable::create(value), arg);
}
/** Convenience method allowing key to be a const char* */
@@ -379,7 +379,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline bool remove(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return remove(createKey(key), value, arg);
+ return remove(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -387,7 +387,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline bool remove(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return remove(key, createValue(value), arg);
+ return remove(key, Serializable::create(value), arg);
}
virtual bool removeEx(const std::shared_ptr<CacheableKey>& key,
@@ -401,7 +401,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE>
inline bool removeEx(const KEYTYPE& key,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return removeEx(createKey(key), arg);
+ return removeEx(CacheableKey::create(key), arg);
}
virtual bool localRemove(const std::shared_ptr<CacheableKey>& key,
@@ -416,7 +416,8 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE, class VALUETYPE>
inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemove(createKey(key), createValue(value), arg);
+ return localRemove(CacheableKey::create(key), Serializable::create(value),
+ arg);
}
/** Convenience method allowing key to be a const char* */
@@ -424,7 +425,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline bool localRemove(const KEYTYPE& key,
const std::shared_ptr<Cacheable>& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemove(createKey(key), value, arg);
+ return localRemove(CacheableKey::create(key), value, arg);
}
/** Convenience method allowing value to be a const char* */
@@ -432,7 +433,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
inline bool localRemove(const std::shared_ptr<CacheableKey>& key,
const VALUETYPE& value,
const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemove(key, createValue(value), arg);
+ return localRemove(key, Serializable::create(value), arg);
}
virtual bool localRemoveEx(const std::shared_ptr<CacheableKey>& key,
@@ -446,7 +447,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
template <class KEYTYPE>
inline bool localRemoveEx(
const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
- return localRemoveEx(createKey(key), arg);
+ return localRemoveEx(CacheableKey::create(key), arg);
}
/**
@@ -494,7 +495,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
*/
template <class KEYTYPE>
inline bool containsValueForKey(const KEYTYPE& key) const {
- return containsValueForKey(createKey(key));
+ return containsValueForKey(CacheableKey::create(key));
}
virtual bool containsKey(
@@ -527,7 +528,7 @@ class _GEODE_EXPORT ProxyRegion : public Region {
*/
template <class KEYTYPE>
inline bool containsKey(const KEYTYPE& key) const {
- return containsKey(createKey(key));
+ return containsKey(CacheableKey::create(key));
}
virtual void registerKeys(
diff --git a/cppcache/test/CacheableKeyCreateTests.cpp b/cppcache/test/CacheableKeyCreateTests.cpp
new file mode 100644
index 0000000..a14c46a
--- /dev/null
+++ b/cppcache/test/CacheableKeyCreateTests.cpp
@@ -0,0 +1,158 @@
+/*
+ * 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.
+ */
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+#include <geode/CacheableKey.hpp>
+#include <geode/CacheableString.hpp>
+#include <geode/CacheableBuiltins.hpp>
+#include <geode/CacheableDate.hpp>
+
+using namespace apache::geode::client;
+
+TEST(CacheableKeyCreateTests, forArrayOf_constchar) {
+ const auto cacheableKey = CacheableKey::create("test");
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableString);
+ EXPECT_EQ(cacheableString->value(), "test");
+}
+
+TEST(CacheableKeyCreateTests, forArrayOf_char) {
+ char* test = new char[10];
+ strcpy(test, "test");
+ const auto cacheableKey = CacheableKey::create(test);
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableString);
+ EXPECT_EQ(cacheableString->value(), "test");
+}
+
+TEST(CacheableKeyCreateTests, forArrayOf_char16_t) {
+ const auto cacheableKey = CacheableKey::create(u"test");
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableString);
+ EXPECT_EQ(cacheableString->value(), "test");
+}
+
+TEST(CacheableKeyCreateTests, forArrayOf_char32_t) {
+ const auto cacheableKey = CacheableKey::create(U"test");
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableString);
+ ASSERT_EQ(cacheableString->value(), "test");
+}
+
+TEST(CacheableKeyCreateTests, forArrayOf_wchar_t) {
+ const auto cacheableKey = CacheableKey::create(L"test");
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableString);
+ EXPECT_EQ(cacheableString->value(), "test");
+}
+
+TEST(CacheableKeyCreateTests, for_uint8_t) {
+ const auto cacheableKey = CacheableKey::create(static_cast<uint8_t>(1));
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableByte = std::dynamic_pointer_cast<CacheableByte>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableByte);
+ EXPECT_EQ(cacheableByte->value(), 1);
+}
+
+TEST(CacheableKeyCreateTests, for_int16_t) {
+ const auto cacheableKey = CacheableKey::create(static_cast<int16_t>(1));
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableInt16 =
+ std::dynamic_pointer_cast<CacheableInt16>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableInt16);
+ ASSERT_EQ(cacheableInt16->value(), 1);
+}
+
+TEST(CacheableKeyCreateTests, for_int32_t) {
+ const auto cacheableKey = CacheableKey::create(static_cast<int32_t>(1));
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableInt32 =
+ std::dynamic_pointer_cast<CacheableInt32>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableInt32);
+ ASSERT_EQ(cacheableInt32->value(), 1);
+}
+
+TEST(CacheableKeyCreateTests, for_int64_t) {
+ const auto cacheableKey = CacheableKey::create(static_cast<int64_t>(1));
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableInt64 =
+ std::dynamic_pointer_cast<CacheableInt64>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableInt64);
+ EXPECT_EQ(cacheableInt64->value(), 1);
+}
+
+TEST(CacheableKeyCreateTests, for_char16_t) {
+ const auto cacheableKey = CacheableKey::create(u'a');
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableCharacter =
+ std::dynamic_pointer_cast<CacheableCharacter>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableCharacter);
+ EXPECT_EQ(cacheableCharacter->value(), u'a');
+}
+
+TEST(CacheableKeyCreateTests, for_float) {
+ const auto cacheableKey = CacheableKey::create(1.1f);
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableFloat =
+ std::dynamic_pointer_cast<CacheableFloat>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableFloat);
+ EXPECT_EQ(cacheableFloat->value(), 1.1f);
+}
+
+TEST(CacheableKeyCreateTests, for_double) {
+ const auto cacheableKey = CacheableKey::create(1.1);
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableDouble =
+ std::dynamic_pointer_cast<CacheableDouble>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableDouble);
+ EXPECT_EQ(cacheableDouble->value(), 1.1);
+}
+
+TEST(CacheableKeyCreateTests, for_bool) {
+ const auto cacheableKey = CacheableKey::create(true);
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableBoolean =
+ std::dynamic_pointer_cast<CacheableBoolean>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableBoolean);
+ EXPECT_EQ(cacheableBoolean->value(), true);
+}
+
+TEST(CacheableKeyCreateTests, for_timepoint) {
+ auto time = std::chrono::system_clock::now();
+ const auto cacheableKey = CacheableKey::create(time);
+ ASSERT_TRUE(nullptr != cacheableKey);
+ auto&& cacheableDate = std::dynamic_pointer_cast<CacheableDate>(cacheableKey);
+ ASSERT_TRUE(nullptr != cacheableDate);
+ auto tmp = static_cast<typename CacheableDate::time_point>(*cacheableDate);
+ EXPECT_EQ(std::chrono::duration_cast<std::chrono::milliseconds>(
+ time.time_since_epoch()),
+ std::chrono::duration_cast<std::chrono::milliseconds>(
+ tmp.time_since_epoch()));
+}
diff --git a/cppcache/test/SerializableCreateTests.cpp b/cppcache/test/SerializableCreateTests.cpp
new file mode 100644
index 0000000..d85fddd
--- /dev/null
+++ b/cppcache/test/SerializableCreateTests.cpp
@@ -0,0 +1,157 @@
+/*
+ * 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.
+ */
+
+#include <chrono>
+
+#include <gtest/gtest.h>
+
+#include <geode/Serializable.hpp>
+#include <geode/CacheableString.hpp>
+#include <geode/CacheableBuiltins.hpp>
+#include <geode/CacheableDate.hpp>
+
+using namespace apache::geode::client;
+
+TEST(SerializableCreateTests, forArrayOf_constchar) {
+ const auto serializable = Serializable::create("test");
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(serializable);
+ ASSERT_TRUE(nullptr != cacheableString);
+ ASSERT_EQ(cacheableString->value(), "test");
+}
+TEST(SerializableCreateTests, forArrayOf_char) {
+ char* test = new char[10];
+ strcpy(test, "test");
+ const auto serializable = Serializable::create(test);
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(serializable);
+ ASSERT_TRUE(nullptr != cacheableString);
+ ASSERT_EQ(cacheableString->value(), "test");
+}
+
+TEST(SerializableCreateTests, forArrayOf_char16_t) {
+ const auto serializable = Serializable::create(u"test");
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(serializable);
+ ASSERT_TRUE(nullptr != cacheableString);
+ ASSERT_EQ(cacheableString->value(), "test");
+}
+
+TEST(SerializableCreateTests, forArrayOf_char32_t) {
+ const auto serializable = Serializable::create(U"test");
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(serializable);
+ ASSERT_TRUE(nullptr != cacheableString);
+ ASSERT_EQ(cacheableString->value(), "test");
+}
+
+TEST(SerializableCreateTests, forArrayOf_wchar_t) {
+ const auto serializable = Serializable::create(L"test");
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableString =
+ std::dynamic_pointer_cast<CacheableString>(serializable);
+ ASSERT_TRUE(nullptr != cacheableString);
+ ASSERT_EQ(cacheableString->value(), "test");
+}
+
+TEST(SerializableCreateTests, for_uint8_t) {
+ const auto serializable = Serializable::create(static_cast<uint8_t>(1));
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableByte = std::dynamic_pointer_cast<CacheableByte>(serializable);
+ ASSERT_TRUE(nullptr != cacheableByte);
+ ASSERT_EQ(cacheableByte->value(), 1);
+}
+
+TEST(SerializableCreateTests, for_int16_t) {
+ const auto serializable = Serializable::create(static_cast<int16_t>(1));
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableInt16 =
+ std::dynamic_pointer_cast<CacheableInt16>(serializable);
+ ASSERT_TRUE(nullptr != cacheableInt16);
+ ASSERT_EQ(cacheableInt16->value(), 1);
+}
+
+TEST(SerializableCreateTests, for_int32_t) {
+ const auto serializable = Serializable::create(static_cast<int32_t>(1));
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableInt32 =
+ std::dynamic_pointer_cast<CacheableInt32>(serializable);
+ ASSERT_TRUE(nullptr != cacheableInt32);
+ ASSERT_EQ(cacheableInt32->value(), 1);
+}
+
+TEST(SerializableCreateTests, for_int64_t) {
+ const auto serializable = Serializable::create(static_cast<int64_t>(1));
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableInt64 =
+ std::dynamic_pointer_cast<CacheableInt64>(serializable);
+ ASSERT_TRUE(nullptr != cacheableInt64);
+ ASSERT_EQ(cacheableInt64->value(), 1);
+}
+
+TEST(SerializableCreateTests, for_char16_t) {
+ const auto serializable = Serializable::create(u'a');
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableCharacter =
+ std::dynamic_pointer_cast<CacheableCharacter>(serializable);
+ ASSERT_TRUE(nullptr != cacheableCharacter);
+ ASSERT_EQ(cacheableCharacter->value(), u'a');
+}
+
+TEST(SerializableCreateTests, for_float) {
+ const auto serializable = Serializable::create(1.1f);
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableFloat =
+ std::dynamic_pointer_cast<CacheableFloat>(serializable);
+ ASSERT_TRUE(nullptr != cacheableFloat);
+ ASSERT_EQ(cacheableFloat->value(), 1.1f);
+}
+
+TEST(SerializableCreateTests, for_double) {
+ const auto serializable = Serializable::create(1.1);
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableDouble =
+ std::dynamic_pointer_cast<CacheableDouble>(serializable);
+ ASSERT_TRUE(nullptr != cacheableDouble);
+ ASSERT_EQ(cacheableDouble->value(), 1.1);
+}
+
+TEST(SerializableCreateTests, for_bool) {
+ const auto serializable = Serializable::create(true);
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableBoolean =
+ std::dynamic_pointer_cast<CacheableBoolean>(serializable);
+ ASSERT_TRUE(nullptr != cacheableBoolean);
+ ASSERT_EQ(cacheableBoolean->value(), true);
+}
+
+TEST(SerializableCreateTests, for_timepoint) {
+ auto time = std::chrono::system_clock::now();
+ const auto serializable = Serializable::create(time);
+ ASSERT_TRUE(nullptr != serializable);
+ auto&& cacheableDate = std::dynamic_pointer_cast<CacheableDate>(serializable);
+ ASSERT_TRUE(nullptr != cacheableDate);
+ auto tmp = static_cast<typename CacheableDate::time_point>(*cacheableDate);
+ EXPECT_EQ(std::chrono::duration_cast<std::chrono::milliseconds>(
+ time.time_since_epoch()),
+ std::chrono::duration_cast<std::chrono::milliseconds>(
+ tmp.time_since_epoch()));
+}
diff --git a/cppcache/test/gtest_extensions.h b/cppcache/test/gtest_extensions.h
index ca6b2ad..02ca34c 100644
--- a/cppcache/test/gtest_extensions.h
+++ b/cppcache/test/gtest_extensions.h
@@ -73,4 +73,4 @@ std::string squash(const std::string& str, size_t maxLength = 60) {
} // namespace geode
} // namespace apache
-#endif // GEODE_GTEST_EXTENSIONS_H_
\ No newline at end of file
+#endif // GEODE_GTEST_EXTENSIONS_H_
--
To stop receiving notification emails like this one, please contact
jbarrett@apache.org.