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 2017/09/19 20:53:04 UTC
[geode-native] branch develop updated (ed74ca2 -> 129240a)
This is an automated email from the ASF dual-hosted git repository.
jbarrett pushed a change to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git.
from ed74ca2 GEODE-3630: Change to void Serializable::fromData(...)
new 317ee42 GEODE-3651: Convert RegionFactory to value type.
new 129240a GEODE-3651: Correct variable name.
The 2 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.
Summary of changes:
clicache/src/Cache.cpp | 4 +-
clicache/src/RegionFactory.hpp | 12 +-
clicache/src/native_conditional_unique_ptr.hpp | 3 +
cppcache/include/geode/Cache.hpp | 2 +-
cppcache/include/geode/RegionFactory.hpp | 82 ++++++------
cppcache/integration-test/CacheHelper.cpp | 146 ++++++++++-----------
.../integration-test/ThinClientMultipleCaches.hpp | 2 +-
.../integration-test/testAttributesFactory.cpp | 73 ++++-------
.../integration-test/testOverflowPutGetSqLite.cpp | 137 +++++--------------
.../integration-test/testThinClientCqDurable.cpp | 42 +++---
cppcache/src/Cache.cpp | 2 +-
cppcache/src/CacheImpl.cpp | 5 +-
cppcache/src/CacheImpl.hpp | 2 +-
cppcache/src/RegionFactory.cpp | 103 +++++++--------
tests/cpp/fwklib/RegionHelper.hpp | 80 +++++------
15 files changed, 296 insertions(+), 399 deletions(-)
--
To stop receiving notification emails like this one, please contact
['"commits@geode.apache.org" <co...@geode.apache.org>'].
[geode-native] 02/02: GEODE-3651: Correct variable name.
Posted by jb...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jbarrett pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git
commit 129240a38fc9446a6f148e61f51202dd5b9dc989
Author: Jacob Barrett <jb...@pivotal.io>
AuthorDate: Tue Sep 19 13:52:31 2017 -0700
GEODE-3651: Correct variable name.
---
cppcache/include/geode/RegionFactory.hpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/cppcache/include/geode/RegionFactory.hpp b/cppcache/include/geode/RegionFactory.hpp
index bc0774a..0092c09 100644
--- a/cppcache/include/geode/RegionFactory.hpp
+++ b/cppcache/include/geode/RegionFactory.hpp
@@ -35,7 +35,7 @@ class CPPCACHE_EXPORT RegionFactory {
public:
RegionFactory() = delete;
~RegionFactory() = default;
- RegionFactory(const RegionFactory& move) = delete;
+ RegionFactory(const RegionFactory& nocopy) = delete;
RegionFactory(RegionFactory&& move) = default;
/*
--
To stop receiving notification emails like this one, please contact
"commits@geode.apache.org" <co...@geode.apache.org>.
[geode-native] 01/02: GEODE-3651: Convert RegionFactory to value
type.
Posted by jb...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jbarrett pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git
commit 317ee427bc3b4a0f76033b6ac90d81cd7d005b6e
Author: Jacob Barrett <jb...@pivotal.io>
AuthorDate: Tue Sep 19 10:29:09 2017 -0700
GEODE-3651: Convert RegionFactory to value type.
---
clicache/src/Cache.cpp | 4 +-
clicache/src/RegionFactory.hpp | 12 +-
clicache/src/native_conditional_unique_ptr.hpp | 3 +
cppcache/include/geode/Cache.hpp | 2 +-
cppcache/include/geode/RegionFactory.hpp | 82 ++++++------
cppcache/integration-test/CacheHelper.cpp | 146 ++++++++++-----------
.../integration-test/ThinClientMultipleCaches.hpp | 2 +-
.../integration-test/testAttributesFactory.cpp | 73 ++++-------
.../integration-test/testOverflowPutGetSqLite.cpp | 137 +++++--------------
.../integration-test/testThinClientCqDurable.cpp | 42 +++---
cppcache/src/Cache.cpp | 2 +-
cppcache/src/CacheImpl.cpp | 5 +-
cppcache/src/CacheImpl.hpp | 2 +-
cppcache/src/RegionFactory.cpp | 103 +++++++--------
tests/cpp/fwklib/RegionHelper.hpp | 80 +++++------
15 files changed, 296 insertions(+), 399 deletions(-)
diff --git a/clicache/src/Cache.cpp b/clicache/src/Cache.cpp
index 7438e84..3d5d0e1 100644
--- a/clicache/src/Cache.cpp
+++ b/clicache/src/Cache.cpp
@@ -255,7 +255,9 @@ namespace Apache
try
{
- return RegionFactory::Create(m_nativeptr->get()->createRegionFactory(preDefineRegionAttr));
+ return RegionFactory::Create(std::unique_ptr<native::RegionFactory>(
+ new native::RegionFactory(
+ m_nativeptr->get()->createRegionFactory(preDefineRegionAttr))));
}
finally
{
diff --git a/clicache/src/RegionFactory.hpp b/clicache/src/RegionFactory.hpp
index 6e781db..0c15cab 100644
--- a/clicache/src/RegionFactory.hpp
+++ b/clicache/src/RegionFactory.hpp
@@ -427,15 +427,15 @@ namespace Apache
/// <returns>
/// The managed wrapper object; null if the native pointer is null.
/// </returns>
- inline static RegionFactory^ Create(native::RegionFactoryPtr nativeptr )
+ inline static RegionFactory^ Create(std::unique_ptr<native::RegionFactory>& nativeptr)
{
return __nullptr == nativeptr ? nullptr :
gcnew RegionFactory( nativeptr );
}
- std::shared_ptr<native::RegionFactory> GetNative()
+ native::RegionFactory& GetNative()
{
- return m_nativeptr->get_shared_ptr();
+ return *m_nativeptr;
}
private:
@@ -444,12 +444,12 @@ namespace Apache
/// Private constructor to wrap a native object pointer
/// </summary>
/// <param name="nativeptr">The native object pointer</param>
- inline RegionFactory(native::RegionFactoryPtr nativeptr )
+ inline RegionFactory(std::unique_ptr<native::RegionFactory>& nativeptr)
{
- m_nativeptr = gcnew native_shared_ptr<native::RegionFactory>(nativeptr);
+ m_nativeptr = gcnew native_conditional_unique_ptr<native::RegionFactory>(std::move(nativeptr));
}
- native_shared_ptr<native::RegionFactory>^ m_nativeptr;
+ native_conditional_unique_ptr<native::RegionFactory>^ m_nativeptr;
};
} // namespace Client
} // namespace Geode
diff --git a/clicache/src/native_conditional_unique_ptr.hpp b/clicache/src/native_conditional_unique_ptr.hpp
index 395fb29..33fe01d 100644
--- a/clicache/src/native_conditional_unique_ptr.hpp
+++ b/clicache/src/native_conditional_unique_ptr.hpp
@@ -55,6 +55,9 @@ namespace Apache
return __nullptr == owned_ptr ? unowned_ptr : owned_ptr->get();
}
+ inline _T& operator*() {
+ return *get();
+ }
};
}
}
diff --git a/cppcache/include/geode/Cache.hpp b/cppcache/include/geode/Cache.hpp
index b414d5e..64d9030 100644
--- a/cppcache/include/geode/Cache.hpp
+++ b/cppcache/include/geode/Cache.hpp
@@ -76,7 +76,7 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
* @param regionShortcut
* To create the region specific type, @see RegionShortcut
*/
- virtual RegionFactoryPtr createRegionFactory(RegionShortcut regionShortcut);
+ virtual RegionFactory createRegionFactory(RegionShortcut regionShortcut);
/**
* Initializes the cache from an xml file
diff --git a/cppcache/include/geode/RegionFactory.hpp b/cppcache/include/geode/RegionFactory.hpp
index 52aba8a..bc0774a 100644
--- a/cppcache/include/geode/RegionFactory.hpp
+++ b/cppcache/include/geode/RegionFactory.hpp
@@ -31,9 +31,13 @@ namespace apache {
namespace geode {
namespace client {
class CacheImpl;
-class CPPCACHE_EXPORT RegionFactory
- : public std::enable_shared_from_this<RegionFactory> {
+class CPPCACHE_EXPORT RegionFactory {
public:
+ RegionFactory() = delete;
+ ~RegionFactory() = default;
+ RegionFactory(const RegionFactory& move) = delete;
+ RegionFactory(RegionFactory&& move) = default;
+
/*
* To create the (@link Region}.
* @param name
@@ -48,58 +52,58 @@ class CPPCACHE_EXPORT RegionFactory
* @param cacheLoader the cache loader or nullptr if no loader
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCacheLoader(const CacheLoaderPtr& cacheLoader);
+ RegionFactory& setCacheLoader(const CacheLoaderPtr& cacheLoader);
/** Sets the cache writer for the next <code>RegionAttributes</code> created.
* @param cacheWriter the cache writer or nullptr if no cache writer
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCacheWriter(const CacheWriterPtr& cacheWriter);
+ RegionFactory& setCacheWriter(const CacheWriterPtr& cacheWriter);
/** Sets the CacheListener for the next <code>RegionAttributes</code> created.
* @param aListener a user defined CacheListener, nullptr if no listener
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCacheListener(const CacheListenerPtr& aListener);
+ RegionFactory& setCacheListener(const CacheListenerPtr& aListener);
/** Sets the PartitionResolver for the next <code>RegionAttributes</code>
* created.
* @param aResolver a user defined PartitionResolver, nullptr if no resolver
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setPartitionResolver(const PartitionResolverPtr& aResolver);
+ RegionFactory& setPartitionResolver(const PartitionResolverPtr& aResolver);
/**
* Sets the library path for the library that will be invoked for the loader
* of the region.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCacheLoader(const char* libpath,
- const char* factoryFuncName);
+ RegionFactory& setCacheLoader(const char* libpath,
+ const char* factoryFuncName);
/**
* Sets the library path for the library that will be invoked for the writer
* of the region.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCacheWriter(const char* libpath,
- const char* factoryFuncName);
+ RegionFactory& setCacheWriter(const char* libpath,
+ const char* factoryFuncName);
/**
* Sets the library path for the library that will be invoked for the listener
* of the region.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCacheListener(const char* libpath,
- const char* factoryFuncName);
+ RegionFactory& setCacheListener(const char* libpath,
+ const char* factoryFuncName);
/**
* Sets the library path for the library that will be invoked for the
* partition resolver of the region.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setPartitionResolver(const char* libpath,
- const char* factoryFuncName);
+ RegionFactory& setPartitionResolver(const char* libpath,
+ const char* factoryFuncName);
// EXPIRATION ATTRIBUTES
@@ -109,8 +113,8 @@ class CPPCACHE_EXPORT RegionFactory
* @param idleTimeout the idleTimeout in seconds for entries in this region.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setEntryIdleTimeout(ExpirationAction::Action action,
- int32_t idleTimeout);
+ RegionFactory& setEntryIdleTimeout(ExpirationAction::Action action,
+ int32_t idleTimeout);
/** Sets the timeToLive expiration attributes for region entries for the next
* <code>RegionAttributes</code> created.
@@ -118,8 +122,8 @@ class CPPCACHE_EXPORT RegionFactory
* @param timeToLive the timeToLive in seconds for entries in this region.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setEntryTimeToLive(ExpirationAction::Action action,
- int32_t timeToLive);
+ RegionFactory& setEntryTimeToLive(ExpirationAction::Action action,
+ int32_t timeToLive);
/** Sets the idleTimeout expiration attributes for the region itself for the
* next <code>RegionAttributes</code> created.
@@ -127,8 +131,8 @@ class CPPCACHE_EXPORT RegionFactory
* @param idleTimeout the idleTimeout in seconds for the region as a whole.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setRegionIdleTimeout(ExpirationAction::Action action,
- int32_t idleTimeout);
+ RegionFactory& setRegionIdleTimeout(ExpirationAction::Action action,
+ int32_t idleTimeout);
/** Sets the timeToLive expiration attributes for the region itself for the
* next <code>RegionAttributes</code> created.
@@ -136,8 +140,8 @@ class CPPCACHE_EXPORT RegionFactory
* @param timeToLive the timeToLive in seconds for the region as a whole.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setRegionTimeToLive(ExpirationAction::Action action,
- int32_t timeToLive);
+ RegionFactory& setRegionTimeToLive(ExpirationAction::Action action,
+ int32_t timeToLive);
// PERSISTENCE
/**
@@ -148,9 +152,9 @@ class CPPCACHE_EXPORT RegionFactory
* this must be used to set the PersistenceManager.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setPersistenceManager(const char* libpath,
- const char* factoryFuncName,
- const PropertiesPtr& config = nullptr);
+ RegionFactory& setPersistenceManager(const char* libpath,
+ const char* factoryFuncName,
+ const PropertiesPtr& config = nullptr);
/** Sets the PersistenceManager for the next <code>RegionAttributes</code>
* created.
@@ -158,7 +162,7 @@ class CPPCACHE_EXPORT RegionFactory
* persistenceManager
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setPersistenceManager(
+ RegionFactory& setPersistenceManager(
const PersistenceManagerPtr& persistenceManager,
const PropertiesPtr& config = nullptr);
@@ -170,7 +174,7 @@ class CPPCACHE_EXPORT RegionFactory
* @return a reference to <code>this</code>
* @throws IllegalArgumentException if initialCapacity is negative.
*/
- RegionFactoryPtr setInitialCapacity(int initialCapacity);
+ RegionFactory& setInitialCapacity(int initialCapacity);
/** Sets the entry load factor for the next <code>RegionAttributes</code>
* created. This value is
@@ -179,7 +183,7 @@ class CPPCACHE_EXPORT RegionFactory
* @return a reference to <code>this</code>
* @throws IllegalArgumentException if loadFactor is nonpositive
*/
- RegionFactoryPtr setLoadFactor(float loadFactor);
+ RegionFactory& setLoadFactor(float loadFactor);
/** Sets the concurrency level tof the next <code>RegionAttributes</code>
* created. This value is used in initializing the map that holds the entries.
@@ -187,7 +191,7 @@ class CPPCACHE_EXPORT RegionFactory
* @return a reference to <code>this</code>
* @throws IllegalArgumentException if concurrencyLevel is nonpositive
*/
- RegionFactoryPtr setConcurrencyLevel(uint8_t concurrencyLevel);
+ RegionFactory& setConcurrencyLevel(uint8_t concurrencyLevel);
/**
* Sets a limit on the number of entries that will be held in the cache.
@@ -197,7 +201,7 @@ class CPPCACHE_EXPORT RegionFactory
* @param entriesLimit number of enteries to keep in region
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setLruEntriesLimit(const uint32_t entriesLimit);
+ RegionFactory& setLruEntriesLimit(const uint32_t entriesLimit);
/** Sets the Disk policy type for the next <code>RegionAttributes</code>
* created.
@@ -205,7 +209,7 @@ class CPPCACHE_EXPORT RegionFactory
* @return a reference to <code>this</code>
* @throws IllegalArgumentException if diskPolicyType is Invalid
*/
- RegionFactoryPtr setDiskPolicy(const DiskPolicyType::PolicyType diskPolicy);
+ RegionFactory& setDiskPolicy(const DiskPolicyType::PolicyType diskPolicy);
/**
* Set caching enabled flag for this region. If set to false, then no data is
@@ -218,7 +222,7 @@ class CPPCACHE_EXPORT RegionFactory
* @param cachingEnabled if true, cache data for this region in this process.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCachingEnabled(bool cachingEnabled);
+ RegionFactory& setCachingEnabled(bool cachingEnabled);
/*
* Set the PoolName to attach the Region with that Pool.
@@ -227,14 +231,14 @@ class CPPCACHE_EXPORT RegionFactory
* the name of the Pool to which region will be attached.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setPoolName(const char* name);
+ RegionFactory& setPoolName(const char* name);
/*
* Set boolean to enable/disable cloning while applying delta.
* @param isClonable whether to enable cloning or not.
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setCloningEnabled(bool isClonable);
+ RegionFactory& setCloningEnabled(bool isClonable);
/**
* Enables or disables concurrent modification checks
@@ -243,7 +247,7 @@ class CPPCACHE_EXPORT RegionFactory
* operations
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setConcurrencyChecksEnabled(bool enable);
+ RegionFactory& setConcurrencyChecksEnabled(bool enable);
/**
* Sets time out for tombstones
@@ -251,21 +255,21 @@ class CPPCACHE_EXPORT RegionFactory
* @param tombstoneTimeoutInMSec tombstone timeout in milli second
* @return a reference to <code>this</code>
*/
- RegionFactoryPtr setTombstoneTimeout(uint32_t tombstoneTimeoutInMSec);
+ RegionFactory& setTombstoneTimeout(uint32_t tombstoneTimeoutInMSec);
private:
RegionFactory(apache::geode::client::RegionShortcut preDefinedRegion,
CacheImpl* cacheImpl);
+ void setRegionShortcut();
+
RegionShortcut m_preDefinedRegion;
AttributesFactoryPtr m_attributeFactory;
- void setRegionShortcut();
CacheImpl* m_cacheImpl;
- ~RegionFactory();
+
friend class CacheImpl;
- FRIEND_STD_SHARED_PTR(RegionFactory)
};
} // namespace client
} // namespace geode
diff --git a/cppcache/integration-test/CacheHelper.cpp b/cppcache/integration-test/CacheHelper.cpp
index df345b2..d47df91 100644
--- a/cppcache/integration-test/CacheHelper.cpp
+++ b/cppcache/integration-test/CacheHelper.cpp
@@ -89,9 +89,8 @@ CacheHelper::CacheHelper(const char* member_id, const PropertiesPtr& configPtr,
if (noRootRegion) return;
try {
- RegionFactoryPtr regionFactoryPtr =
- cachePtr->createRegionFactory(CACHING_PROXY);
- rootRegionPtr = regionFactoryPtr->create(ROOT_NAME);
+ auto regionFactory = cachePtr->createRegionFactory(CACHING_PROXY);
+ rootRegionPtr = regionFactory.create(ROOT_NAME);
} catch (const RegionExistsException&) {
rootRegionPtr = cachePtr->getRegion(ROOT_NAME);
}
@@ -134,9 +133,8 @@ CacheHelper::CacheHelper(const PropertiesPtr& configPtr,
if (noRootRegion) return;
try {
- RegionFactoryPtr regionFactoryPtr =
- cachePtr->createRegionFactory(CACHING_PROXY);
- rootRegionPtr = regionFactoryPtr->create(ROOT_NAME);
+ auto regionFactory = cachePtr->createRegionFactory(CACHING_PROXY);
+ rootRegionPtr = regionFactory.create(ROOT_NAME);
} catch (const RegionExistsException&) {
rootRegionPtr = cachePtr->getRegion(ROOT_NAME);
}
@@ -526,16 +524,16 @@ RegionPtr CacheHelper::createRegionAndAttachPool(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
if (poolName != nullptr) {
- regionFactoryPtr->setPoolName(poolName);
+ regionFactory.setPoolName(poolName);
}
- return regionFactoryPtr->create(name);
+ return regionFactory.create(name);
}
RegionPtr CacheHelper::createRegionAndAttachPool2(
@@ -549,15 +547,15 @@ RegionPtr CacheHelper::createRegionAndAttachPool2(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
- regionFactoryPtr->setPoolName(poolName);
- regionFactoryPtr->setPartitionResolver(aResolver);
- return regionFactoryPtr->create(name);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
+ regionFactory.setPoolName(poolName);
+ regionFactory.setPartitionResolver(aResolver);
+ return regionFactory.create(name);
}
void CacheHelper::addServerLocatorEPs(const char* epList, PoolFactoryPtr pfPtr,
@@ -628,17 +626,17 @@ RegionPtr CacheHelper::createPooledRegion(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
- regionFactoryPtr->setPoolName(poolName);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
+ regionFactory.setPoolName(poolName);
if (cacheListener != nullptr) {
- regionFactoryPtr->setCacheListener(cacheListener);
+ regionFactory.setCacheListener(cacheListener);
}
- return regionFactoryPtr->create(name);
+ return regionFactory.create(name);
}
RegionPtr CacheHelper::createPooledRegionConcurrencyCheckDisabled(
@@ -664,18 +662,18 @@ RegionPtr CacheHelper::createPooledRegionConcurrencyCheckDisabled(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
- regionFactoryPtr->setConcurrencyChecksEnabled(concurrencyCheckEnabled);
- regionFactoryPtr->setPoolName(poolName);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
+ regionFactory.setConcurrencyChecksEnabled(concurrencyCheckEnabled);
+ regionFactory.setPoolName(poolName);
if (cacheListener != nullptr) {
- regionFactoryPtr->setCacheListener(cacheListener);
+ regionFactory.setCacheListener(cacheListener);
}
- return regionFactoryPtr->create(name);
+ return regionFactory.create(name);
}
RegionPtr CacheHelper::createRegionDiscOverFlow(
@@ -737,30 +735,30 @@ RegionPtr CacheHelper::createPooledRegionDiscOverFlow(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
- regionFactoryPtr->setPoolName(poolName);
- regionFactoryPtr->setCloningEnabled(true);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
+ regionFactory.setPoolName(poolName);
+ regionFactory.setCloningEnabled(true);
if (lel > 0) {
- regionFactoryPtr->setDiskPolicy(DiskPolicyType::OVERFLOWS);
- PropertiesPtr sqLiteProps = Properties::create();
+ regionFactory.setDiskPolicy(DiskPolicyType::OVERFLOWS);
+ auto sqLiteProps = Properties::create();
sqLiteProps->insert("PageSize", "65536");
sqLiteProps->insert("MaxPageCount", "1073741823");
std::string sqlite_dir =
"SqLiteRegionData" +
std::to_string(static_cast<long long int>(ACE_OS::getpid()));
sqLiteProps->insert("PersistenceDirectory", sqlite_dir.c_str());
- regionFactoryPtr->setPersistenceManager(
- "SqLiteImpl", "createSqLiteInstance", sqLiteProps);
+ regionFactory.setPersistenceManager("SqLiteImpl", "createSqLiteInstance",
+ sqLiteProps);
}
if (cacheListener != nullptr) {
- regionFactoryPtr->setCacheListener(cacheListener);
+ regionFactory.setCacheListener(cacheListener);
}
- return regionFactoryPtr->create(name);
+ return regionFactory.create(name);
}
RegionPtr CacheHelper::createPooledRegionSticky(
@@ -790,17 +788,17 @@ RegionPtr CacheHelper::createPooledRegionSticky(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
- regionFactoryPtr->setPoolName(poolName);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
+ regionFactory.setPoolName(poolName);
if (cacheListener != nullptr) {
- regionFactoryPtr->setCacheListener(cacheListener);
+ regionFactory.setCacheListener(cacheListener);
}
- return regionFactoryPtr->create(name);
+ return regionFactory.create(name);
}
RegionPtr CacheHelper::createPooledRegionStickySingleHop(
@@ -830,17 +828,17 @@ RegionPtr CacheHelper::createPooledRegionStickySingleHop(
if (lel > 0) {
preDefRA = CACHING_PROXY_ENTRY_LRU;
}
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
- regionFactoryPtr->setLruEntriesLimit(lel);
- regionFactoryPtr->setEntryIdleTimeout(action, eit);
- regionFactoryPtr->setEntryTimeToLive(action, ettl);
- regionFactoryPtr->setRegionIdleTimeout(action, rit);
- regionFactoryPtr->setRegionTimeToLive(action, rttl);
- regionFactoryPtr->setPoolName(poolName);
+ auto regionFactory = cachePtr->createRegionFactory(preDefRA);
+ regionFactory.setLruEntriesLimit(lel);
+ regionFactory.setEntryIdleTimeout(action, eit);
+ regionFactory.setEntryTimeToLive(action, ettl);
+ regionFactory.setRegionIdleTimeout(action, rit);
+ regionFactory.setRegionTimeToLive(action, rttl);
+ regionFactory.setPoolName(poolName);
if (cacheListener != nullptr) {
- regionFactoryPtr->setCacheListener(cacheListener);
+ regionFactory.setCacheListener(cacheListener);
}
- return regionFactoryPtr->create(name);
+ return regionFactory.create(name);
}
RegionPtr CacheHelper::createSubregion(RegionPtr& parent, const char* name,
diff --git a/cppcache/integration-test/ThinClientMultipleCaches.hpp b/cppcache/integration-test/ThinClientMultipleCaches.hpp
index 9b33e45..637b368 100644
--- a/cppcache/integration-test/ThinClientMultipleCaches.hpp
+++ b/cppcache/integration-test/ThinClientMultipleCaches.hpp
@@ -53,7 +53,7 @@ RegionPtr createRegionFromCache(std::shared_ptr<Cache> cache) {
auto poolFactory = cache->getPoolManager().createFactory();
CacheHelper::getHelper().addServerLocatorEPs(locatorsG, poolFactory, true);
poolFactory->create("DistRegionAck");
- return cache->createRegionFactory(PROXY)->create("DistRegionAck");
+ return cache->createRegionFactory(PROXY).create("DistRegionAck");
}
DUNIT_TASK_DEFINITION(CLIENT1, SetupAndTestMutlipleCaches)
diff --git a/cppcache/integration-test/testAttributesFactory.cpp b/cppcache/integration-test/testAttributesFactory.cpp
index 2e4ffcf..ef84c40 100644
--- a/cppcache/integration-test/testAttributesFactory.cpp
+++ b/cppcache/integration-test/testAttributesFactory.cpp
@@ -23,79 +23,62 @@
using namespace apache::geode::client;
-// BEGIN_TEST(ATTRIBUTE_FACTORY)
-// {
-// AttributesFactory af;
-// RegionAttributesPtr ra;
-// RegionPtr region;
-//
-// CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
-// CachePtr cache = cacheFactoryPtr->create();
-// ra = af.createRegionAttributes();
-//
-// CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
-// cacheImpl->createRegion("region1", ra, region);
-// LOG("local region created with HA cache specification.");
-// cache->close();
-// }
-// END_TEST(ATTRIBUTE_FACTORY)
-
/* testing attributes with invalid value */
/* testing with negative values */ /*see bug no #865 */
/* testing with exceed boundry condition */ /*see bug no #865 */
BEGIN_TEST(REGION_FACTORY)
{
- CacheFactoryPtr cf = CacheFactory::createCacheFactory();
- CachePtr m_cache = cf->create();
+ auto cf = CacheFactory::createCacheFactory();
+ auto cache = cf->create();
- RegionFactoryPtr rf = m_cache->createRegionFactory(LOCAL);
+ auto rf = cache->createRegionFactory(LOCAL);
/*see bug no #865 */
try {
- rf->setInitialCapacity(-1);
+ rf.setInitialCapacity(-1);
FAIL("Should have got expected IllegalArgumentException");
} catch (IllegalArgumentException&) {
LOG("Got expected IllegalArgumentException");
}
- RegionPtr m_region = rf->create("Local_ETTL_LI");
- LOGINFO("m_region->getAttributes()->getInitialCapacity() = %d ",
- m_region->getAttributes()->getInitialCapacity());
- ASSERT(m_region->getAttributes()->getInitialCapacity() == 10000,
+ auto region = rf.create("Local_ETTL_LI");
+ LOGINFO("region->getAttributes()->getInitialCapacity() = %d ",
+ region->getAttributes()->getInitialCapacity());
+ ASSERT(region->getAttributes()->getInitialCapacity() == 10000,
"Incorrect InitialCapacity");
- m_region->put(1, 1);
- auto res = std::dynamic_pointer_cast<CacheableInt32>(m_region->get(1));
+ region->put(1, 1);
+ auto res = std::dynamic_pointer_cast<CacheableInt32>(region->get(1));
ASSERT(res->value() == 1, "Expected to find value 1.");
- m_region->destroyRegion();
- m_cache->close();
- m_cache = nullptr;
- m_region = nullptr;
+ region->destroyRegion();
+ cache->close();
+ cache = nullptr;
+ region = nullptr;
- CacheFactoryPtr cf1 = CacheFactory::createCacheFactory();
- CachePtr m_cache1 = cf1->create();
+ auto cf1 = CacheFactory::createCacheFactory();
+ auto cache1 = cf1->create();
- RegionFactoryPtr rf1 = m_cache1->createRegionFactory(LOCAL);
+ auto rf1 = cache1->createRegionFactory(LOCAL);
/*see bug no #865 */
try {
- rf1->setInitialCapacity(2147483648U);
+ rf1.setInitialCapacity(2147483648U);
FAIL("Should have got expected IllegalArgumentException");
} catch (IllegalArgumentException&) {
LOG("Got expected IllegalArgumentException");
}
- RegionPtr m_region1 = rf1->create("Local_ETTL_LI");
- LOGINFO("m_region1->getAttributes()->getInitialCapacity() = %d ",
- m_region1->getAttributes()->getInitialCapacity());
- ASSERT(m_region1->getAttributes()->getInitialCapacity() == 10000,
+ auto region1 = rf1.create("Local_ETTL_LI");
+ LOGINFO("region1->getAttributes()->getInitialCapacity() = %d ",
+ region1->getAttributes()->getInitialCapacity());
+ ASSERT(region1->getAttributes()->getInitialCapacity() == 10000,
"Incorrect InitialCapacity");
- m_region1->put(1, 1);
- auto res1 = std::dynamic_pointer_cast<CacheableInt32>(m_region1->get(1));
+ region1->put(1, 1);
+ auto res1 = std::dynamic_pointer_cast<CacheableInt32>(region1->get(1));
ASSERT(res1->value() == 1, "Expected to find value 1.");
- m_region1->destroyRegion();
- m_cache1->close();
- m_cache1 = nullptr;
- m_region1 = nullptr;
+ region1->destroyRegion();
+ cache1->close();
+ cache1 = nullptr;
+ region1 = nullptr;
}
END_TEST(REGION_FACTORY)
diff --git a/cppcache/integration-test/testOverflowPutGetSqLite.cpp b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
index 7467539..5fc7cfc 100644
--- a/cppcache/integration-test/testOverflowPutGetSqLite.cpp
+++ b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
@@ -308,18 +308,17 @@ void verifyGetAll(RegionPtr region, int startIndex) {
void createRegion(RegionPtr& regionPtr, const char* regionName,
PropertiesPtr& cacheProps, PropertiesPtr& sqLiteProps) {
- CacheFactoryPtr cacheFactoryPtr =
- CacheFactory::createCacheFactory(cacheProps);
- CachePtr cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cacheFactoryPtr = CacheFactory::createCacheFactory(cacheProps);
+ auto cachePtr = CacheFactory::createCacheFactory()->create();
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(LOCAL);
- regionFactoryPtr->setCachingEnabled(true);
- regionFactoryPtr->setLruEntriesLimit(10);
- regionFactoryPtr->setInitialCapacity(1000);
- regionFactoryPtr->setDiskPolicy(DiskPolicyType::OVERFLOWS);
- regionFactoryPtr->setPersistenceManager("SqLiteImpl", "createSqLiteInstance",
- sqLiteProps);
- regionPtr = regionFactoryPtr->create(regionName);
+ auto regionFactory = cachePtr->createRegionFactory(LOCAL);
+ regionFactory.setCachingEnabled(true);
+ regionFactory.setLruEntriesLimit(10);
+ regionFactory.setInitialCapacity(1000);
+ regionFactory.setDiskPolicy(DiskPolicyType::OVERFLOWS);
+ regionFactory.setPersistenceManager("SqLiteImpl", "createSqLiteInstance",
+ sqLiteProps);
+ regionPtr = regionFactory.create(regionName);
ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
}
@@ -471,22 +470,22 @@ END_TEST(OverFlowTest_absPath)
BEGIN_TEST(OverFlowTest_SqLiteFull)
{
- CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory();
- CachePtr cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cacheFactoryPtr = CacheFactory::createCacheFactory();
+ auto cachePtr = CacheFactory::createCacheFactory()->create();
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(LOCAL);
- regionFactoryPtr->setCachingEnabled(true);
- regionFactoryPtr->setLruEntriesLimit(1);
- regionFactoryPtr->setInitialCapacity(1000);
- regionFactoryPtr->setDiskPolicy(DiskPolicyType::OVERFLOWS);
- PropertiesPtr sqliteProperties = Properties::create();
+ auto regionFactory = cachePtr->createRegionFactory(LOCAL);
+ regionFactory.setCachingEnabled(true);
+ regionFactory.setLruEntriesLimit(1);
+ regionFactory.setInitialCapacity(1000);
+ regionFactory.setDiskPolicy(DiskPolicyType::OVERFLOWS);
+ auto sqliteProperties = Properties::create();
sqliteProperties->insert(
"MaxPageCount", "10"); // 10 * 1024 is arround 10kB is the db file size
sqliteProperties->insert("PageSize", "1024");
sqliteProperties->insert("PersistenceDirectory", sqlite_dir.c_str());
- regionFactoryPtr->setPersistenceManager(
- "SqLiteImpl", "createSqLiteInstance", sqliteProperties);
- RegionPtr regionPtr = regionFactoryPtr->create("OverFlowRegion");
+ regionFactory.setPersistenceManager("SqLiteImpl", "createSqLiteInstance",
+ sqliteProperties);
+ auto regionPtr = regionFactory.create("OverFlowRegion");
ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
try {
@@ -507,100 +506,30 @@ BEGIN_TEST(OverFlowTest_SqLiteFull)
}
END_TEST(OverFlowTest_SqLiteFull)
-//#if ( defined(_WIN64) || defined(__sparcv9) || defined(__x86_64__) ) // run
-// this test only for 64 bit mode
-// BEGIN_TEST(OverFlowTest_LargeData)
-//{
-// /** Connecting to a distributed system. */
-// DistributedSystem& dsysPtr;
-//
-// /** Creating a cache to manage regions. */
-// CachePtr cachePtr ;
-// PropertiesPtr pp = Properties::create();
-// startDSandCreateCache(dsysPtr, cachePtr, pp);
-// ASSERT(dsysPtr != nullptr, "Expected dsys to be NON-nullptr");
-// ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
-//
-// RegionAttributesPtr attrsPtr;
-// AttributesFactory attrsFact;
-// attrsFact.setCachingEnabled(true);
-// attrsFact.setLruEntriesLimit(1 );
-// attrsFact.setInitialCapacity( 10000 );
-// attrsFact.setDiskPolicy(DiskPolicyType::OVERFLOWS);
-// PropertiesPtr sqliteProperties = Properties::create();
-// sqliteProperties->insert("MaxPageCount","2147483646"); //maximum allowed
-// for sqlite
-// sqliteProperties->insert("PageSize","65536"); //maximum allowed for sqlite
-// sqliteProperties->insert("PersistenceDirectory", sqlite_dir.c_str());
-// attrsFact.setPersistenceManager("SqLiteImpl","createSqLiteInstance",sqliteProperties);
-//
-// attrsPtr = attrsFact.createRegionAttributes( );
-// ASSERT(attrsPtr != nullptr, "Expected region attributes to be NON-nullptr");
-//
-// /** Create a region with caching and LRU. */
-// RegionPtr regionPtr = cachePtr->createRegion( "OverFlowRegion", attrsPtr );
-// ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
-//
-// /** put one million values into the cache. to test the large data values*/
-// doNputLargeData(regionPtr, 1024 * 1); //arround 100 GB data
-//
-// /** do some gets... printing what we find in the cache. */
-// doNgetLargeData(regionPtr, 1024 * 1); //arround 100 GB data
-// LOG("Completed doNget");
-//
-//
-// /** test to verify same region repeatedly to ensure that the persistece
-// files are created and destroyed correctly */
-//
-// RegionPtr subRegion;
-// for(int i = 0; i<10; i++)
-// {
-// createSubRegion(regionPtr,subRegion,attrsPtr,"SubRegion");
-// ASSERT(subRegion != nullptr, "Expected region to be NON-nullptr");
-// subRegion->destroyRegion();
-// ASSERT(subRegion->isDestroyed(), "Expected region is not destroyed ");
-// subRegion = nullptr;
-// ACE_TCHAR hname[MAXHOSTNAMELEN];
-// ACE_OS::hostname( hname, sizeof(hname)-1);
-// char sqliteDirSubRgn[512];
-// sprintf(sqliteDirSubRgn, "%s/%s_%u/_%s_SubRegion/file_0.db",
-// sqlite_dir.c_str(), hname, ACE_OS::getpid(), regionPtr->getName());
-//
-// ACE_stat fileStat;
-// ASSERT(ACE_OS::stat(sqliteDirSubRgn, &fileStat) == -1, "persistence file
-// still present");
-// }
-// // cache close
-// cachePtr->close();
-// // DS system close
-// dsysPtr->disconnect();
-//}
-// END_TEST(OverFlowTest_LargeData)
-//#endif // 64-bit
BEGIN_TEST(OverFlowTest_HeapLRU)
{
/** Creating a cache to manage regions. */
- PropertiesPtr pp = Properties::create();
+ auto pp = Properties::create();
pp->insert("heap-lru-limit", 1);
pp->insert("heap-lru-delta", 10);
- CacheFactoryPtr cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
- CachePtr cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
+ auto cachePtr = CacheFactory::createCacheFactory()->create();
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
- RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(LOCAL);
- regionFactoryPtr->setCachingEnabled(true);
- regionFactoryPtr->setLruEntriesLimit(1024 * 10);
- regionFactoryPtr->setInitialCapacity(1000);
- regionFactoryPtr->setDiskPolicy(DiskPolicyType::OVERFLOWS);
- PropertiesPtr sqliteProperties = Properties::create();
+ auto regionFactory = cachePtr->createRegionFactory(LOCAL);
+ regionFactory.setCachingEnabled(true);
+ regionFactory.setLruEntriesLimit(1024 * 10);
+ regionFactory.setInitialCapacity(1000);
+ regionFactory.setDiskPolicy(DiskPolicyType::OVERFLOWS);
+ auto sqliteProperties = Properties::create();
sqliteProperties->insert(
"MaxPageCount",
"2147483646"); // 10 * 1024 is arround 10kB is the db file size
sqliteProperties->insert("PageSize", "65536");
sqliteProperties->insert("PersistenceDirectory", sqlite_dir.c_str());
- regionFactoryPtr->setPersistenceManager(
- "SqLiteImpl", "createSqLiteInstance", sqliteProperties);
- RegionPtr regionPtr = regionFactoryPtr->create("OverFlowRegion");
+ regionFactory.setPersistenceManager("SqLiteImpl", "createSqLiteInstance",
+ sqliteProperties);
+ auto regionPtr = regionFactory.create("OverFlowRegion");
ASSERT(regionPtr != nullptr, "Expected regionPtr to be NON-nullptr");
validateAttribute(regionPtr);
diff --git a/cppcache/integration-test/testThinClientCqDurable.cpp b/cppcache/integration-test/testThinClientCqDurable.cpp
index 35c3892..48cd2ab 100644
--- a/cppcache/integration-test/testThinClientCqDurable.cpp
+++ b/cppcache/integration-test/testThinClientCqDurable.cpp
@@ -186,13 +186,13 @@ void stepOne() {
void RunDurableCqClient() {
// Create durable client's properties using api.
- PropertiesPtr pp = Properties::create();
+ auto pp = Properties::create();
pp->insert("durable-client-id", "DurableClientId");
pp->insert("durable-timeout", 3600);
// Create a Geode Cache Programmatically.
- CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory(pp);
- CachePtr cachePtr = cacheFactory->create();
+ auto cacheFactory = CacheFactory::createCacheFactory(pp);
+ auto cachePtr = cacheFactory->create();
auto poolFactory = cachePtr->getPoolManager().createFactory();
poolFactory->setSubscriptionEnabled(true);
poolFactory->setSubscriptionAckInterval(5000);
@@ -201,27 +201,27 @@ void RunDurableCqClient() {
LOGINFO("Created the Geode Cache Programmatically");
- RegionFactoryPtr regionFactory = cachePtr->createRegionFactory(CACHING_PROXY);
+ auto regionFactory = cachePtr->createRegionFactory(CACHING_PROXY);
// Create the Region Programmatically.
- RegionPtr regionPtr = regionFactory->create("DistRegionAck");
+ auto regionPtr = regionFactory.create("DistRegionAck");
LOGINFO("Created the Region Programmatically");
// Get the QueryService from the Cache.
- QueryServicePtr qrySvcPtr = cachePtr->getQueryService();
+ auto qrySvcPtr = cachePtr->getQueryService();
// Create CqAttributes and Install Listener
CqAttributesFactory cqFac;
auto cqLstner = std::make_shared<MyCqListener1>();
cqFac.addCqListener(cqLstner);
- CqAttributesPtr cqAttr = cqFac.create();
+ auto cqAttr = cqFac.create();
LOGINFO("Attached CqListener");
// create a new Cq Query
const char* qryStr = "select * from /DistRegionAck ";
- CqQueryPtr qry = qrySvcPtr->newCq((char*)"MyCq", qryStr, cqAttr, true);
+ auto qry = qrySvcPtr->newCq((char*)"MyCq", qryStr, cqAttr, true);
LOGINFO("Created new CqQuery");
@@ -251,26 +251,25 @@ void RunDurableCqClient() {
}
void RunFeederClient() {
- CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
+ auto cacheFactory = CacheFactory::createCacheFactory();
LOGINFO("Feeder connected to the Geode Distributed System");
- CachePtr cachePtr = cacheFactory->create();
+ auto cachePtr = cacheFactory->create();
LOGINFO("Created the Geode Cache");
- RegionFactoryPtr regionFactory = cachePtr->createRegionFactory(PROXY);
+ auto regionFactory = cachePtr->createRegionFactory(PROXY);
LOGINFO("Created the RegionFactory");
// Create the Region Programmatically.
- RegionPtr regionPtr = regionFactory->create("DistRegionAck");
+ auto regionPtr = regionFactory.create("DistRegionAck");
LOGINFO("Created the Region Programmatically.");
for (int i = 0; i < 10; i++) {
- auto keyPtr =
- std::dynamic_pointer_cast<CacheableKey>(CacheableInt32::create(i));
- CacheableInt32Ptr valPtr = CacheableInt32::create(i);
+ auto keyPtr = CacheableInt32::create(i);
+ auto valPtr = CacheableInt32::create(i);
regionPtr->put(keyPtr, valPtr);
}
@@ -284,26 +283,25 @@ void RunFeederClient() {
}
void RunFeederClient1() {
- CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
+ auto cacheFactory = CacheFactory::createCacheFactory();
LOGINFO("Feeder connected to the Geode Distributed System");
- CachePtr cachePtr = cacheFactory->create();
+ auto cachePtr = cacheFactory->create();
LOGINFO("Created the Geode Cache");
- RegionFactoryPtr regionFactory = cachePtr->createRegionFactory(PROXY);
+ auto regionFactory = cachePtr->createRegionFactory(PROXY);
LOGINFO("Created the RegionFactory");
// Create the Region Programmatically.
- RegionPtr regionPtr = regionFactory->create("DistRegionAck");
+ auto regionPtr = regionFactory.create("DistRegionAck");
LOGINFO("Created the Region Programmatically.");
for (int i = 10; i < 20; i++) {
- auto keyPtr =
- std::dynamic_pointer_cast<CacheableKey>(CacheableInt32::create(i));
- CacheableInt32Ptr valPtr = CacheableInt32::create(i);
+ auto keyPtr = CacheableInt32::create(i);
+ auto valPtr = CacheableInt32::create(i);
regionPtr->put(keyPtr, valPtr);
}
diff --git a/cppcache/src/Cache.cpp b/cppcache/src/Cache.cpp
index 37ca223..bbd7c18 100644
--- a/cppcache/src/Cache.cpp
+++ b/cppcache/src/Cache.cpp
@@ -132,7 +132,7 @@ void Cache::rootRegions(VectorOfRegion& regions) {
}*/
}
-RegionFactoryPtr Cache::createRegionFactory(RegionShortcut preDefinedRegion) {
+RegionFactory Cache::createRegionFactory(RegionShortcut preDefinedRegion) {
return m_cacheImpl->createRegionFactory(preDefinedRegion);
}
diff --git a/cppcache/src/CacheImpl.cpp b/cppcache/src/CacheImpl.cpp
index a7c5157..e4acce7 100644
--- a/cppcache/src/CacheImpl.cpp
+++ b/cppcache/src/CacheImpl.cpp
@@ -739,9 +739,8 @@ int CacheImpl::getPoolSize(const char* poolName) {
return -1;
}
-RegionFactoryPtr CacheImpl::createRegionFactory(
- RegionShortcut preDefinedRegion) {
- return std::make_shared<RegionFactory>(preDefinedRegion, this);
+RegionFactory CacheImpl::createRegionFactory(RegionShortcut preDefinedRegion) {
+ return RegionFactory(preDefinedRegion, this);
}
std::map<std::string, RegionAttributesPtr> CacheImpl::getRegionShortcut() {
diff --git a/cppcache/src/CacheImpl.hpp b/cppcache/src/CacheImpl.hpp
index e6da435..fec3a9f 100644
--- a/cppcache/src/CacheImpl.hpp
+++ b/cppcache/src/CacheImpl.hpp
@@ -203,7 +203,7 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
*/
inline void setSearchTimeout(int seconds = 0) {}
- virtual RegionFactoryPtr createRegionFactory(RegionShortcut preDefinedRegion);
+ virtual RegionFactory createRegionFactory(RegionShortcut preDefinedRegion);
CacheTransactionManagerPtr getCacheTransactionManager();
diff --git a/cppcache/src/RegionFactory.cpp b/cppcache/src/RegionFactory.cpp
index 6d2b41a..90f4111 100644
--- a/cppcache/src/RegionFactory.cpp
+++ b/cppcache/src/RegionFactory.cpp
@@ -43,8 +43,6 @@ RegionFactory::RegionFactory(RegionShortcut preDefinedRegion,
setRegionShortcut();
}
-RegionFactory::~RegionFactory() {}
-
RegionPtr RegionFactory::create(const char* name) {
RegionPtr retRegionPtr = nullptr;
RegionAttributesPtr regAttr = m_attributeFactory->createRegionAttributes();
@@ -82,136 +80,135 @@ void RegionFactory::setRegionShortcut() {
}
}
-RegionFactoryPtr RegionFactory::setCacheLoader(
+RegionFactory& RegionFactory::setCacheLoader(
const CacheLoaderPtr& cacheLoader) {
m_attributeFactory->setCacheLoader(cacheLoader);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCacheWriter(
+RegionFactory& RegionFactory::setCacheWriter(
const CacheWriterPtr& cacheWriter) {
m_attributeFactory->setCacheWriter(cacheWriter);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCacheListener(
+RegionFactory& RegionFactory::setCacheListener(
const CacheListenerPtr& aListener) {
m_attributeFactory->setCacheListener(aListener);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setPartitionResolver(
+RegionFactory& RegionFactory::setPartitionResolver(
const PartitionResolverPtr& aResolver) {
m_attributeFactory->setPartitionResolver(aResolver);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCacheLoader(const char* lib,
- const char* func) {
+RegionFactory& RegionFactory::setCacheLoader(const char* lib,
+ const char* func) {
m_attributeFactory->setCacheLoader(lib, func);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCacheWriter(const char* lib,
- const char* func) {
+RegionFactory& RegionFactory::setCacheWriter(const char* lib,
+ const char* func) {
m_attributeFactory->setCacheWriter(lib, func);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCacheListener(const char* lib,
- const char* func) {
+RegionFactory& RegionFactory::setCacheListener(const char* lib,
+ const char* func) {
m_attributeFactory->setCacheListener(lib, func);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setPartitionResolver(const char* lib,
- const char* func) {
+RegionFactory& RegionFactory::setPartitionResolver(const char* lib,
+ const char* func) {
m_attributeFactory->setPartitionResolver(lib, func);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setEntryIdleTimeout(
+RegionFactory& RegionFactory::setEntryIdleTimeout(
ExpirationAction::Action action, int idleTimeout) {
m_attributeFactory->setEntryIdleTimeout(action, idleTimeout);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setEntryTimeToLive(
+RegionFactory& RegionFactory::setEntryTimeToLive(
ExpirationAction::Action action, int timeToLive) {
m_attributeFactory->setEntryTimeToLive(action, timeToLive);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setRegionIdleTimeout(
+RegionFactory& RegionFactory::setRegionIdleTimeout(
ExpirationAction::Action action, int idleTimeout) {
m_attributeFactory->setRegionIdleTimeout(action, idleTimeout);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setRegionTimeToLive(
+RegionFactory& RegionFactory::setRegionTimeToLive(
ExpirationAction::Action action, int timeToLive) {
m_attributeFactory->setRegionTimeToLive(action, timeToLive);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setInitialCapacity(int initialCapacity) {
+RegionFactory& RegionFactory::setInitialCapacity(int initialCapacity) {
char excpStr[256] = {0};
if (initialCapacity < 0) {
ACE_OS::snprintf(excpStr, 256, "initialCapacity must be >= 0 ");
throw IllegalArgumentException(excpStr);
}
m_attributeFactory->setInitialCapacity(initialCapacity);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setLoadFactor(float loadFactor) {
+RegionFactory& RegionFactory::setLoadFactor(float loadFactor) {
m_attributeFactory->setLoadFactor(loadFactor);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setConcurrencyLevel(uint8_t concurrencyLevel) {
+RegionFactory& RegionFactory::setConcurrencyLevel(uint8_t concurrencyLevel) {
m_attributeFactory->setConcurrencyLevel(concurrencyLevel);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setConcurrencyChecksEnabled(bool enable) {
+RegionFactory& RegionFactory::setConcurrencyChecksEnabled(bool enable) {
m_attributeFactory->setConcurrencyChecksEnabled(enable);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setLruEntriesLimit(
- const uint32_t entriesLimit) {
+RegionFactory& RegionFactory::setLruEntriesLimit(const uint32_t entriesLimit) {
m_attributeFactory->setLruEntriesLimit(entriesLimit);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setDiskPolicy(
+RegionFactory& RegionFactory::setDiskPolicy(
const DiskPolicyType::PolicyType diskPolicy) {
m_attributeFactory->setDiskPolicy(diskPolicy);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCachingEnabled(bool cachingEnabled) {
+RegionFactory& RegionFactory::setCachingEnabled(bool cachingEnabled) {
m_attributeFactory->setCachingEnabled(cachingEnabled);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setPersistenceManager(
+RegionFactory& RegionFactory::setPersistenceManager(
const PersistenceManagerPtr& persistenceManager,
const PropertiesPtr& config) {
m_attributeFactory->setPersistenceManager(persistenceManager, config);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setPersistenceManager(
+RegionFactory& RegionFactory::setPersistenceManager(
const char* lib, const char* func, const PropertiesPtr& config) {
m_attributeFactory->setPersistenceManager(lib, func, config);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setPoolName(const char* name) {
+RegionFactory& RegionFactory::setPoolName(const char* name) {
m_attributeFactory->setPoolName(name);
- return shared_from_this();
+ return *this;
}
-RegionFactoryPtr RegionFactory::setCloningEnabled(bool isClonable) {
+RegionFactory& RegionFactory::setCloningEnabled(bool isClonable) {
m_attributeFactory->setCloningEnabled(isClonable);
- return shared_from_this();
+ return *this;
}
} // namespace client
} // namespace geode
diff --git a/tests/cpp/fwklib/RegionHelper.hpp b/tests/cpp/fwklib/RegionHelper.hpp
index 451d228..d635803 100644
--- a/tests/cpp/fwklib/RegionHelper.hpp
+++ b/tests/cpp/fwklib/RegionHelper.hpp
@@ -146,59 +146,59 @@ class RegionHelper {
return sString;
}
- void setRegionAttributes(RegionFactoryPtr& regionFac) {
+ void setRegionAttributes(RegionFactory& regionFac) {
RegionAttributesPtr atts = m_region->getAttributesPtr();
- regionFac->setCachingEnabled(atts->getCachingEnabled());
+ regionFac.setCachingEnabled(atts->getCachingEnabled());
if (atts->getCacheListenerLibrary() != NULL &&
atts->getCacheListenerFactory() != NULL) {
- regionFac->setCacheListener(atts->getCacheListenerLibrary(),
- atts->getCacheListenerFactory());
+ regionFac.setCacheListener(atts->getCacheListenerLibrary(),
+ atts->getCacheListenerFactory());
}
if (atts->getCacheLoaderLibrary() != NULL &&
atts->getCacheLoaderFactory() != NULL) {
- regionFac->setCacheLoader(atts->getCacheLoaderLibrary(),
- atts->getCacheLoaderFactory());
+ regionFac.setCacheLoader(atts->getCacheLoaderLibrary(),
+ atts->getCacheLoaderFactory());
}
if (atts->getCacheWriterLibrary() != NULL &&
atts->getCacheWriterFactory() != NULL) {
- regionFac->setCacheWriter(atts->getCacheWriterLibrary(),
- atts->getCacheWriterFactory());
+ regionFac.setCacheWriter(atts->getCacheWriterLibrary(),
+ atts->getCacheWriterFactory());
}
if (atts->getEntryIdleTimeout() != 0) {
- regionFac->setEntryIdleTimeout(atts->getEntryIdleTimeoutAction(),
- atts->getEntryIdleTimeout());
+ regionFac.setEntryIdleTimeout(atts->getEntryIdleTimeoutAction(),
+ atts->getEntryIdleTimeout());
}
if (atts->getEntryTimeToLive() != 0) {
- regionFac->setEntryTimeToLive(atts->getEntryTimeToLiveAction(),
- atts->getEntryTimeToLive());
+ regionFac.setEntryTimeToLive(atts->getEntryTimeToLiveAction(),
+ atts->getEntryTimeToLive());
}
if (atts->getRegionIdleTimeout() != 0) {
- regionFac->setRegionIdleTimeout(atts->getRegionIdleTimeoutAction(),
- atts->getRegionIdleTimeout());
+ regionFac.setRegionIdleTimeout(atts->getRegionIdleTimeoutAction(),
+ atts->getRegionIdleTimeout());
}
if (atts->getRegionTimeToLive() != 0) {
- regionFac->setRegionTimeToLive(atts->getRegionTimeToLiveAction(),
- atts->getRegionTimeToLive());
+ regionFac.setRegionTimeToLive(atts->getRegionTimeToLiveAction(),
+ atts->getRegionTimeToLive());
}
if (atts->getPartitionResolverLibrary() != NULL &&
atts->getPartitionResolverFactory() != NULL) {
- regionFac->setPartitionResolver(atts->getPartitionResolverLibrary(),
- atts->getPartitionResolverFactory());
+ regionFac.setPartitionResolver(atts->getPartitionResolverLibrary(),
+ atts->getPartitionResolverFactory());
}
if (atts->getPersistenceLibrary() != NULL &&
atts->getPersistenceFactory() != NULL) {
- regionFac->setPersistenceManager(atts->getPersistenceLibrary(),
- atts->getPersistenceFactory(),
- atts->getPersistenceProperties());
+ regionFac.setPersistenceManager(atts->getPersistenceLibrary(),
+ atts->getPersistenceFactory(),
+ atts->getPersistenceProperties());
}
- regionFac->setInitialCapacity(atts->getInitialCapacity());
- regionFac->setLoadFactor(atts->getLoadFactor());
- regionFac->setConcurrencyLevel(atts->getConcurrencyLevel());
- regionFac->setLruEntriesLimit(atts->getLruEntriesLimit());
- regionFac->setDiskPolicy(atts->getDiskPolicy());
- regionFac->setCloningEnabled(atts->getCloningEnabled());
- regionFac->setPoolName(atts->getPoolName());
- regionFac->setConcurrencyChecksEnabled(atts->getConcurrencyChecksEnabled());
+ regionFac.setInitialCapacity(atts->getInitialCapacity());
+ regionFac.setLoadFactor(atts->getLoadFactor());
+ regionFac.setConcurrencyLevel(atts->getConcurrencyLevel());
+ regionFac.setLruEntriesLimit(atts->getLruEntriesLimit());
+ regionFac.setDiskPolicy(atts->getDiskPolicy());
+ regionFac.setCloningEnabled(atts->getCloningEnabled());
+ regionFac.setPoolName(atts->getPoolName());
+ regionFac.setConcurrencyChecksEnabled(atts->getConcurrencyChecksEnabled());
}
RegionPtr createRootRegion(CachePtr& cachePtr) {
@@ -211,8 +211,6 @@ class RegionHelper {
}
RegionPtr createRootRegion(CachePtr& cachePtr, std::string regionName) {
- RegionPtr region;
- RegionFactoryPtr regionFac;
if (regionName.empty()) {
regionName = m_region->getName();
FWKINFO("region name is " << regionName);
@@ -220,23 +218,9 @@ class RegionHelper {
FWKEXCEPTION("Region name not specified.");
}
}
- regionFac = cachePtr->createRegionFactory(CACHING_PROXY);
+ auto regionFac = cachePtr->createRegionFactory(CACHING_PROXY);
setRegionAttributes(regionFac);
- RegionAttributesPtr atts = m_region->getAttributesPtr();
- /* if(atts->getCachingEnabled())
- {
- regionFac=cachePtr->createRegionFactory(CACHING_PROXY);
- regionFac->setCachingEnabled(true);
- FWKINFO("Setting CachingEnabled=true");
- }
- else
- {
- regionFac=cachePtr->createRegionFactory(PROXY);
- regionFac->setCachingEnabled(false);
- FWKINFO("Setting CachingEnabled=false");
- }*/
- // UNUSED bool hasEndpoints = ( NULL != atts->getEndpoints() ) ? true :
- // false;
+ auto atts = m_region->getAttributesPtr();
bool withPool = (NULL != atts->getPoolName()) ? true : false;
std::string poolName;
if (withPool) {
@@ -244,7 +228,7 @@ class RegionHelper {
} else {
poolName = "";
}
- region = regionFac->create(regionName.c_str());
+ auto region = regionFac.create(regionName.c_str());
FWKINFO("Region created with name = " << regionName + " and pool name= "
<< poolName);
FWKINFO(" Region Created with following attributes :"
--
To stop receiving notification emails like this one, please contact
"commits@geode.apache.org" <co...@geode.apache.org>.