[
https://issues.apache.org/jira/browse/GEODE-3645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16273257#comment-16273257
]
ASF GitHub Bot commented on GEODE-3645:
---------------------------------------
dgkimura closed pull request #159: GEODE-3645: Update CacheFactory::create to
return Cache by value
URL: https://github.com/apache/geode-native/pull/159
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/clicache/src/CacheFactory.cpp b/clicache/src/CacheFactory.cpp
index f2f63000..11de85a6 100644
--- a/clicache/src/CacheFactory.cpp
+++ b/clicache/src/CacheFactory.cpp
@@ -60,12 +60,10 @@ namespace Apache
bool pdxIgnoreUnreadFields = false;
bool pdxReadSerialized = false;
bool appDomainEnable = false;
- std::shared_ptr<native::Cache> nativeCache = nullptr;
_GF_MG_EXCEPTION_TRY2
//msclr::lock lockInstance(m_singletonSync);
DistributedSystem::acquireDisconnectLock();
-
- nativeCache = m_nativeptr->get()->create( );
+ auto nativeCache =
std::make_shared<native::Cache>(m_nativeptr->get()->create( ));
auto cache = Cache::Create( nativeCache );
CacheResolver::Add(nativeCache.get(), cache);
diff --git a/clicache/src/DistributedSystem.cpp
b/clicache/src/DistributedSystem.cpp
index 27d961ee..01018a0e 100644
--- a/clicache/src/DistributedSystem.cpp
+++ b/clicache/src/DistributedSystem.cpp
@@ -140,9 +140,9 @@ namespace Apache
// this we are calling after all .NET initialization required in
// each AppDomain
- auto nativeptr = native::DistributedSystem::create(mg_name.CharPtr,
cache->GetNative().get(),
+ auto nativeptr = native::DistributedSystem::create(mg_name.CharPtr,
config->GetNative());
- nativeptr->connect();
+ nativeptr->connect(cache->GetNative().get());
ManagedPostConnect(cache);
diff --git a/clicache/src/LocalRegion.cpp b/clicache/src/LocalRegion.cpp
index 821c28b4..782ad35c 100644
--- a/clicache/src/LocalRegion.cpp
+++ b/clicache/src/LocalRegion.cpp
@@ -201,8 +201,8 @@ namespace Apache
{
return false;
}
- std::unique_ptr<apache::geode::client::DataOutput> out1 =
m_nativeptr->get_shared_ptr()->getCache()->createDataOutput();
- std::unique_ptr<apache::geode::client::DataOutput> out2 =
m_nativeptr->get_shared_ptr()->getCache()->createDataOutput();
+ auto out1 =
m_nativeptr->get_shared_ptr()->getCache().createDataOutput();
+ auto out2 =
m_nativeptr->get_shared_ptr()->getCache().createDataOutput();
val1->toData(*out1);
val2->toData(*out2);
if ( out1->getBufferLength() != out2->getBufferLength() )
@@ -823,7 +823,7 @@ namespace Apache
generic<class TKey, class TValue>
IRegionService^ LocalRegion<TKey, TValue>::RegionService::get()
{
- return CacheResolver::Lookup(m_nativeptr->get()->getCache().get());
+ return CacheResolver::Lookup(&m_nativeptr->get()->getCache());
}
generic<class TKey, class TValue>
diff --git a/clicache/src/Region.cpp b/clicache/src/Region.cpp
index db9288c4..789eadc5 100644
--- a/clicache/src/Region.cpp
+++ b/clicache/src/Region.cpp
@@ -102,7 +102,7 @@ namespace Apache
auto rAttributes = this->Attributes;
auto poolName = rAttributes->PoolName;
if (poolName != nullptr) {
- auto poolManager = gcnew
PoolManager(m_nativeptr->get()->getCache()->getPoolManager());
+ auto poolManager = gcnew
PoolManager(m_nativeptr->get()->getCache().getPoolManager());
auto pool = poolManager->Find(poolName);
if (pool != nullptr && !pool->Destroyed) {
return pool->MultiuserAuthentication;
@@ -244,8 +244,8 @@ namespace Apache
{
return false;
}
- std::unique_ptr<native::DataOutput> out1 =
m_nativeptr->get_shared_ptr()->getCache()->createDataOutput();
- std::unique_ptr<native::DataOutput> out2 =
m_nativeptr->get_shared_ptr()->getCache()->createDataOutput();
+ auto out1 =
m_nativeptr->get_shared_ptr()->getCache().createDataOutput();
+ auto out2 =
m_nativeptr->get_shared_ptr()->getCache().createDataOutput();
val1->toData(*out1);
val2->toData(*out2);
@@ -726,7 +726,7 @@ namespace Apache
if (values != nullptr) {
valuesPtr = std::make_shared<native::HashMapOfCacheable>();
}
- std::shared_ptr<native::Serializable> callbackptr =
Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg,
m_nativeptr->get()->getCache().get());
+ auto callbackptr =
Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg,
&m_nativeptr->get()->getCache());
native::HashMapOfCacheable native_value;
try
{
@@ -1003,7 +1003,7 @@ namespace Apache
generic<class TKey, class TValue>
IRegionService^ Region<TKey, TValue>::RegionService::get()
{
- return CacheResolver::Lookup(m_nativeptr->get()->getCache().get());
+ return CacheResolver::Lookup(&m_nativeptr->get()->getCache());
}
generic<class TKey, class TValue>
diff --git a/cppcache/include/geode/Cache.hpp b/cppcache/include/geode/Cache.hpp
index e88766fd..eb731c6d 100644
--- a/cppcache/include/geode/Cache.hpp
+++ b/cppcache/include/geode/Cache.hpp
@@ -241,6 +241,8 @@ class CPPCACHE_EXPORT Cache : public GeodeCache,
*/
virtual ~Cache();
+ Cache(Cache&& other) noexcept;
+
private:
/**
* @brief constructors
diff --git a/cppcache/include/geode/CacheFactory.hpp
b/cppcache/include/geode/CacheFactory.hpp
index 2a5211fb..ccb6d0d1 100644
--- a/cppcache/include/geode/CacheFactory.hpp
+++ b/cppcache/include/geode/CacheFactory.hpp
@@ -61,7 +61,7 @@ class CPPCACHE_EXPORT CacheFactory
/**
* To create the instance of {@link Cache}.
*/
- std::shared_ptr<Cache> create();
+ Cache create();
/** Returns the version of the cache implementation.
* For the 1.0 release of Geode, the string returned is <code>1.0</code>.
@@ -139,13 +139,10 @@ class CPPCACHE_EXPORT CacheFactory
bool pdxReadSerialized;
std::shared_ptr<AuthInitialize> authInitialize;
- std::shared_ptr<Cache> create(
+ Cache create(
const char* name,
const std::shared_ptr<CacheAttributes>& attrs = nullptr);
- void create_(const char* name, const char* id_data,
- std::shared_ptr<Cache>& cptr, bool readPdxSerialized);
-
// no instances allowed
CacheFactory();
CacheFactory(const std::shared_ptr<Properties> dsProps);
diff --git a/cppcache/include/geode/DistributedSystem.hpp
b/cppcache/include/geode/DistributedSystem.hpp
index 9251c237..8b4f3090 100644
--- a/cppcache/include/geode/DistributedSystem.hpp
+++ b/cppcache/include/geode/DistributedSystem.hpp
@@ -64,14 +64,13 @@ class CPPCACHE_EXPORT DistributedSystem {
* product installation directory cannot be determined
**/
static std::unique_ptr<DistributedSystem> create(
- const std::string& name, Cache* cache,
- const std::shared_ptr<Properties>& configPtr = nullptr);
+ const std::string& name, const std::shared_ptr<Properties>& configPtr =
nullptr);
/**
* @brief connects from the distributed system
* @throws AlreadyConnectedException if this call has succeeded once before
*/
- void connect();
+ void connect(Cache* cache);
/**
* @brief disconnect from the distributed system
@@ -104,7 +103,6 @@ class CPPCACHE_EXPORT DistributedSystem {
* @brief constructors
*/
DistributedSystem(const std::string& name,
- std::unique_ptr<statistics::StatisticsManager> statMngr,
std::unique_ptr<SystemProperties> sysProps);
private:
diff --git a/cppcache/include/geode/PoolManager.hpp
b/cppcache/include/geode/PoolManager.hpp
index 57c04dea..e71f9c37 100644
--- a/cppcache/include/geode/PoolManager.hpp
+++ b/cppcache/include/geode/PoolManager.hpp
@@ -36,6 +36,7 @@ namespace client {
class ThinClientPoolDM;
class FunctionService;
+class CacheImpl;
typedef std::unordered_map<std::string, std::shared_ptr<Pool>> HashMapOfPools;
@@ -52,7 +53,6 @@ typedef std::unordered_map<std::string,
std::shared_ptr<Pool>> HashMapOfPools;
*/
class CPPCACHE_EXPORT PoolManager {
public:
- PoolManager(const Cache& cache);
/**
* Creates a new {@link PoolFactory pool factory},
@@ -110,6 +110,8 @@ class CPPCACHE_EXPORT PoolManager {
class Impl;
std::unique_ptr<Impl, void (*)(Impl*)> m_pimpl;
+ PoolManager(CacheImpl* cache);
+
friend Cache;
friend CacheImpl;
friend RegionFactory;
diff --git a/cppcache/include/geode/Region.hpp
b/cppcache/include/geode/Region.hpp
index d5bbe340..da31e7e4 100644
--- a/cppcache/include/geode/Region.hpp
+++ b/cppcache/include/geode/Region.hpp
@@ -1452,16 +1452,16 @@ class CPPCACHE_EXPORT Region : public
std::enable_shared_from_this<Region> {
virtual const std::shared_ptr<Pool>& getPool() = 0;
- inline std::shared_ptr<Cache>& getCache() { return m_cache; }
+ inline Cache& getCache() { return *m_cache; }
Region(const Region&) = delete;
Region& operator=(const Region&) = delete;
protected:
- Region(const std::shared_ptr<Cache>& cache);
+ Region(Cache* cache);
virtual ~Region();
- mutable std::shared_ptr<Cache> m_cache;
+ mutable Cache* m_cache;
FRIEND_STD_SHARED_PTR(Region)
};
diff --git a/cppcache/include/geode/TypeRegistry.hpp
b/cppcache/include/geode/TypeRegistry.hpp
index 577ff11c..14b852c7 100644
--- a/cppcache/include/geode/TypeRegistry.hpp
+++ b/cppcache/include/geode/TypeRegistry.hpp
@@ -26,11 +26,13 @@
namespace apache {
namespace geode {
namespace client {
+
+class CacheImpl;
class PdxSerializer;
class TypeRegistry {
public:
- TypeRegistry(const Cache& cache);
+ TypeRegistry(CacheImpl* cache);
/**
* @brief register an instance factory method for a given type.
@@ -57,9 +59,9 @@ class TypeRegistry {
*/
void registerPdxSerializer(std::shared_ptr<PdxSerializer> pdxSerializer);
- protected:
private:
- const Cache& m_cache;
+
+ CacheImpl* m_cache;
};
} // namespace client
} // namespace geode
diff --git a/cppcache/integration-test/CacheHelper.cpp
b/cppcache/integration-test/CacheHelper.cpp
index 28c1cb1a..2ebf3216 100644
--- a/cppcache/integration-test/CacheHelper.cpp
+++ b/cppcache/integration-test/CacheHelper.cpp
@@ -86,7 +86,8 @@ CacheHelper::CacheHelper(const char* member_id,
pp = Properties::create();
}
- cachePtr = CacheFactory::createCacheFactory(pp)->create();
+ auto cacheFactory = CacheFactory::createCacheFactory(pp);
+ cachePtr = std::make_shared<Cache>(cacheFactory->create());
m_doDisconnect = false;
@@ -115,7 +116,8 @@ CacheHelper::CacheHelper(const char* member_id, const char*
cachexml,
CacheHelper::createDuplicateXMLFile(newFile, tmpXmlFile);
pp->insert("cache-xml-file", newFile.c_str());
}
- cachePtr = CacheFactory::createCacheFactory(pp)->create();
+ auto cacheFactory = CacheFactory::createCacheFactory(pp);
+ cachePtr = std::make_shared<Cache>(cacheFactory->create());
m_doDisconnect = false;
}
@@ -127,7 +129,8 @@ CacheHelper::CacheHelper(const std::shared_ptr<Properties>&
configPtr,
pp = Properties::create();
}
- cachePtr = CacheFactory::createCacheFactory(pp)->create();
+ auto cacheFactory = CacheFactory::createCacheFactory(pp);
+ cachePtr = std::make_shared<Cache>(cacheFactory->create());
auto poolFactory = cachePtr->getPoolManager().createFactory();
addServerLocatorEPs("localhost:40404", poolFactory);
@@ -156,9 +159,9 @@ CacheHelper::CacheHelper(const bool isThinclient,
}
try {
LOG(" in cachehelper before createCacheFactory");
- cachePtr = CacheFactory::createCacheFactory(pp)
- ->setAuthInitialize(authInitialize)
- ->create();
+ auto cacheFactory = CacheFactory::createCacheFactory(pp)
+ ->setAuthInitialize(authInitialize);
+ cachePtr = std::make_shared<Cache>(cacheFactory->create());
m_doDisconnect = false;
} catch (const Exception& excp) {
LOG("Geode exception while creating cache, logged in following line");
@@ -177,7 +180,8 @@ CacheHelper::CacheHelper(const bool isThinclient,
}
try {
LOG(" in cachehelper before createCacheFactory");
- cachePtr = CacheFactory::createCacheFactory(pp)->create();
+ auto cacheFactory = CacheFactory::createCacheFactory(pp);
+ cachePtr = std::make_shared<Cache>(cacheFactory->create());
m_doDisconnect = false;
} catch (const Exception& excp) {
LOG("Geode exception while creating cache, logged in following line");
@@ -201,7 +205,7 @@ CacheHelper::CacheHelper(const bool isThinclient, bool
pdxIgnoreUnreadFields,
LOGINFO("pdxIgnoreUnreadFields = %d ", pdxIgnoreUnreadFields);
cfPtr->setPdxReadSerialized(pdxReadSerialized);
cfPtr->setPdxIgnoreUnreadFields(pdxIgnoreUnreadFields);
- cachePtr = cfPtr->create();
+ cachePtr = std::make_shared<Cache>(cfPtr->create());
m_doDisconnect = false;
} catch (const Exception& excp) {
LOG("Geode exception while creating cache, logged in following line");
@@ -225,7 +229,7 @@ CacheHelper::CacheHelper(const bool isthinClient, const
char* poolName,
try {
auto cacheFac = CacheFactory::createCacheFactory(pp);
- cachePtr = cacheFac->create();
+ cachePtr = std::make_shared<Cache>(cacheFac->create());
auto poolFactory = cachePtr->getPoolManager().createFactory();
@@ -274,7 +278,7 @@ CacheHelper::CacheHelper(const int redundancyLevel,
}
auto cacheFac = CacheFactory::createCacheFactory(pp);
- cachePtr = cacheFac->create();
+ cachePtr = std::make_shared<Cache>(cacheFac->create());
m_doDisconnect = false;
}
diff --git a/cppcache/integration-test/QueryHelper.hpp
b/cppcache/integration-test/QueryHelper.hpp
index 8eb0b796..97eebabc 100644
--- a/cppcache/integration-test/QueryHelper.hpp
+++ b/cppcache/integration-test/QueryHelper.hpp
@@ -251,7 +251,7 @@ void
QueryHelper::populatePositionPdxData(std::shared_ptr<Region>& rptr,
void QueryHelper::populatePDXObject(std::shared_ptr<Region>& rptr) {
// Register PdxType Object
- CacheImpl* cacheImpl =
CacheRegionHelper::getCacheImpl(rptr->getCache().get());
+ CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(&rptr->getCache());
cacheImpl->getSerializationRegistry()->addPdxType(PdxTests::PdxType::createDeserializable);
LOG("PdxObject Registered Successfully....");
diff --git a/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
b/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
index 0d4484b2..1f3b15a0 100644
--- a/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
+++ b/cppcache/integration-test/ThinClientLocalCacheLoader.hpp
@@ -104,7 +104,7 @@ DUNIT_TASK_DEFINITION(CLIENT1, SetupClient)
clientXml += clientXmlFile;
auto cacheFactoryPtr = CacheFactory::createCacheFactory()->set(
"cache-xml-file", clientXml.c_str());
- cachePtr = cacheFactoryPtr->create();
+ cachePtr = std::make_shared<Cache>(cacheFactoryPtr->create());
LOGINFO("Created the Geode Cache");
// Get the example Region from the Cache which is declared in the Cache XML
diff --git a/cppcache/integration-test/ThinClientMultipleCaches.hpp
b/cppcache/integration-test/ThinClientMultipleCaches.hpp
index 0cec1645..cb9b2932 100644
--- a/cppcache/integration-test/ThinClientMultipleCaches.hpp
+++ b/cppcache/integration-test/ThinClientMultipleCaches.hpp
@@ -47,7 +47,7 @@ DUNIT_TASK_DEFINITION(SERVER1, CreateServer1)
LOG("SERVER1 started");
}
END_TASK_DEFINITION
-std::shared_ptr<Region> createRegionFromCache(std::shared_ptr<Cache> cache) {
+std::shared_ptr<Region> createRegionFromCache(std::shared_ptr<Cache>& cache) {
auto poolFactory = cache->getPoolManager().createFactory();
CacheHelper::getHelper().addServerLocatorEPs(locatorsG, poolFactory, true);
poolFactory->create("DistRegionAck");
@@ -57,10 +57,10 @@ std::shared_ptr<Region>
createRegionFromCache(std::shared_ptr<Cache> cache) {
DUNIT_TASK_DEFINITION(CLIENT1, SetupAndTestMutlipleCaches)
{
auto factory = CacheFactory::createCacheFactory();
- auto cache1 = factory->create();
+ auto cache1 = std::make_shared<Cache>(factory->create());
auto region1 = createRegionFromCache(cache1);
- auto cache2 = factory->create();
+ auto cache2 = std::make_shared<Cache>(factory->create());
auto region2 = createRegionFromCache(cache2);
region1->put("a", "key");
diff --git a/cppcache/integration-test/testAttributesFactory.cpp
b/cppcache/integration-test/testAttributesFactory.cpp
index e667b5ae..fdc132fc 100644
--- a/cppcache/integration-test/testAttributesFactory.cpp
+++ b/cppcache/integration-test/testAttributesFactory.cpp
@@ -28,7 +28,7 @@ using namespace apache::geode::client;
BEGIN_TEST(REGION_FACTORY)
{
auto cf = CacheFactory::createCacheFactory();
- auto cache = cf->create();
+ auto cache = std::make_shared<Cache>(cf->create());
auto rf = cache->createRegionFactory(LOCAL);
/*see bug no #865 */
@@ -55,7 +55,7 @@ BEGIN_TEST(REGION_FACTORY)
region = nullptr;
auto cf1 = CacheFactory::createCacheFactory();
- auto cache1 = cf1->create();
+ auto cache1 = std::make_shared<Cache>(cf1->create());
auto rf1 = cache1->createRegionFactory(LOCAL);
/*see bug no #865 */
diff --git a/cppcache/integration-test/testAttributesMutator.cpp
b/cppcache/integration-test/testAttributesMutator.cpp
index 9ae54192..6e71b3c9 100644
--- a/cppcache/integration-test/testAttributesMutator.cpp
+++ b/cppcache/integration-test/testAttributesMutator.cpp
@@ -38,7 +38,7 @@ class TestData {
DUNIT_TASK(A, Init)
{
auto cacheFactoryPtr = CacheFactory::createCacheFactory();
- Test.m_cache = cacheFactoryPtr->create();
+ Test.m_cache = std::make_shared<Cache>(cacheFactoryPtr->create());
AttributesFactory af;
af.setEntryTimeToLive(ExpirationAction::LOCAL_INVALIDATE,
diff --git a/cppcache/integration-test/testCache.cpp
b/cppcache/integration-test/testCache.cpp
index c6b4606b..466d353f 100644
--- a/cppcache/integration-test/testCache.cpp
+++ b/cppcache/integration-test/testCache.cpp
@@ -41,7 +41,7 @@ BEGIN_TEST(CacheFunction)
std::cout << "create Cache with name=" << host_name
<< " and unitialized system" << std::endl;
auto cacheFactoryPtr = CacheFactory::createCacheFactory();
- cptr = cacheFactoryPtr->create();
+ cptr = std::make_shared<Cache>(cacheFactoryPtr->create());
AttributesFactory attrFac;
std::shared_ptr<RegionAttributes> rAttr;
std::cout << "create RegionAttributes" << std::endl;
diff --git a/cppcache/integration-test/testConnect.cpp
b/cppcache/integration-test/testConnect.cpp
index c0be8f33..e831bee3 100644
--- a/cppcache/integration-test/testConnect.cpp
+++ b/cppcache/integration-test/testConnect.cpp
@@ -26,9 +26,9 @@ const char* host_name = "Suds";
DUNIT_TASK(s1p1, CreateRegionOne)
{
auto factory = CacheFactory::createCacheFactory();
- auto cache = factory->create();
+ auto cache = std::make_shared<Cache>(factory->create());
try {
- cache->getDistributedSystem().connect();
+ cache->getDistributedSystem().connect(cache.get());
FAIL("Expected an exception.");
} catch (const AlreadyConnectedException& ex) {
LOG("Got expected exception.");
diff --git a/cppcache/integration-test/testExpiration.cpp
b/cppcache/integration-test/testExpiration.cpp
index ff578c1e..842e6290 100644
--- a/cppcache/integration-test/testExpiration.cpp
+++ b/cppcache/integration-test/testExpiration.cpp
@@ -36,7 +36,7 @@ size_t getNumOfEntries(std::shared_ptr<Region>& R1) {
void startDSandCreateCache(std::shared_ptr<Cache>& cache) {
auto pp = Properties::create();
auto cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
- cache = cacheFactoryPtr->create();
+ cache = std::make_shared<Cache>(cacheFactoryPtr->create());
ASSERT(cache != nullptr, "cache not equal to null expected");
}
diff --git a/cppcache/integration-test/testLinkage.cpp
b/cppcache/integration-test/testLinkage.cpp
index 53108e7c..d2bcd867 100644
--- a/cppcache/integration-test/testLinkage.cpp
+++ b/cppcache/integration-test/testLinkage.cpp
@@ -79,7 +79,7 @@ BEGIN_TEST(LinkageTest)
std::shared_ptr<Cache> cachePtr;
auto cacheFactoryPtr = CacheFactory::createCacheFactory();
- cachePtr = cacheFactoryPtr->create();
+ cachePtr = std::make_shared<Cache>(cacheFactoryPtr->create());
// Cache cache;
ASSERT((!cachePtr->isClosed()), "cache shouldn't be closed.");
std::shared_ptr<Region> rptr;
diff --git a/cppcache/integration-test/testOverflowPutGetSqLite.cpp
b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
index 4ed7461f..1d23b931 100644
--- a/cppcache/integration-test/testOverflowPutGetSqLite.cpp
+++ b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
@@ -303,7 +303,8 @@ void createRegion(std::shared_ptr<Region>& regionPtr, const
char* regionName,
std::shared_ptr<Properties>& cacheProps,
std::shared_ptr<Properties>& sqLiteProps) {
auto cacheFactoryPtr = CacheFactory::createCacheFactory(cacheProps);
- auto cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cachePtr = std::make_shared<Cache>(
+ CacheFactory::createCacheFactory()->create());
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
auto regionFactory = cachePtr->createRegionFactory(LOCAL);
regionFactory.setCachingEnabled(true);
@@ -466,7 +467,8 @@ END_TEST(OverFlowTest_absPath)
BEGIN_TEST(OverFlowTest_SqLiteFull)
{
auto cacheFactoryPtr = CacheFactory::createCacheFactory();
- auto cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cachePtr = std::make_shared<Cache>(
+ CacheFactory::createCacheFactory()->create());
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
auto regionFactory = cachePtr->createRegionFactory(LOCAL);
regionFactory.setCachingEnabled(true);
@@ -509,7 +511,8 @@ BEGIN_TEST(OverFlowTest_HeapLRU)
pp->insert("heap-lru-limit", 1);
pp->insert("heap-lru-delta", 10);
auto cacheFactoryPtr = CacheFactory::createCacheFactory(pp);
- auto cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cachePtr = std::make_shared<Cache>(
+ CacheFactory::createCacheFactory()->create());
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
auto regionFactory = cachePtr->createRegionFactory(LOCAL);
regionFactory.setCachingEnabled(true);
@@ -570,7 +573,8 @@ END_TEST(OverFlowTest_HeapLRU)
BEGIN_TEST(OverFlowTest_MultiThreaded)
{
/** Creating a cache to manage regions. */
- auto cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cachePtr = std::make_shared<Cache>(
+ CacheFactory::createCacheFactory()->create());
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
std::shared_ptr<RegionAttributes> attrsPtr;
@@ -611,7 +615,8 @@ END_TEST(OverFlowTest_MultiThreaded)
BEGIN_TEST(OverFlowTest_PutGetAll)
{
/** Creating a cache to manage regions. */
- auto cachePtr = CacheFactory::createCacheFactory()->create();
+ auto cachePtr = std::make_shared<Cache>(
+ CacheFactory::createCacheFactory()->create());
ASSERT(cachePtr != nullptr, "Expected cache to be NON-nullptr");
std::shared_ptr<RegionAttributes> attrsPtr;
diff --git a/cppcache/integration-test/testPoolFactory.cpp
b/cppcache/integration-test/testPoolFactory.cpp
index 6b9d89dc..6b502d29 100644
--- a/cppcache/integration-test/testPoolFactory.cpp
+++ b/cppcache/integration-test/testPoolFactory.cpp
@@ -29,9 +29,8 @@ BEGIN_TEST(POOLFACTORY)
{
auto cacheFactory = CacheFactory::createCacheFactory();
ASSERT(cacheFactory != nullptr, "CacheFactory was a nullptr");
- auto cachePtr = cacheFactory->create();
- ASSERT(cachePtr != nullptr, "CachePtr was a nullptr");
- auto poolFactory = cachePtr->getPoolManager().createFactory();
+ auto cache = cacheFactory->create();
+ auto poolFactory = cache.getPoolManager().createFactory();
ASSERT(poolFactory != nullptr, "poolFactory was a nullptr");
auto& testPoolFactory = poolFactory->setSubscriptionEnabled(true);
bool test = poolFactory.get() ==
std::addressof<PoolFactory>(testPoolFactory);
diff --git a/cppcache/integration-test/testRegionTemplateArgs.cpp
b/cppcache/integration-test/testRegionTemplateArgs.cpp
index 18357e3d..4ca2466d 100644
--- a/cppcache/integration-test/testRegionTemplateArgs.cpp
+++ b/cppcache/integration-test/testRegionTemplateArgs.cpp
@@ -36,7 +36,7 @@ bool CheckBytesEqual(std::shared_ptr<CacheableBytes> result,
BEGIN_TEST(CheckTemplates)
{
auto cacheFactoryPtr = CacheFactory::createCacheFactory();
- auto cache = cacheFactoryPtr->create();
+ auto cache = std::make_shared<Cache>(cacheFactoryPtr->create());
AttributesFactory afact;
std::shared_ptr<RegionAttributes> attrs = afact.createRegionAttributes();
std::shared_ptr<Region> regPtr;
diff --git a/cppcache/integration-test/testThinClientCqDurable.cpp
b/cppcache/integration-test/testThinClientCqDurable.cpp
index f3718adf..c9c88e81 100644
--- a/cppcache/integration-test/testThinClientCqDurable.cpp
+++ b/cppcache/integration-test/testThinClientCqDurable.cpp
@@ -191,7 +191,7 @@ void RunDurableCqClient() {
// Create a Geode Cache Programmatically.
auto cacheFactory = CacheFactory::createCacheFactory(pp);
- auto cachePtr = cacheFactory->create();
+ auto cachePtr = std::make_shared<Cache>(cacheFactory->create());
auto poolFactory = cachePtr->getPoolManager().createFactory();
poolFactory->setSubscriptionEnabled(true)
.setSubscriptionAckInterval(std::chrono::milliseconds(5000))
@@ -253,7 +253,7 @@ void RunFeederClient() {
auto cacheFactory = CacheFactory::createCacheFactory();
LOGINFO("Feeder connected to the Geode Distributed System");
- auto cachePtr = cacheFactory->create();
+ auto cachePtr = std::make_shared<Cache>(cacheFactory->create());
LOGINFO("Created the Geode Cache");
@@ -285,7 +285,7 @@ void RunFeederClient1() {
auto cacheFactory = CacheFactory::createCacheFactory();
LOGINFO("Feeder connected to the Geode Distributed System");
- auto cachePtr = cacheFactory->create();
+ auto cachePtr = std::make_shared<Cache>(cacheFactory->create());
LOGINFO("Created the Geode Cache");
diff --git a/cppcache/integration-test/testXmlCacheCreationWithOverFlow.cpp
b/cppcache/integration-test/testXmlCacheCreationWithOverFlow.cpp
index 54256dee..94ee5da1 100644
--- a/cppcache/integration-test/testXmlCacheCreationWithOverFlow.cpp
+++ b/cppcache/integration-test/testXmlCacheCreationWithOverFlow.cpp
@@ -51,7 +51,8 @@ int testXmlCacheCreationWithOverflow() {
try {
std::string filePath = directory + "/resources/non-existent.xml";
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
return -1;
} catch (CacheXmlException& ex) {
std::cout << "CacheXmlException: msg = " << ex.what() << std::endl;
@@ -65,7 +66,8 @@ int testXmlCacheCreationWithOverflow() {
try {
std::string filePath = directory + "/resources/valid_overflowAttr.xml";
std::cout << "getPdxIgnoreUnreadFields should return true.1" << std::endl;
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
if (cptr->getPdxIgnoreUnreadFields() != false) {
std::cout << "getPdxIgnoreUnreadFields should return true." << std::endl;
return -1;
@@ -246,7 +248,8 @@ int testXmlCacheCreationWithOverflow() {
try {
std::string filePath = directory + "/invalid_overflowAttr1.xml";
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
return -1;
} catch (Exception& ex) {
std::cout << std::endl;
@@ -265,7 +268,8 @@ int testXmlCacheCreationWithOverflow() {
try {
std::string filePath = directory + "/invalid_overflowAttr2.xml";
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
return -1;
} catch (CacheXmlException& ex) {
std::cout << std::endl;
@@ -285,7 +289,8 @@ int testXmlCacheCreationWithOverflow() {
try {
std::string filePath = directory + "/invalid_overflowAttr3.xml";
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
return -1;
} catch (Exception& ex) {
std::cout << std::endl;
diff --git a/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
b/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
index a09d8434..2bed9341 100644
--- a/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
+++ b/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
@@ -276,7 +276,8 @@ int testXmlCacheCreationWithPools() {
std::string filePath = "valid_cache_pool.xml";
std::string duplicateFile;
CacheHelper::createDuplicateXMLFile(duplicateFile, filePath);
- cptr = cacheFactory->set("cache-xml-file",
duplicateFile.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", duplicateFile.c_str())->create());
if (cptr->getPdxIgnoreUnreadFields() != true) {
std::cout << "getPdxIgnoreUnreadFields should return true." << std::endl;
return -1;
@@ -415,7 +416,8 @@ int testXmlCacheCreationWithPools() {
std::string filePath = "invalid_cache_pool.xml";
std::string duplicateFile;
CacheHelper::createDuplicateXMLFile(duplicateFile, filePath);
- cptr = cacheFactory->set("cache-xml-file",
duplicateFile.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", duplicateFile.c_str())->create());
return -1;
} catch (Exception& ex) {
std::cout << "EXPECTED EXCEPTION" << std::endl;
@@ -428,7 +430,8 @@ int testXmlCacheCreationWithPools() {
std::string filePath = "invalid_cache_pool2.xml";
std::string duplicateFile;
CacheHelper::createDuplicateXMLFile(duplicateFile, filePath);
- cptr = cacheFactory->set("cache-xml-file",
duplicateFile.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", duplicateFile.c_str())->create());
return -1;
} catch (Exception& ex) {
std::cout << "EXPECTED EXCEPTION" << std::endl;
@@ -441,7 +444,8 @@ int testXmlCacheCreationWithPools() {
std::string filePath = "invalid_cache_pool3.xml";
std::string duplicateFile;
CacheHelper::createDuplicateXMLFile(duplicateFile, filePath);
- cptr = cacheFactory->set("cache-xml-file",
duplicateFile.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", duplicateFile.c_str())->create());
return -1;
} catch (Exception& ex) {
std::cout << "EXPECTED EXCEPTION" << std::endl;
@@ -454,7 +458,8 @@ int testXmlCacheCreationWithPools() {
std::string filePath = "invalid_cache_pool4.xml";
std::string duplicateFile;
CacheHelper::createDuplicateXMLFile(duplicateFile, filePath);
- cptr = cacheFactory->set("cache-xml-file",
duplicateFile.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", duplicateFile.c_str())->create());
return -1;
} catch (Exception& ex) {
std::cout << "EXPECTED EXCEPTION" << std::endl;
@@ -495,7 +500,8 @@ int testXmlDeclarativeCacheCreation() {
try {
std::string filePath =
directory + "/resources/valid_declarative_cache_creation.xml";
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
} catch (Exception& ex) {
std::cout << "Exception: msg = " << ex.what() << std::endl;
diff --git a/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
b/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
index 6d2fcc3a..c2b4e5b1 100644
--- a/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
+++ b/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
@@ -50,7 +50,8 @@ int testXmlCacheCreationWithRefid(const char* fileName) {
try {
std::string filePath = directory + fileName;
- cptr = cacheFactory->set("cache-xml-file", filePath.c_str())->create();
+ cptr = std::make_shared<Cache>(
+ cacheFactory->set("cache-xml-file", filePath.c_str())->create());
if (cptr->getPdxIgnoreUnreadFields() != false) {
std::cout << "getPdxIgnoreUnreadFields should return false." <<
std::endl;
return -1;
diff --git a/cppcache/src/Cache.cpp b/cppcache/src/Cache.cpp
index 40d21422..d10bf0e2 100644
--- a/cppcache/src/Cache.cpp
+++ b/cppcache/src/Cache.cpp
@@ -122,27 +122,38 @@ std::vector<std::shared_ptr<Region>> Cache::rootRegions()
{
RegionFactory Cache::createRegionFactory(RegionShortcut preDefinedRegion) {
return m_cacheImpl->createRegionFactory(preDefinedRegion);
}
- std::shared_ptr<QueryService> Cache::getQueryService() {
- return m_cacheImpl->getQueryService();
- }
- std::shared_ptr<QueryService> Cache::getQueryService(const char* poolName) {
- return m_cacheImpl->getQueryService(poolName);
- }
- std::shared_ptr<CacheTransactionManager> Cache::getCacheTransactionManager() {
- return m_cacheImpl->getCacheTransactionManager();
- }
- TypeRegistry& Cache::getTypeRegistry() { return *(m_typeRegistry.get()); }
+std::shared_ptr<QueryService> Cache::getQueryService() {
+ return m_cacheImpl->getQueryService();
+}
+
+std::shared_ptr<QueryService> Cache::getQueryService(const char* poolName) {
+ return m_cacheImpl->getQueryService(poolName);
+}
+
+std::shared_ptr<CacheTransactionManager> Cache::getCacheTransactionManager() {
+ return m_cacheImpl->getCacheTransactionManager();
+}
+
+TypeRegistry& Cache::getTypeRegistry() { return *(m_typeRegistry.get()); }
+
+Cache::Cache(const std::string& name, std::shared_ptr<Properties> dsProp,
+ bool ignorePdxUnreadFields, bool readPdxSerialized,
+ const std::shared_ptr<AuthInitialize>& authInitialize) {
+ m_cacheImpl = std::unique_ptr<CacheImpl>(
+ new CacheImpl(this, name,
+ DistributedSystem::create(DEFAULT_DS_NAME, dsProp),
+ ignorePdxUnreadFields, readPdxSerialized, authInitialize));
+ m_cacheImpl->getDistributedSystem().connect(this);
+ m_typeRegistry = std::unique_ptr<TypeRegistry>(
+ new TypeRegistry(m_cacheImpl.get()));
+}
+
+Cache::Cache(Cache&& other) noexcept :
+ m_cacheImpl(std::move(other.m_cacheImpl)),
+ m_typeRegistry(std::move(other.m_typeRegistry)) {
- Cache::Cache(const std::string& name, std::shared_ptr<Properties> dsProp,
- bool ignorePdxUnreadFields, bool readPdxSerialized,
- const std::shared_ptr<AuthInitialize>& authInitialize) {
- auto dsPtr = DistributedSystem::create(DEFAULT_DS_NAME, this, dsProp);
- dsPtr->connect();
- m_cacheImpl = std::unique_ptr<CacheImpl>(
- new CacheImpl(this, name, std::move(dsPtr), ignorePdxUnreadFields,
- readPdxSerialized, authInitialize));
- m_typeRegistry = std::unique_ptr<TypeRegistry>(new TypeRegistry(*this));
+ m_cacheImpl->setCache(this);
}
Cache::~Cache() = default;
@@ -176,7 +187,7 @@ bool Cache::isPoolInMultiuserMode(std::shared_ptr<Region>
regionPtr) {
const char* poolName = regionPtr->getAttributes()->getPoolName();
if (poolName != nullptr) {
- auto poolPtr = regionPtr->getCache()->getPoolManager().find(poolName);
+ auto poolPtr = regionPtr->getCache().getPoolManager().find(poolName);
if (poolPtr != nullptr && !poolPtr->isDestroyed()) {
return poolPtr->getMultiuserAuthentication();
}
diff --git a/cppcache/src/CacheFactory.cpp b/cppcache/src/CacheFactory.cpp
index abe0058f..1d0d2f97 100644
--- a/cppcache/src/CacheFactory.cpp
+++ b/cppcache/src/CacheFactory.cpp
@@ -55,20 +55,6 @@ std::shared_ptr<CacheFactory>
CacheFactory::createCacheFactory(
return std::make_shared<CacheFactory>(configPtr);
}
-void CacheFactory::create_(const char* name, const char* id_data,
- std::shared_ptr<Cache>& cptr, bool
readPdxSerialized) {
- cptr = nullptr;
- if (name == nullptr) {
- throw IllegalArgumentException("CacheFactory::create: name is nullptr");
- }
- if (name[0] == '\0') {
- name = "NativeCache";
- }
-
- cptr = std::make_shared<Cache>(name, dsProp, ignorePdxUnreadFields,
- readPdxSerialized, authInitialize);
-} // namespace client
-
const char* CacheFactory::getVersion() { return PRODUCT_VERSION; }
const char* CacheFactory::getProductDescription() {
@@ -87,76 +73,83 @@ CacheFactory::CacheFactory(const
std::shared_ptr<Properties> dsProps) {
pdxReadSerialized = false;
this->dsProp = dsProps;
}
- std::shared_ptr<Cache> CacheFactory::create() {
- ACE_Guard<ACE_Recursive_Thread_Mutex> connectGuard(*g_disconnectLock);
- LOGFINE("CacheFactory called DistributedSystem::connect");
- auto cache = create(DEFAULT_CACHE_NAME, nullptr);
+Cache CacheFactory::create() {
+ ACE_Guard<ACE_Recursive_Thread_Mutex> connectGuard(*g_disconnectLock);
- auto& cacheImpl = cache->m_cacheImpl;
- const auto& serializationRegistry = cacheImpl->getSerializationRegistry();
- const auto& pdxTypeRegistry = cacheImpl->getPdxTypeRegistry();
- const auto& memberListForVersionStamp =
- std::ref(*(cacheImpl->getMemberListForVersionStamp()));
+ LOGFINE("CacheFactory called DistributedSystem::connect");
+ auto cache = create(DEFAULT_CACHE_NAME, nullptr);
- serializationRegistry->addType2(
- std::bind(TXCommitMessage::create, memberListForVersionStamp));
+ auto& cacheImpl = cache.m_cacheImpl;
+ const auto& serializationRegistry = cacheImpl->getSerializationRegistry();
+ const auto& pdxTypeRegistry = cacheImpl->getPdxTypeRegistry();
+ const auto& memberListForVersionStamp =
+ std::ref(*(cacheImpl->getMemberListForVersionStamp()));
- serializationRegistry->addType(
- GeodeTypeIds::PdxType,
- std::bind(PdxType::CreateDeserializable, pdxTypeRegistry));
+ serializationRegistry->addType2(
+ std::bind(TXCommitMessage::create, memberListForVersionStamp));
- serializationRegistry->addType(
- std::bind(VersionTag::createDeserializable, memberListForVersionStamp));
+ serializationRegistry->addType(
+ GeodeTypeIds::PdxType,
+ std::bind(PdxType::CreateDeserializable, pdxTypeRegistry));
- serializationRegistry->addType2(
- GeodeTypeIdsImpl::DiskVersionTag,
- std::bind(DiskVersionTag::createDeserializable,
- memberListForVersionStamp));
+ serializationRegistry->addType(
+ std::bind(VersionTag::createDeserializable, memberListForVersionStamp));
- serializationRegistry->setPdxTypeHandler([](DataInput& dataInput) {
- return PdxHelper::deserializePdx(dataInput, false);
- });
+ serializationRegistry->addType2(
+ GeodeTypeIdsImpl::DiskVersionTag,
+ std::bind(DiskVersionTag::createDeserializable,
+ memberListForVersionStamp));
-
pdxTypeRegistry->setPdxIgnoreUnreadFields(cache->getPdxIgnoreUnreadFields());
- pdxTypeRegistry->setPdxReadSerialized(cache->getPdxReadSerialized());
+ serializationRegistry->setPdxTypeHandler([](DataInput& dataInput) {
+ return PdxHelper::deserializePdx(dataInput, false);
+ });
- return cache;
+ pdxTypeRegistry->setPdxIgnoreUnreadFields(cache.getPdxIgnoreUnreadFields());
+ pdxTypeRegistry->setPdxReadSerialized(cache.getPdxReadSerialized());
+
+ return cache;
}
-std::shared_ptr<Cache> CacheFactory::create(
+
+Cache CacheFactory::create(
const char* name,
const std::shared_ptr<CacheAttributes>& attrs /*= nullptr*/) {
ACE_Guard<ACE_Recursive_Thread_Mutex> connectGuard(*g_disconnectLock);
- std::shared_ptr<Cache> cptr;
- create_(name, "", cptr, pdxReadSerialized);
- cptr->m_cacheImpl->setAttributes(attrs);
+ if (name == nullptr) {
+ throw IllegalArgumentException("CacheFactory::create: name is nullptr");
+ }
+ if (name[0] == '\0') {
+ name = "NativeCache";
+ }
+
+ auto cache = Cache(name, dsProp, ignorePdxUnreadFields,
+ pdxReadSerialized, authInitialize);
+ cache.m_cacheImpl->setAttributes(attrs);
try {
- const char* cacheXml =
- cptr->getDistributedSystem().getSystemProperties().cacheXMLFile();
+ const auto cacheXml =
+ cache.getDistributedSystem().getSystemProperties().cacheXMLFile();
if (cacheXml != 0 && strlen(cacheXml) > 0) {
- cptr->initializeDeclarativeCache(cacheXml);
+ cache.initializeDeclarativeCache(cacheXml);
} else {
- cptr->m_cacheImpl->initServices();
+ cache.m_cacheImpl->initServices();
}
} catch (const apache::geode::client::RegionExistsException&) {
LOGWARN("Attempt to create existing regions declaratively");
} catch (const apache::geode::client::Exception&) {
- if (!cptr->isClosed()) {
- cptr->close();
- cptr = nullptr;
+ if (!cache.isClosed()) {
+ cache.close();
}
throw;
} catch (...) {
- if (!cptr->isClosed()) {
- cptr->close();
- cptr = nullptr;
+ if (!cache.isClosed()) {
+ cache.close();
}
throw apache::geode::client::UnknownException(
"Exception thrown in CacheFactory::create");
}
- return cptr;
+ return cache;
}
CacheFactory::~CacheFactory() {}
diff --git a/cppcache/src/CacheImpl.cpp b/cppcache/src/CacheImpl.cpp
index dabf3568..1732f5cd 100644
--- a/cppcache/src/CacheImpl.cpp
+++ b/cppcache/src/CacheImpl.cpp
@@ -57,7 +57,7 @@ CacheImpl::CacheImpl(Cache* c, const std::string& name,
m_closed(false),
m_initialized(false),
m_distributedSystem(std::move(sys)),
- m_implementee(c),
+ m_cache(c),
m_cond(m_mutex),
m_attributes(nullptr),
m_evictionControllerPtr(nullptr),
@@ -69,7 +69,7 @@ CacheImpl::CacheImpl(Cache* c, const std::string& name,
m_memberListForVersionStamp(
*(std::make_shared<MemberListForVersionStamp>())),
m_serializationRegistry(std::make_shared<SerializationRegistry>()),
- m_pdxTypeRegistry(std::make_shared<PdxTypeRegistry>(c)),
+ m_pdxTypeRegistry(nullptr),
m_expiryTaskManager(
std::unique_ptr<ExpiryTaskManager>(new ExpiryTaskManager())),
m_clientProxyMembershipIDFactory(m_distributedSystem->getName()),
@@ -77,7 +77,7 @@ CacheImpl::CacheImpl(Cache* c, const std::string& name,
m_distributedSystem->getSystemProperties().threadPoolSize())),
m_authInitialize(authInitialize) {
m_cacheTXManager = std::shared_ptr<InternalCacheTransactionManager2PC>(
- new InternalCacheTransactionManager2PCImpl(c));
+ new InternalCacheTransactionManager2PCImpl(this));
m_regions = new MapOfRegionWithLock();
auto& prop = m_distributedSystem->getSystemProperties();
@@ -88,14 +88,11 @@ CacheImpl::CacheImpl(Cache* c, const std::string& name,
LOGINFO("Heap LRU eviction controller thread started");
}
- m_cacheStats = new CachePerfStats(m_distributedSystem.get()
- ->getStatisticsManager()
- ->getStatisticsFactory());
m_expiryTaskManager->begin();
m_initialized = true;
-
- m_poolManager = std::unique_ptr<PoolManager>(new
PoolManager(*m_implementee));
+ m_pdxTypeRegistry = std::make_shared<PdxTypeRegistry>(this);
+ m_poolManager = std::unique_ptr<PoolManager>(new PoolManager(this));
}
void CacheImpl::initServices() {
@@ -381,7 +378,7 @@ void CacheImpl::createRegion(const char* name,
}
validateRegionAttributes(name, aRegionAttributes);
-std::shared_ptr<RegionInternal> rpImpl = nullptr;
+ std::shared_ptr<RegionInternal> rpImpl = nullptr;
{
// For multi threading and the operations between bind and find seems to be
// hard to be atomic since a regionImpl needs to be valid before it can be
@@ -546,7 +543,7 @@ std::shared_ptr<RegionInternal>
CacheImpl::createRegion_internal(
"RegionAttributes is null");
}
-std::shared_ptr<RegionInternal> rptr = nullptr;
+ std::shared_ptr<RegionInternal> rptr = nullptr;
RegionKind regionKind = getRegionKind(attrs);
const char* poolName = attrs->getPoolName();
const char* regionEndpoints = attrs->getEndpoints();
@@ -797,3 +794,7 @@ CacheImpl::getCacheTransactionManager() {
new MemberListForVersionStamp());
return *versionStampMemIdList;
}
+
+void CacheImpl::setCache(Cache* cache) {
+ m_cache = cache;
+}
diff --git a/cppcache/src/CacheImpl.hpp b/cppcache/src/CacheImpl.hpp
index 614d98c3..97eb8815 100644
--- a/cppcache/src/CacheImpl.hpp
+++ b/cppcache/src/CacheImpl.hpp
@@ -226,7 +226,7 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable,
private NonAssignable {
return m_clientProxyMembershipIDFactory;
}
- Cache* getCache() const { return m_implementee; }
+ Cache* getCache() const { return m_cache; }
TcrConnectionManager& tcrConnectionManager() {
return *m_tcrConnectionManager;
}
@@ -321,6 +321,9 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable,
private NonAssignable {
srm.bind((*p).ext_id_, (*p).int_id_);
}
}
+
+ void setCache(Cache* cache);
+
std::string m_name;
bool m_closed;
bool m_initialized;
@@ -328,7 +331,7 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable,
private NonAssignable {
std::unique_ptr<DistributedSystem> m_distributedSystem;
ClientProxyMembershipIDFactory m_clientProxyMembershipIDFactory;
MapOfRegionWithLock* m_regions;
- Cache* m_implementee;
+ Cache* m_cache;
ACE_Recursive_Thread_Mutex m_mutex;
Condition m_cond;
std::shared_ptr<CacheAttributes> m_attributes;
@@ -350,6 +353,7 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable,
private NonAssignable {
friend class CacheFactory;
friend class Cache;
+ friend class DistributedSystem;
};
} // namespace client
} // namespace geode
diff --git a/cppcache/src/CacheTransactionManagerImpl.cpp
b/cppcache/src/CacheTransactionManagerImpl.cpp
index 42ef64fd..ff201b42 100644
--- a/cppcache/src/CacheTransactionManagerImpl.cpp
+++ b/cppcache/src/CacheTransactionManagerImpl.cpp
@@ -39,7 +39,7 @@ namespace apache {
namespace geode {
namespace client {
-CacheTransactionManagerImpl::CacheTransactionManagerImpl(Cache* cache)
+CacheTransactionManagerImpl::CacheTransactionManagerImpl(CacheImpl* cache)
: m_cache(cache), m_txCond(m_suspendedTxLock) {}
CacheTransactionManagerImpl::~CacheTransactionManagerImpl() {}
@@ -49,7 +49,7 @@ void CacheTransactionManagerImpl::begin() {
GfErrTypeThrowException("Transaction already in progress",
GF_CACHE_ILLEGAL_STATE_EXCEPTION);
}
- TXState* txState = new TXState(m_cache);
+ TXState* txState = new TXState(m_cache->getCache());
TSSTXStateWrapper::s_geodeTSSTXState->setTXState(txState);
addTx(txState->getTransactionId()->getId());
}
@@ -64,7 +64,7 @@ void CacheTransactionManagerImpl::commit() {
GF_CACHE_ILLEGAL_STATE_EXCEPTION);
}
- TcrMessageCommit request(m_cache->createDataOutput());
+ TcrMessageCommit request(m_cache->getCache()->createDataOutput());
TcrMessageReply reply(true, nullptr);
ThinClientPoolDM* tcr_dm = getDM();
@@ -114,7 +114,7 @@ void CacheTransactionManagerImpl::commit() {
auto commit = std::static_pointer_cast<TXCommitMessage>(reply.getValue());
txCleaner.clean();
- commit->apply(m_cache);
+ commit->apply(m_cache->getCache());
/*
if(m_writer != nullptr)
@@ -276,7 +276,7 @@ void CacheTransactionManagerImpl::rollback() {
GfErrType CacheTransactionManagerImpl::rollback(TXState* txState,
bool callListener) {
- TcrMessageRollback request(m_cache->createDataOutput());
+ TcrMessageRollback request(m_cache->getCache()->createDataOutput());
TcrMessageReply reply(true, nullptr);
GfErrType err = GF_NOERR;
ThinClientPoolDM* tcr_dm = getDM();
@@ -325,7 +325,7 @@ ThinClientPoolDM* CacheTransactionManagerImpl::getDM() {
return nullptr;
}
-Cache* CacheTransactionManagerImpl::getCache() { return m_cache; }
+Cache* CacheTransactionManagerImpl::getCache() { return m_cache->getCache(); }
std::shared_ptr<TransactionId> CacheTransactionManagerImpl::suspend() {
// get the current state of the thread
TXState* txState = TSSTXStateWrapper::s_geodeTSSTXState->getTXState();
@@ -363,9 +363,8 @@ std::shared_ptr<TransactionId>
CacheTransactionManagerImpl::suspend() {
.suspendedTxTimeout();
auto handler = new SuspendedTxExpiryHandler(this,
txState->getTransactionId(),
suspendedTxTimeout);
- long id = CacheRegionHelper::getCacheImpl(m_cache)
- ->getExpiryTaskManager()
- .scheduleExpiryTask(handler, suspendedTxTimeout,
+ long id = m_cache->getExpiryTaskManager()
+ .scheduleExpiryTask(handler, suspendedTxTimeout,
std::chrono::seconds::zero(), false);
txState->setSuspendedExpiryTaskId(id);
@@ -452,10 +451,10 @@ void
CacheTransactionManagerImpl::resumeTxUsingTxState(TXState* txState,
if (cancelExpiryTask) {
// cancel the expiry task for the transaction
-
CacheRegionHelper::getCacheImpl(m_cache)->getExpiryTaskManager().cancelTask(
+ m_cache->getExpiryTaskManager().cancelTask(
txState->getSuspendedExpiryTaskId());
} else {
- CacheRegionHelper::getCacheImpl(m_cache)->getExpiryTaskManager().resetTask(
+ m_cache->getExpiryTaskManager().resetTask(
txState->getSuspendedExpiryTaskId(), std::chrono::seconds(0));
}
diff --git a/cppcache/src/CacheTransactionManagerImpl.hpp
b/cppcache/src/CacheTransactionManagerImpl.hpp
index 098f7040..9eec27b0 100644
--- a/cppcache/src/CacheTransactionManagerImpl.hpp
+++ b/cppcache/src/CacheTransactionManagerImpl.hpp
@@ -36,7 +36,7 @@ enum commitOp { BEFORE_COMMIT, AFTER_COMMIT };
class CacheTransactionManagerImpl
: public virtual apache::geode::client::CacheTransactionManager {
public:
- CacheTransactionManagerImpl(Cache* cache);
+ CacheTransactionManagerImpl(CacheImpl* cache);
virtual ~CacheTransactionManagerImpl();
virtual void begin() override;
@@ -63,7 +63,7 @@ class CacheTransactionManagerImpl
Cache* getCache();
private:
- Cache* m_cache;
+ CacheImpl* m_cache;
void resumeTxUsingTxState(TXState* txState, bool cancelExpiryTask = true);
GfErrType rollback(TXState* txState, bool callListener);
diff --git a/cppcache/src/DistributedSystem.cpp
b/cppcache/src/DistributedSystem.cpp
index 02f398d2..a3824b09 100644
--- a/cppcache/src/DistributedSystem.cpp
+++ b/cppcache/src/DistributedSystem.cpp
@@ -27,17 +27,18 @@
#include <geode/CacheFactory.hpp>
#include <ace/OS.h>
-#include <ExpiryTaskManager.hpp>
-#include <CacheImpl.hpp>
#include <ace/Guard_T.h>
#include <ace/Recursive_Thread_Mutex.h>
-#include <geode/DataOutput.hpp>
-#include <TcrMessage.hpp>
-#include <DistributedSystemImpl.hpp>
-#include <RegionStats.hpp>
-#include <PoolStatistics.hpp>
-#include <DiffieHellman.hpp>
+#include "ExpiryTaskManager.hpp"
+#include "CacheImpl.hpp"
+#include "geode/DataOutput.hpp"
+#include "TcrMessage.hpp"
+#include "DistributedSystemImpl.hpp"
+#include "RegionStats.hpp"
+#include "PoolStatistics.hpp"
+#include "CacheRegionHelper.hpp"
+#include "DiffieHellman.hpp"
#include "version.h"
@@ -101,10 +102,10 @@ void setLFH() {
} // namespace apache
DistributedSystem::DistributedSystem(
- const std::string& name, std::unique_ptr<StatisticsManager> statMngr,
+ const std::string& name,
std::unique_ptr<SystemProperties> sysProps)
: m_name(name),
- m_statisticsManager(std::move(statMngr)),
+ m_statisticsManager(nullptr),
m_sysProps(std::move(sysProps)),
m_connected(false) {
LOGDEBUG("DistributedSystem::DistributedSystem");
@@ -150,8 +151,7 @@ void DistributedSystem::logSystemInformation() {
}
std::unique_ptr<DistributedSystem> DistributedSystem::create(
- const std::string& _name, Cache* cache,
- const std::shared_ptr<Properties>& configPtr) {
+ const std::string& _name, const std::shared_ptr<Properties>& configPtr) {
// TODO global - Refactory out the static initialization
// Trigger other library initialization.
CppCacheLibrary::initLib();
@@ -195,21 +195,8 @@ std::unique_ptr<DistributedSystem>
DistributedSystem::create(
throw;
}
- std::unique_ptr<StatisticsManager> statMngr;
- try {
- statMngr = std::unique_ptr<StatisticsManager>(new StatisticsManager(
- sysProps->statisticsArchiveFile(),
sysProps->statisticsSampleInterval(),
- sysProps->statisticsEnabled(), cache, sysProps->durableClientId(),
- sysProps->durableTimeout(), sysProps->statsFileSizeLimit(),
- sysProps->statsDiskSpaceLimit()));
- } catch (const NullPointerException&) {
- Log::close();
- throw;
- }
- GF_D_ASSERT(m_statisticsManager != nullptr);
-
auto distributedSystem = std::unique_ptr<DistributedSystem>(
- new DistributedSystem(name, std::move(statMngr), std::move(sysProps)));
+ new DistributedSystem(name, std::move(sysProps)));
if (!distributedSystem) {
throw NullPointerException("DistributedSystem::connect: new failed");
}
@@ -221,7 +208,7 @@ std::unique_ptr<DistributedSystem>
DistributedSystem::create(
return distributedSystem;
}
-void DistributedSystem::connect() {
+void DistributedSystem::connect(Cache* cache) {
ACE_Guard<ACE_Recursive_Thread_Mutex> disconnectGuard(*g_disconnectLock);
if (m_connected == true) {
throw AlreadyConnectedException(
@@ -248,6 +235,20 @@ void DistributedSystem::connect() {
"DistributedSystem::connect: caught unknown exception");
}
+ auto cacheImpl = CacheRegionHelper::getCacheImpl(cache);
+ try {
+ m_statisticsManager = std::unique_ptr<StatisticsManager>(new
StatisticsManager(
+ m_sysProps->statisticsArchiveFile(),
m_sysProps->statisticsSampleInterval(),
+ m_sysProps->statisticsEnabled(), cacheImpl,
+ m_sysProps->durableClientId(), m_sysProps->durableTimeout(),
+ m_sysProps->statsFileSizeLimit(), m_sysProps->statsDiskSpaceLimit()));
+ cacheImpl->m_cacheStats = new
CachePerfStats(getStatisticsManager()->getStatisticsFactory());
+ }
+ catch (const NullPointerException&) {
+ Log::close();
+ throw;
+ }
+
m_connected = true;
}
diff --git a/cppcache/src/FunctionService.cpp b/cppcache/src/FunctionService.cpp
index fce49693..f4cc345d 100644
--- a/cppcache/src/FunctionService.cpp
+++ b/cppcache/src/FunctionService.cpp
@@ -49,7 +49,7 @@ std::shared_ptr<Execution> FunctionService::onRegion(
// it is in multiuser mode
proxyCache = pr->m_proxyCache;
auto userAttachedPool = proxyCache->m_userAttributes->getPool();
- auto pool = realRegion->getCache()->getPoolManager().find(
+ auto pool = realRegion->getCache().getPoolManager().find(
userAttachedPool->getName());
if (!(pool != nullptr && pool.get() == userAttachedPool.get() &&
!pool->isDestroyed())) {
@@ -57,8 +57,8 @@ std::shared_ptr<Execution> FunctionService::onRegion(
"Pool has been closed with attached Logical Cache.");
}
// getting real region to execute function on region
- if (!realRegion->getCache()->isClosed()) {
- realRegion->getCache()->m_cacheImpl->getRegion(realRegion->getName(),
+ if (!realRegion->getCache().isClosed()) {
+ realRegion->getCache().m_cacheImpl->getRegion(realRegion->getName(),
realRegion);
} else {
throw IllegalStateException("Cache has been closed");
diff --git a/cppcache/src/InternalCacheTransactionManager2PCImpl.cpp
b/cppcache/src/InternalCacheTransactionManager2PCImpl.cpp
index 3d4b9ab4..b46c16f1 100644
--- a/cppcache/src/InternalCacheTransactionManager2PCImpl.cpp
+++ b/cppcache/src/InternalCacheTransactionManager2PCImpl.cpp
@@ -36,7 +36,7 @@ namespace geode {
namespace client {
InternalCacheTransactionManager2PCImpl::InternalCacheTransactionManager2PCImpl(
- Cache* cache)
+ CacheImpl* cache)
: CacheTransactionManagerImpl(cache) {}
InternalCacheTransactionManager2PCImpl::
diff --git a/cppcache/src/InternalCacheTransactionManager2PCImpl.hpp
b/cppcache/src/InternalCacheTransactionManager2PCImpl.hpp
index 34fcbb58..732154a3 100644
--- a/cppcache/src/InternalCacheTransactionManager2PCImpl.hpp
+++ b/cppcache/src/InternalCacheTransactionManager2PCImpl.hpp
@@ -31,7 +31,7 @@ class InternalCacheTransactionManager2PCImpl
: public apache::geode::client::CacheTransactionManagerImpl,
public apache::geode::client::InternalCacheTransactionManager2PC {
public:
- InternalCacheTransactionManager2PCImpl(Cache* cache);
+ InternalCacheTransactionManager2PCImpl(CacheImpl* cache);
virtual ~InternalCacheTransactionManager2PCImpl();
virtual void prepare() override;
diff --git a/cppcache/src/LocalRegion.cpp b/cppcache/src/LocalRegion.cpp
index 30457bdf..5aa9c4e9 100644
--- a/cppcache/src/LocalRegion.cpp
+++ b/cppcache/src/LocalRegion.cpp
@@ -45,7 +45,7 @@ LocalRegion::LocalRegion(const std::string& name, CacheImpl*
cache,
const std::shared_ptr<RegionAttributes>& attributes,
const std::shared_ptr<CacheStatistics>& stats,
bool shared, bool enableTimeStatistics)
- : RegionInternal(cache->getCache()->shared_from_this(), attributes),
+ : RegionInternal(cache->getCache(), attributes),
m_name(name),
m_parentRegion(rPtr),
m_cacheImpl(cache),
diff --git a/cppcache/src/PdxTypeRegistry.cpp b/cppcache/src/PdxTypeRegistry.cpp
index 9ce60b4d..f4643a69 100644
--- a/cppcache/src/PdxTypeRegistry.cpp
+++ b/cppcache/src/PdxTypeRegistry.cpp
@@ -20,12 +20,13 @@
#include "PdxTypeRegistry.hpp"
#include "CacheRegionHelper.hpp"
#include "ThinClientPoolDM.hpp"
+#include "CacheImpl.hpp"
namespace apache {
namespace geode {
namespace client {
-PdxTypeRegistry::PdxTypeRegistry(Cache* cache)
+PdxTypeRegistry::PdxTypeRegistry(CacheImpl* cache)
: cache(cache),
typeIdToPdxType(),
remoteTypeIdToMergedPdxType(),
@@ -54,10 +55,8 @@ int32_t PdxTypeRegistry::getPDXIdForType(const char* type,
const char* poolname,
}
}
- int typeId =
- CacheRegionHelper::getCacheImpl(cache)
- ->getSerializationRegistry()
- ->GetPDXIdForType(cache->getPoolManager().find(poolname), nType);
+ int typeId = cache->getSerializationRegistry()
+ ->GetPDXIdForType(cache->getPoolManager().find(poolname),
nType);
nType->setTypeId(typeId);
PdxTypeRegistry::addPdxType(typeId, nType);
@@ -88,9 +87,8 @@ int32_t
PdxTypeRegistry::getPDXIdForType(std::shared_ptr<PdxType> nType,
}
}
- typeId = CacheRegionHelper::getCacheImpl(cache)
- ->getSerializationRegistry()
- ->GetPDXIdForType(cache->getPoolManager().find(poolname),
nType);
+ typeId = cache->getSerializationRegistry()
+ ->GetPDXIdForType(cache->getPoolManager().find(poolname),
nType);
nType->setTypeId(typeId);
pdxTypeToTypeIdMap.insert(std::make_pair(nType, typeId));
addPdxType(typeId, nType);
@@ -273,7 +271,7 @@ std::shared_ptr<EnumInfo> PdxTypeRegistry::getEnum(int32_t
enumVal) {
ret = std::static_pointer_cast<EnumInfo>(
static_cast<ThinClientPoolDM*>(
cache->getPoolManager().getAll().begin()->second.get())
- ->GetEnum(enumVal));
+ ->GetEnum(enumVal));
tmp = intToEnum;
(*tmp)[enumValPtr] = ret;
intToEnum = tmp;
diff --git a/cppcache/src/PdxTypeRegistry.hpp b/cppcache/src/PdxTypeRegistry.hpp
index 98549914..f4f075df 100644
--- a/cppcache/src/PdxTypeRegistry.hpp
+++ b/cppcache/src/PdxTypeRegistry.hpp
@@ -63,7 +63,7 @@ typedef std::map<std::shared_ptr<PdxType>, int32_t,
PdxTypeLessThan>
class CPPCACHE_EXPORT PdxTypeRegistry
: public std::enable_shared_from_this<PdxTypeRegistry> {
private:
- Cache* cache;
+ CacheImpl* cache;
TypeIdVsPdxType typeIdToPdxType;
@@ -89,7 +89,7 @@ class CPPCACHE_EXPORT PdxTypeRegistry
std::shared_ptr<CacheableHashMap> intToEnum;
public:
- PdxTypeRegistry(Cache* cache);
+ PdxTypeRegistry(CacheImpl* cache);
PdxTypeRegistry(const PdxTypeRegistry& other) = delete;
virtual ~PdxTypeRegistry();
diff --git a/cppcache/src/PoolManager.cpp b/cppcache/src/PoolManager.cpp
index f456be35..66469b74 100644
--- a/cppcache/src/PoolManager.cpp
+++ b/cppcache/src/PoolManager.cpp
@@ -18,11 +18,14 @@
#include <geode/PoolManager.hpp>
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
+
using namespace apache::geode::client;
class PoolManager::Impl {
public:
- Impl(const Cache& cache) : m_cache(cache) {}
+ Impl(CacheImpl* cache) : m_cache(cache) {}
void removePool(const char* name);
std::shared_ptr<PoolFactory> createFactory();
@@ -43,15 +46,16 @@ class PoolManager::Impl {
HashMapOfPools m_connectionPools;
std::recursive_mutex m_connectionPoolsLock;
std::shared_ptr<Pool> m_defaultPool;
- const Cache& m_cache;
+ CacheImpl* m_cache;
};
void PoolManager::Impl::removePool(const char* name) {
std::lock_guard<std::recursive_mutex> guard(m_connectionPoolsLock);
m_connectionPools.erase(name);
}
+
std::shared_ptr<PoolFactory> PoolManager::Impl::createFactory() {
- return std::shared_ptr<PoolFactory>(new PoolFactory(m_cache));
+ return std::shared_ptr<PoolFactory>(new PoolFactory(*m_cache->getCache()));
}
void PoolManager::Impl::close(bool keepAlive) {
@@ -106,7 +110,7 @@ std::shared_ptr<Pool> PoolManager::Impl::getDefaultPool() {
return m_defaultPool;
}
-PoolManager::PoolManager(const Cache& cache)
+PoolManager::PoolManager(CacheImpl* cache)
: m_pimpl(new Impl(cache), [](Impl* impl) { delete impl; }) {}
void PoolManager::removePool(const char* name) { m_pimpl->removePool(name); }
diff --git a/cppcache/src/ProxyRegion.hpp b/cppcache/src/ProxyRegion.hpp
index 805e449b..a9bf844e 100644
--- a/cppcache/src/ProxyRegion.hpp
+++ b/cppcache/src/ProxyRegion.hpp
@@ -603,7 +603,7 @@ class CPPCACHE_EXPORT ProxyRegion : public Region {
ProxyRegion(const std::shared_ptr<ProxyCache>& proxyCache,
const std::shared_ptr<RegionInternal>& realRegion)
- : Region(realRegion->getCache()) {
+ : Region(&realRegion->getCache()) {
m_proxyCache = proxyCache;
m_realRegion = realRegion;
}
diff --git a/cppcache/src/Region.cpp b/cppcache/src/Region.cpp
index 0bf97dd3..f834efbd 100644
--- a/cppcache/src/Region.cpp
+++ b/cppcache/src/Region.cpp
@@ -20,7 +20,7 @@
namespace apache {
namespace geode {
namespace client {
-Region::Region(const std::shared_ptr<Cache>& cache) : m_cache(cache) {}
+Region::Region(Cache* cache) : m_cache(cache) {}
Region::~Region() {}
} // namespace client
} // namespace geode
diff --git a/cppcache/src/RegionInternal.cpp b/cppcache/src/RegionInternal.cpp
index 5775a6a6..008917bf 100644
--- a/cppcache/src/RegionInternal.cpp
+++ b/cppcache/src/RegionInternal.cpp
@@ -39,7 +39,7 @@ const CacheEventFlags CacheEventFlags::NOCACHEWRITER(
CacheEventFlags::GF_NOCACHEWRITER);
RegionInternal::RegionInternal(
- const std::shared_ptr<Cache>& cache,
+ Cache* cache,
const std::shared_ptr<RegionAttributes>& attributes)
: Region(cache), m_regionAttributes(attributes) {}
diff --git a/cppcache/src/RegionInternal.hpp b/cppcache/src/RegionInternal.hpp
index 1edf9e8d..cabc786a 100644
--- a/cppcache/src/RegionInternal.hpp
+++ b/cppcache/src/RegionInternal.hpp
@@ -288,7 +288,7 @@ class RegionInternal : public Region {
/**
* @brief constructor
*/
- RegionInternal(const std::shared_ptr<Cache>& cache, const
std::shared_ptr<RegionAttributes>& attributes);
+ RegionInternal(Cache* cache, const std::shared_ptr<RegionAttributes>&
attributes);
void setLruEntriesLimit(uint32_t limit);
void setRegionTimeToLiveExpirationAction(ExpirationAction::Action action);
diff --git a/cppcache/src/ThinClientPoolDM.cpp
b/cppcache/src/ThinClientPoolDM.cpp
index 1fd61056..c6dffb16 100644
--- a/cppcache/src/ThinClientPoolDM.cpp
+++ b/cppcache/src/ThinClientPoolDM.cpp
@@ -83,7 +83,7 @@ class GetAllWork : public PooledWork<GfErrType>,
m_keys(keys),
m_region(region),
m_aCallbackArgument(aCallbackArgument) {
- m_request = new TcrMessageGetAll(region->getCache()->createDataOutput(),
+ m_request = new TcrMessageGetAll(region->getCache().createDataOutput(),
region.get(), m_keys.get(), m_poolDM,
m_aCallbackArgument);
m_reply = new TcrMessageReply(true, m_poolDM);
diff --git a/cppcache/src/ThinClientPoolRegion.cpp
b/cppcache/src/ThinClientPoolRegion.cpp
index afbcf322..814452b5 100644
--- a/cppcache/src/ThinClientPoolRegion.cpp
+++ b/cppcache/src/ThinClientPoolRegion.cpp
@@ -42,7 +42,7 @@ void ThinClientPoolRegion::initTCR() {
try {
ThinClientPoolDM* poolDM = dynamic_cast<ThinClientPoolDM*>(
getCache()
- ->getPoolManager()
+ .getPoolManager()
.find(m_regionAttributes->getPoolName())
.get());
m_tcrdm = dynamic_cast<ThinClientBaseDM*>(poolDM);
diff --git a/cppcache/src/ThinClientRegion.cpp
b/cppcache/src/ThinClientRegion.cpp
index d92d94ad..e2ab53e0 100644
--- a/cppcache/src/ThinClientRegion.cpp
+++ b/cppcache/src/ThinClientRegion.cpp
@@ -91,7 +91,7 @@ class PutAllWork : public PooledWork<GfErrType>,
m_isPapeReceived(false)
// UNUSED , m_aCallbackArgument(aCallbackArgument)
{
- m_request = new TcrMessagePutAll(m_region->getCache()->createDataOutput(),
+ m_request = new TcrMessagePutAll(m_region->getCache().createDataOutput(),
m_region.get(), *m_map.get(), m_timeout,
m_poolDM, aCallbackArgument);
m_reply = new TcrMessageReply(true, m_poolDM);
@@ -236,7 +236,7 @@ class RemoveAllWork : public PooledWork<GfErrType>,
m_papException(nullptr),
m_isPapeReceived(false) {
m_request = new TcrMessageRemoveAll(
- m_region->getCache()->createDataOutput(), m_region.get(), *keys,
+ m_region->getCache().createDataOutput(), m_region.get(), *keys,
m_aCallbackArgument, m_poolDM);
m_reply = new TcrMessageReply(true, m_poolDM);
// create new instanceof VCOPL
@@ -1366,7 +1366,7 @@ GfErrType ThinClientRegion::singleHopPutAllNoThrow_remote(
*/
std::vector<PutAllWork*> putAllWorkers;
auto threadPool =
- CacheRegionHelper::getCacheImpl(getCache().get())->getThreadPool();
+ CacheRegionHelper::getCacheImpl(&getCache())->getThreadPool();
int locationMapIndex = 0;
for (const auto& locationIter : *locationMap) {
const auto& serverLocation = locationIter.first;
@@ -1746,7 +1746,7 @@ GfErrType
ThinClientRegion::singleHopRemoveAllNoThrow_remote(
*/
std::vector<RemoveAllWork*> removeAllWorkers;
auto* threadPool =
- CacheRegionHelper::getCacheImpl(getCache().get())->getThreadPool();
+ CacheRegionHelper::getCacheImpl(&getCache())->getThreadPool();
int locationMapIndex = 0;
for (const auto& locationIter : *locationMap) {
const auto& serverLocation = locationIter.first;
@@ -3197,7 +3197,7 @@ bool ThinClientRegion::executeFunctionSH(
TSSUserAttributesWrapper::s_geodeTSSUserAttributes->getUserAttributes();
std::vector<std::shared_ptr<OnRegionFunctionExecution>> feWorkers;
auto* threadPool =
- CacheRegionHelper::getCacheImpl(getCache().get())->getThreadPool();
+ CacheRegionHelper::getCacheImpl(&getCache())->getThreadPool();
for (const auto& locationIter : *locationMap) {
const auto& serverLocation = locationIter.first;
diff --git a/cppcache/src/TypeRegistry.cpp b/cppcache/src/TypeRegistry.cpp
index 4e911c07..e5d2314d 100644
--- a/cppcache/src/TypeRegistry.cpp
+++ b/cppcache/src/TypeRegistry.cpp
@@ -23,23 +23,20 @@
TypeRegistry is the public facing wrapper for the serialization registry.
**/
-TypeRegistry::TypeRegistry(const Cache &cache) : m_cache(cache) {}
+TypeRegistry::TypeRegistry(CacheImpl* cache) : m_cache(cache) {}
void TypeRegistry::registerType(TypeFactoryMethod creationFunction) {
- CacheRegionHelper::getCacheImpl(&m_cache)
- ->getSerializationRegistry()
- ->addType(creationFunction);
+ m_cache->getSerializationRegistry()
+ ->addType(creationFunction);
}
void TypeRegistry::registerPdxType(TypeFactoryMethodPdx creationFunction) {
- CacheRegionHelper::getCacheImpl(&m_cache)
- ->getSerializationRegistry()
- ->addPdxType(creationFunction);
+ m_cache->getSerializationRegistry()
+ ->addPdxType(creationFunction);
}
void TypeRegistry::registerPdxSerializer(
std::shared_ptr<PdxSerializer> pdxSerializer) {
- CacheRegionHelper::getCacheImpl(&m_cache)
- ->getSerializationRegistry()
- ->setPdxSerializer(pdxSerializer);
+ m_cache->getSerializationRegistry()
+ ->setPdxSerializer(pdxSerializer);
}
diff --git a/cppcache/src/statistics/HostStatSampler.cpp
b/cppcache/src/statistics/HostStatSampler.cpp
index 030657c7..bd67ac0e 100644
--- a/cppcache/src/statistics/HostStatSampler.cpp
+++ b/cppcache/src/statistics/HostStatSampler.cpp
@@ -130,7 +130,7 @@ const char* HostStatSampler::NC_HSS_Thread = "NC HSS
Thread";
HostStatSampler::HostStatSampler(const char* filePath,
std::chrono::milliseconds sampleIntervalMs,
- StatisticsManager* statMngr, Cache* cache,
+ StatisticsManager* statMngr, CacheImpl* cache,
const char* durableClientId,
const std::chrono::seconds durableTimeout,
int64_t statFileLimit,
diff --git a/cppcache/src/statistics/HostStatSampler.hpp
b/cppcache/src/statistics/HostStatSampler.hpp
index 96466209..3a768e88 100644
--- a/cppcache/src/statistics/HostStatSampler.hpp
+++ b/cppcache/src/statistics/HostStatSampler.hpp
@@ -83,7 +83,7 @@ class CPPCACHE_EXPORT HostStatSampler : public ACE_Task_Base,
*/
HostStatSampler(const char* filePath,
std::chrono::milliseconds sampleIntervalMs,
- StatisticsManager* statMngr, Cache* cache,
+ StatisticsManager* statMngr, CacheImpl* cache,
const char* durableClientId,
const std::chrono::seconds durableTimeout,
int64_t statFileLimit = 0, int64_t statDiskSpaceLimit = 0);
@@ -218,7 +218,7 @@ class CPPCACHE_EXPORT HostStatSampler : public
ACE_Task_Base,
int64_t m_archiveDiskSpaceLimit;
std::chrono::milliseconds m_sampleRate;
StatisticsManager* m_statMngr;
- Cache* m_cache;
+ CacheImpl* m_cache;
int64_t m_pid;
system_clock::time_point m_startTime;
diff --git a/cppcache/src/statistics/StatArchiveWriter.cpp
b/cppcache/src/statistics/StatArchiveWriter.cpp
index 47f03ec5..ac63a2d3 100644
--- a/cppcache/src/statistics/StatArchiveWriter.cpp
+++ b/cppcache/src/statistics/StatArchiveWriter.cpp
@@ -26,6 +26,7 @@
#include "StatArchiveWriter.hpp"
#include "GeodeStatisticsFactory.hpp"
+#include "CacheImpl.hpp"
namespace apache {
namespace geode {
@@ -39,14 +40,18 @@ using std::chrono::nanoseconds;
// Constructor and Member functions of StatDataOutput class
-StatDataOutput::StatDataOutput(std::string filename, Cache *cache) {
+StatDataOutput::StatDataOutput(CacheImpl* cache) : bytesWritten(0),
m_fp(nullptr), closed(false) {
+ dataBuffer = cache->getCache()->createDataOutput();
+}
+
+StatDataOutput::StatDataOutput(std::string filename, CacheImpl* cache) {
if (filename.length() == 0) {
std::string s("undefined archive file name");
throw IllegalArgumentException(s.c_str());
}
SerializationRegistry serializationRegistry;
- dataBuffer = cache->createDataOutput();
+ dataBuffer = cache->getCache()->createDataOutput();
outFile = filename;
closed = false;
bytesWritten = 0;
@@ -314,7 +319,7 @@ void ResourceInst::writeResourceInst(StatDataOutput
*dataOutArg,
// Constructor and Member functions of StatArchiveWriter class
StatArchiveWriter::StatArchiveWriter(std::string outfile,
- HostStatSampler *samplerArg, Cache *cache)
+ HostStatSampler *samplerArg, CacheImpl*
cache)
: cache(cache) {
resourceTypeId = 0;
resourceInstId = 0;
diff --git a/cppcache/src/statistics/StatArchiveWriter.hpp
b/cppcache/src/statistics/StatArchiveWriter.hpp
index 6f77c6d1..a677a69f 100644
--- a/cppcache/src/statistics/StatArchiveWriter.hpp
+++ b/cppcache/src/statistics/StatArchiveWriter.hpp
@@ -79,10 +79,8 @@ using std::chrono::steady_clock;
class CPPCACHE_EXPORT StatDataOutput {
public:
- StatDataOutput(Cache *cache) : bytesWritten(0), m_fp(nullptr), closed(false)
{
- dataBuffer = cache->createDataOutput();
- }
- StatDataOutput(std::string, Cache *cache);
+ StatDataOutput(CacheImpl* cache);
+ StatDataOutput(std::string, CacheImpl* cache);
~StatDataOutput();
/**
* Returns the number of bytes written into the buffer so far.
@@ -207,7 +205,7 @@ class CPPCACHE_EXPORT StatArchiveWriter {
private:
HostStatSampler *sampler;
StatDataOutput *dataBuffer;
- Cache *cache;
+ CacheImpl* cache;
steady_clock::time_point previousTimeStamp;
int32_t resourceTypeId;
int32_t resourceInstId;
@@ -230,7 +228,7 @@ class CPPCACHE_EXPORT StatArchiveWriter {
public:
StatArchiveWriter(std::string archiveName, HostStatSampler *sampler,
- Cache *cache);
+ CacheImpl* cache);
~StatArchiveWriter();
/**
* Returns the number of bytes written so far to this archive.
diff --git a/cppcache/src/statistics/StatisticsManager.cpp
b/cppcache/src/statistics/StatisticsManager.cpp
index 2732bcf1..402a84a0 100644
--- a/cppcache/src/statistics/StatisticsManager.cpp
+++ b/cppcache/src/statistics/StatisticsManager.cpp
@@ -39,7 +39,7 @@ using namespace apache::geode::statistics;
StatisticsManager::StatisticsManager(
const char* filePath, const std::chrono::milliseconds sampleInterval,
- bool enabled, Cache* cache, const char* durableClientId,
+ bool enabled, CacheImpl* cache, const char* durableClientId,
const std::chrono::seconds durableTimeout, int64_t statFileLimit,
int64_t statDiskSpaceLimit)
: m_sampleIntervalMs(sampleInterval),
diff --git a/cppcache/src/statistics/StatisticsManager.hpp
b/cppcache/src/statistics/StatisticsManager.hpp
index f5f5f5d5..907764d6 100644
--- a/cppcache/src/statistics/StatisticsManager.hpp
+++ b/cppcache/src/statistics/StatisticsManager.hpp
@@ -68,7 +68,7 @@ class StatisticsManager {
public:
StatisticsManager(const char* filePath,
std::chrono::milliseconds sampleIntervalMs, bool enabled,
- Cache* cache, const char* durableClientId,
+ apache::geode::client::CacheImpl* cache, const char*
durableClientId,
const std::chrono::seconds durableTimeout,
int64_t statFileLimit = 0, int64_t statDiskSpaceLimit = 0);
@@ -108,7 +108,6 @@ class StatisticsManager {
GeodeStatisticsFactory* getStatisticsFactory() const {
return m_statisticsFactory.get();
}
-
}; // class
} // namespace statistics
diff --git a/cppcache/test/PdxLocalReaderTest.cpp
b/cppcache/test/PdxLocalReaderTest.cpp
index cbd43eed..90f256e9 100644
--- a/cppcache/test/PdxLocalReaderTest.cpp
+++ b/cppcache/test/PdxLocalReaderTest.cpp
@@ -67,7 +67,7 @@ class DISABLED_PdxLocalReaderTest : public ::testing::Test {
public:
void SetUp() {
auto factory = CacheFactory::createCacheFactory();
- cache = factory->create();
+ cache = std::make_shared<Cache>(factory->create());
}
protected:
diff --git a/sqliteimpl/SqLiteImpl.cpp b/sqliteimpl/SqLiteImpl.cpp
index 0de4e99a..d086d608 100644
--- a/sqliteimpl/SqLiteImpl.cpp
+++ b/sqliteimpl/SqLiteImpl.cpp
@@ -113,9 +113,9 @@ void SqLiteImpl::write(const std::shared_ptr<CacheableKey>&
key,
const std::shared_ptr<Cacheable>& value,
void*& dbHandle) {
// Serialize key and value.
- auto* cache = m_regionPtr->getCache().get();
- auto keyDataBuffer = cache->createDataOutput();
- auto valueDataBuffer = cache->createDataOutput();
+ auto& cache = m_regionPtr->getCache();
+ auto keyDataBuffer = cache.createDataOutput();
+ auto valueDataBuffer = cache.createDataOutput();
uint32_t keyBufferSize, valueBufferSize;
keyDataBuffer->writeObject(key);
@@ -134,7 +134,7 @@ bool SqLiteImpl::writeAll() { return true; }
std::shared_ptr<Cacheable> SqLiteImpl::read(
const std::shared_ptr<CacheableKey>& key, void*& dbHandle) {
// Serialize key.
- auto keyDataBuffer = m_regionPtr->getCache()->createDataOutput();
+ auto keyDataBuffer = m_regionPtr->getCache().createDataOutput();
uint32_t keyBufferSize;
keyDataBuffer->writeObject(key);
void* keyData =
const_cast<uint8_t*>(keyDataBuffer->getBuffer(&keyBufferSize));
@@ -147,7 +147,7 @@ std::shared_ptr<Cacheable> SqLiteImpl::read(
}
// Deserialize object and return value.
- auto valueDataBuffer = m_regionPtr->getCache()->createDataInput(
+ auto valueDataBuffer = m_regionPtr->getCache().createDataInput(
reinterpret_cast<uint8_t*>(valueData), valueBufferSize);
std::shared_ptr<Cacheable> retValue;
valueDataBuffer->readObject(retValue);
@@ -177,7 +177,7 @@ void SqLiteImpl::destroyRegion() {
void SqLiteImpl::destroy(const std::shared_ptr<CacheableKey>& key, void*&
dbHandle) {
// Serialize key and value.
- auto keyDataBuffer = m_regionPtr->getCache()->createDataOutput();
+ auto keyDataBuffer = m_regionPtr->getCache().createDataOutput();
uint32_t keyBufferSize;
keyDataBuffer->writeObject(key);
void* keyData =
const_cast<uint8_t*>(keyDataBuffer->getBuffer(&keyBufferSize));
diff --git a/tests/cpp/fwklib/FrameworkTest.cpp
b/tests/cpp/fwklib/FrameworkTest.cpp
index dd0024e4..d0da6bca 100644
--- a/tests/cpp/fwklib/FrameworkTest.cpp
+++ b/tests/cpp/fwklib/FrameworkTest.cpp
@@ -261,7 +261,7 @@ void FrameworkTest::cacheInitialize(
}
try {
- m_cache = cacheFactory->create();
+ m_cache = std::make_shared<Cache>(cacheFactory->create());
bool m_istransaction = getBoolValue("useTransactions");
if (m_istransaction) {
txManager = m_cache->getCacheTransactionManager();
diff --git a/tests/cpp/fwklib/FwkObjects.cpp b/tests/cpp/fwklib/FwkObjects.cpp
index adbb7548..93aaf837 100644
--- a/tests/cpp/fwklib/FwkObjects.cpp
+++ b/tests/cpp/fwklib/FwkObjects.cpp
@@ -577,8 +577,8 @@ Attributes::Attributes(const DOMNode* node)
FwkPool::FwkPool(const DOMNode* node) : m_locators(false), m_servers(false) {
// Init Factory
auto cacheFactory = CacheFactory::createCacheFactory();
- m_cache = cacheFactory->create();
- m_poolManager = new PoolManager(*m_cache);
+ m_cache = std::make_shared<Cache>(cacheFactory->create());
+ m_poolManager = &m_cache->getPoolManager();
m_poolFactory = m_poolManager->createFactory();
// Set Attrs to Pool
setAttributesToFactory(node);
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
> Update API CacheFactory::create to return cache object
> ------------------------------------------------------
>
> Key: GEODE-3645
> URL: https://issues.apache.org/jira/browse/GEODE-3645
> Project: Geode
> Issue Type: New Feature
> Components: native client
> Reporter: David Kimura
>
> As an application developer I want to control the stack vs heap allocation of
> my cache object. If we change CacheFactory::create to return a cache object
> then the application user can pick an allocation scheme. This also allows
> application developers to bypass smart pointer complexity until the developer
> deems them necessary.
> Example:
> {noformat}
> auto cache = CacheFactory::createFactory().create();
> auto cacheptr =
> std::make_shared<Cache>(CacheFactory::createFactory().create());
> {noformat}
> Difficulty of implementation is due to Cache/CacheImpl circular dependency.
> Here are a few examples of various approaches to consider:
> https://gist.github.com/pivotal-jbarrett/52ba9ec5de0b494368d1c5282ef188ef
> https://gist.github.com/pivotal-jbarrett/c48ffff3f7f41b187f0ed8c80108aa6a
> Here are the related email threads of interest:
> http://markmail.org/message/in5e337npq5euslh
> http://markmail.org/message/lp2rx2rtyblg72fv
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
