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:26 UTC
[geode-native] branch wip/createValue-2 created (now c6b4246)
This is an automated email from the ASF dual-hosted git repository.
jbarrett pushed a change to branch wip/createValue-2
in repository https://gitbox.apache.org/repos/asf/geode-native.git.
at c6b4246 GEODE-4282: Remove createKey/Value templates.
This branch includes the following new commits:
new c6b4246 GEODE-4282: Remove createKey/Value templates.
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
--
To stop receiving notification emails like this one, please contact
jbarrett@apache.org.
[geode-native] 01/01: GEODE-4282: Remove createKey/Value templates.
Posted by jb...@apache.org.
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.