geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [geode-native] branch develop updated: GEODE-5018: Fixing PIMPL pattern for Cache (#278)
Date Tue, 17 Apr 2018 19:51:18 GMT
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


The following commit(s) were added to refs/heads/develop by this push:
     new fc41344  GEODE-5018: Fixing PIMPL pattern for Cache (#278)
fc41344 is described below

commit fc413448d12c63a1588a2f0300159ea7b570acd0
Author: Ryan McMahon <rmcmahon@pivotal.io>
AuthorDate: Tue Apr 17 12:51:15 2018 -0700

    GEODE-5018: Fixing PIMPL pattern for Cache (#278)
    
    * Moving type registry out and using forward decl
    * Using initializer list in Cache constructor
---
 cppcache/include/geode/AuthenticatedView.hpp       |   7 +-
 cppcache/include/geode/Cache.hpp                   |  42 +++---
 cppcache/include/geode/Pool.hpp                    |   2 +-
 cppcache/include/geode/RegionService.hpp           |   2 +-
 cppcache/integration-test-2/ExampleTest.cpp        |   3 +-
 .../integration-test-2/RegionPutGetAllTest.cpp     |   3 +
 cppcache/integration-test/CacheHelper.cpp          |   5 +-
 cppcache/integration-test/QueryHelper.hpp          |  25 ++--
 .../integration-test/ThinClientMultipleCaches.hpp  |   4 +-
 .../integration-test/testAttributesMutator.cpp     |  13 +-
 cppcache/integration-test/testCache.cpp            |   4 +
 cppcache/integration-test/testExpiration.cpp       |  87 ++++++++-----
 cppcache/integration-test/testLinkage.cpp          |   3 +
 .../integration-test/testOverflowPutGetSqLite.cpp  |   8 +-
 .../testRegionAttributesFactory.cpp                |   8 +-
 .../integration-test/testRegionTemplateArgs.cpp    |   8 +-
 .../integration-test/testThinClientCqDurable.cpp   |  25 ++--
 .../testThinClientSecurityMultiUserTest.cpp        |   2 +
 .../testXmlCacheCreationWithRefid.cpp              |  17 ++-
 cppcache/src/AuthenticatedView.cpp                 |   9 +-
 cppcache/src/Cache.cpp                             | 129 +++++--------------
 cppcache/src/CacheImpl.cpp                         | 143 +++++++++++++++++----
 cppcache/src/CacheImpl.hpp                         |  50 ++++---
 cppcache/src/ClientMetadataService.cpp             |   5 +-
 cppcache/src/EvictionController.cpp                |  19 ++-
 cppcache/src/FunctionService.cpp                   |   3 +-
 cppcache/src/PdxInstanceFactoryImpl.cpp            |   2 +-
 cppcache/src/PdxInstanceFactoryImpl.hpp            |   3 +-
 cppcache/src/PdxType.cpp                           | 136 ++++++++++----------
 cppcache/src/PdxType.hpp                           |   2 +-
 cppcache/src/PoolManagerImpl.cpp                   |   1 +
 cppcache/src/RegionEntry.cpp                       |   1 +
 cppcache/src/RegionFactory.cpp                     |  18 +--
 cppcache/src/TcrEndpoint.cpp                       |   8 +-
 cppcache/src/ThinClientPoolDM.cpp                  |  23 ++--
 examples/cpp/customserializable/main.cpp           |   4 +-
 examples/cpp/customserializer/main.cpp             |   4 +
 examples/cpp/put-get-remove/main.cpp               |  16 ++-
 tests/cpp/fwklib/RegionHelper.hpp                  |   2 +
 39 files changed, 484 insertions(+), 362 deletions(-)

diff --git a/cppcache/include/geode/AuthenticatedView.hpp b/cppcache/include/geode/AuthenticatedView.hpp
index 44f5c2d..586a44d 100644
--- a/cppcache/include/geode/AuthenticatedView.hpp
+++ b/cppcache/include/geode/AuthenticatedView.hpp
@@ -82,8 +82,7 @@ class APACHE_GEODE_EXPORT AuthenticatedView : public RegionService {
    * @param path the region's path, such as <code>RootA/Sub1/Sub1A</code>.
    * @returns region, or nullptr if no such region exists.
    */
-  std::shared_ptr<Region> getRegion(
-      const std::string& path) const override;
+  std::shared_ptr<Region> getRegion(const std::string& path) const override;
 
   /**
    * Gets the QueryService from which a new Query can be obtained.
@@ -109,7 +108,7 @@ class APACHE_GEODE_EXPORT AuthenticatedView : public RegionService {
 
   /**
    * @brief constructors
-  */
+   */
   AuthenticatedView(std::shared_ptr<Properties> credentials,
                     std::shared_ptr<Pool> pool, CacheImpl* cacheImpl);
   AuthenticatedView(AuthenticatedView&& other) = default;
@@ -123,7 +122,7 @@ class APACHE_GEODE_EXPORT AuthenticatedView : public RegionService {
    * @return the factory
    */
   std::shared_ptr<PdxInstanceFactory> createPdxInstanceFactory(
-      std::string className) const override;
+      const std::string& className) const override;
 
   AuthenticatedView& operator=(AuthenticatedView&& other) = default;
   AuthenticatedView& operator=(const AuthenticatedView& other) = delete;
diff --git a/cppcache/include/geode/Cache.hpp b/cppcache/include/geode/Cache.hpp
index bd8ff4c..fc21add 100644
--- a/cppcache/include/geode/Cache.hpp
+++ b/cppcache/include/geode/Cache.hpp
@@ -24,13 +24,6 @@
 
 #include "internal/geode_globals.hpp"
 #include "GeodeCache.hpp"
-#include "Region.hpp"
-#include "DistributedSystem.hpp"
-#include "QueryService.hpp"
-#include "PoolFactory.hpp"
-#include "RegionShortcut.hpp"
-#include "RegionFactory.hpp"
-#include "TypeRegistry.hpp"
 
 /**
  * @file
@@ -40,15 +33,24 @@ namespace apache {
 namespace geode {
 namespace client {
 
-class PoolManager;
+class AuthenticatedView;
+class AuthInitialize;
 class CacheFactory;
-class CacheRegionHelper;
-class Pool;
 class CacheImpl;
-class AuthInitialize;
+class CacheRegionHelper;
 class CacheTransactionManager;
+class DataInput;
+class DataOutput;
+class DistributedSystem;
+class Pool;
+class PoolFactory;
+class PoolManager;
+class Properties;
+class QueryService;
+class Region;
 class RegionFactory;
-class AuthenticatedView;
+class TypeRegistry;
+enum class RegionShortcut;
 
 /**
  * @class Cache Cache.hpp
@@ -108,6 +110,12 @@ class APACHE_GEODE_EXPORT Cache : public GeodeCache {
   virtual DistributedSystem& getDistributedSystem() const override;
 
   /**
+   * Returns the type registry that this cache was
+   * {@link CacheFactory::create created} with.
+   */
+  virtual TypeRegistry& getTypeRegistry();
+
+  /**
    * Terminates this object cache and releases all the local resources.
    * After this cache is closed, any further
    * method call on this cache or any region object will throw
@@ -198,7 +206,7 @@ class APACHE_GEODE_EXPORT Cache : public GeodeCache {
    */
 
   virtual AuthenticatedView createAuthenticatedView(
-      std::shared_ptr<Properties> userSecurityProperties,
+      const std::shared_ptr<Properties>& userSecurityProperties,
       const std::string& poolName);
 
   /**
@@ -220,8 +228,6 @@ class APACHE_GEODE_EXPORT Cache : public GeodeCache {
    */
   virtual bool getPdxReadSerialized() const override;
 
-  virtual TypeRegistry& getTypeRegistry();
-
   /**
    * Returns a factory that can create a {@link PdxInstance}.
    * @param className the fully qualified class name that the PdxInstance will
@@ -231,7 +237,7 @@ class APACHE_GEODE_EXPORT Cache : public GeodeCache {
    * @return the factory
    */
   virtual std::shared_ptr<PdxInstanceFactory> createPdxInstanceFactory(
-      std::string className) const override;
+      const std::string& className) const override;
 
   virtual std::unique_ptr<DataInput> createDataInput(const uint8_t* m_buffer,
                                                      size_t len) const;
@@ -250,19 +256,17 @@ class APACHE_GEODE_EXPORT Cache : public GeodeCache {
   /**
    * @brief constructors
    */
-  Cache(std::shared_ptr<Properties> dsProp, bool ignorePdxUnreadFields,
+  Cache(const std::shared_ptr<Properties>& dsProp, bool ignorePdxUnreadFields,
         bool readPdxSerialized,
         const std::shared_ptr<AuthInitialize>& authInitialize);
 
   std::unique_ptr<CacheImpl> m_cacheImpl;
-  std::unique_ptr<TypeRegistry> m_typeRegistry;
 
  protected:
   static bool isPoolInMultiuserMode(std::shared_ptr<Region> regionPtr);
 
   friend class CacheFactory;
   friend class CacheRegionHelper;
-  friend class Pool;
   friend class FunctionService;
   friend class CacheXmlCreation;
   friend class RegionXmlCreation;
diff --git a/cppcache/include/geode/Pool.hpp b/cppcache/include/geode/Pool.hpp
index 5345f2f..8befcfa 100644
--- a/cppcache/include/geode/Pool.hpp
+++ b/cppcache/include/geode/Pool.hpp
@@ -305,7 +305,7 @@ class APACHE_GEODE_EXPORT Pool : public std::enable_shared_from_this<Pool> {
 
   friend class PoolFactory;
   friend class CacheFactory;
-  friend class Cache;
+  friend class CacheImpl;
 };
 
 }  // namespace client
diff --git a/cppcache/include/geode/RegionService.hpp b/cppcache/include/geode/RegionService.hpp
index 227f24a..8190953 100644
--- a/cppcache/include/geode/RegionService.hpp
+++ b/cppcache/include/geode/RegionService.hpp
@@ -116,7 +116,7 @@ class APACHE_GEODE_EXPORT RegionService {
    * @return the factory
    */
   virtual std::shared_ptr<PdxInstanceFactory> createPdxInstanceFactory(
-      std::string className) const = 0;
+      const std::string& className) const = 0;
 };
 }  // namespace client
 }  // namespace geode
diff --git a/cppcache/integration-test-2/ExampleTest.cpp b/cppcache/integration-test-2/ExampleTest.cpp
index 8013fd0..9a1da24 100644
--- a/cppcache/integration-test-2/ExampleTest.cpp
+++ b/cppcache/integration-test-2/ExampleTest.cpp
@@ -24,6 +24,8 @@
 
 #include <geode/Cache.hpp>
 #include <geode/PoolManager.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
 
 #include "framework/Framework.h"
 #include "framework/Gfsh.h"
@@ -122,7 +124,6 @@ TEST(ExampleTest, DISABLED_putGetAndUpdateWith1Server) {
 
     region->put(1, "two");
     updatePromise.set_value();
-
   });
   ASSERT_EQ(std::future_status::ready, task2.wait_for(debug_safe(minutes(1))));
 }
diff --git a/cppcache/integration-test-2/RegionPutGetAllTest.cpp b/cppcache/integration-test-2/RegionPutGetAllTest.cpp
index a9361f9..b9726ba 100644
--- a/cppcache/integration-test-2/RegionPutGetAllTest.cpp
+++ b/cppcache/integration-test-2/RegionPutGetAllTest.cpp
@@ -25,6 +25,9 @@
 
 #include <geode/Cache.hpp>
 #include <geode/PoolManager.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
+#include <geode/TypeRegistry.hpp>
 
 #include <VariousPdxTypes.hpp>
 
diff --git a/cppcache/integration-test/CacheHelper.cpp b/cppcache/integration-test/CacheHelper.cpp
index 9d11b34..ac67cd9 100644
--- a/cppcache/integration-test/CacheHelper.cpp
+++ b/cppcache/integration-test/CacheHelper.cpp
@@ -27,6 +27,8 @@
 #include <geode/SystemProperties.hpp>
 #include <geode/PoolManager.hpp>
 #include <geode/internal/chrono/duration.hpp>
+#include <geode/RegionShortcut.hpp>
+#include <geode/RegionFactory.hpp>
 
 #include "CacheRegionHelper.hpp"
 #include "DistributedSystemImpl.hpp"
@@ -705,7 +707,8 @@ std::shared_ptr<Region> CacheHelper::createRegionDiscOverFlow(
         "SqLiteRegionData" +
         std::to_string(static_cast<long long int>(ACE_OS::getpid()));
     sqLiteProps->insert("PersistenceDirectory", sqlite_dir.c_str());
-    regionAttributeFactory.setPersistenceManager("SqLiteImpl", "createSqLiteInstance", sqLiteProps);
+    regionAttributeFactory.setPersistenceManager(
+        "SqLiteImpl", "createSqLiteInstance", sqLiteProps);
   }
 
   auto regionAttributes = regionAttributeFactory.create();
diff --git a/cppcache/integration-test/QueryHelper.hpp b/cppcache/integration-test/QueryHelper.hpp
index e0a8459..ebd969d 100644
--- a/cppcache/integration-test/QueryHelper.hpp
+++ b/cppcache/integration-test/QueryHelper.hpp
@@ -1,8 +1,3 @@
-#pragma once
-
-#ifndef GEODE_INTEGRATION_TEST_QUERYHELPER_H_
-#define GEODE_INTEGRATION_TEST_QUERYHELPER_H_
-
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -20,21 +15,29 @@
  * limitations under the License.
  */
 
+#pragma once
+
+#ifndef GEODE_INTEGRATION_TEST_QUERYHELPER_H_
+#define GEODE_INTEGRATION_TEST_QUERYHELPER_H_
+
 #include <cstdlib>
-#include <geode/SystemProperties.hpp>
+
 #include <ace/OS.h>
 
-#include "DistributedSystemImpl.hpp"
+#include <geode/Region.hpp>
+#include <geode/ResultSet.hpp>
+#include <geode/StructSet.hpp>
+#include <geode/SystemProperties.hpp>
 
+#include "CacheImpl.hpp"
+#include "CacheRegionHelper.hpp"
+#include "DistributedSystemImpl.hpp"
 #include "testobject/Portfolio.hpp"
 #include "testobject/Position.hpp"
 #include "testobject/PdxType.hpp"
 #include "testobject/PortfolioPdx.hpp"
 #include "testobject/PositionPdx.hpp"
-#include <geode/ResultSet.hpp>
-#include <geode/StructSet.hpp>
-#include "CacheRegionHelper.hpp"
-#include "CacheImpl.hpp"
+
 //#include <geode/Struct.hpp>
 
 //#ifndef ROOT_NAME
diff --git a/cppcache/integration-test/ThinClientMultipleCaches.hpp b/cppcache/integration-test/ThinClientMultipleCaches.hpp
index 505bead..98fc92d 100644
--- a/cppcache/integration-test/ThinClientMultipleCaches.hpp
+++ b/cppcache/integration-test/ThinClientMultipleCaches.hpp
@@ -22,10 +22,12 @@
 
 #include <string>
 
-#include "fw_dunit.hpp"
 #include <geode/CacheFactory.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
 
 #include "CacheHelper.hpp"
+#include "fw_dunit.hpp"
 
 using namespace apache::geode::client;
 using namespace test;
diff --git a/cppcache/integration-test/testAttributesMutator.cpp b/cppcache/integration-test/testAttributesMutator.cpp
index e45ea96..558bfb8 100644
--- a/cppcache/integration-test/testAttributesMutator.cpp
+++ b/cppcache/integration-test/testAttributesMutator.cpp
@@ -15,9 +15,14 @@
  * limitations under the License.
  */
 
-#include "fw_dunit.hpp"
-#include "CacheRegionHelper.hpp"
+#include <geode/CacheFactory.hpp>
+#include <geode/Region.hpp>
+#include <geode/RegionAttributesFactory.hpp>
+
 #include "CacheImpl.hpp"
+#include "CacheRegionHelper.hpp"
+
+#include "fw_dunit.hpp"
 
 // this is a test.
 
@@ -39,8 +44,8 @@ DUNIT_TASK(A, Init)
     Test.m_cache = std::make_shared<Cache>(cacheFactory.create());
 
     RegionAttributesFactory regionAttributesFactory;
-    regionAttributesFactory.setEntryTimeToLive(ExpirationAction::LOCAL_INVALIDATE,
-                          std::chrono::seconds(5));
+    regionAttributesFactory.setEntryTimeToLive(
+        ExpirationAction::LOCAL_INVALIDATE, std::chrono::seconds(5));
     auto regionAttributes = regionAttributesFactory.create();
 
     CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(Test.m_cache.get());
diff --git a/cppcache/integration-test/testCache.cpp b/cppcache/integration-test/testCache.cpp
index 567aea0..799d1ee 100644
--- a/cppcache/integration-test/testCache.cpp
+++ b/cppcache/integration-test/testCache.cpp
@@ -18,6 +18,10 @@
 #include <string>
 #include <iostream>
 
+#include <geode/CacheFactory.hpp>
+#include <geode/RegionAttributesFactory.hpp>
+#include <geode/Region.hpp>
+
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
 #include "fw_helper.hpp"
diff --git a/cppcache/integration-test/testExpiration.cpp b/cppcache/integration-test/testExpiration.cpp
index 48d8bbd..bdabc21 100644
--- a/cppcache/integration-test/testExpiration.cpp
+++ b/cppcache/integration-test/testExpiration.cpp
@@ -15,6 +15,9 @@
  * limitations under the License.
  */
 
+#include <geode/ExpirationAction.hpp>
+#include <geode/Region.hpp>
+
 #include "fw_helper.hpp"
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
@@ -74,10 +77,11 @@ std::shared_ptr<CacheableKey> do1Put(std::shared_ptr<Region>& rptr) {
 }
 
 RegionAttributes setRegionAttributesTimeouts(
-    const std::chrono::seconds &entryTimeToLive = std::chrono::seconds::zero(),
-    const std::chrono::seconds &entryIdleTimeout = std::chrono::seconds::zero(),
-    const std::chrono::seconds &regionTimeToLive = std::chrono::seconds::zero(),
-    const std::chrono::seconds &regionIdleTimeout = std::chrono::seconds::zero()) {
+    const std::chrono::seconds& entryTimeToLive = std::chrono::seconds::zero(),
+    const std::chrono::seconds& entryIdleTimeout = std::chrono::seconds::zero(),
+    const std::chrono::seconds& regionTimeToLive = std::chrono::seconds::zero(),
+    const std::chrono::seconds& regionIdleTimeout =
+        std::chrono::seconds::zero()) {
   RegionAttributesFactory regionAttributesFactory;
 
   regionAttributesFactory.setEntryTimeToLive(action, entryTimeToLive);
@@ -118,8 +122,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_2;
 
-    attrs_2 = setRegionAttributesTimeouts(std::chrono::seconds(20), std::chrono::seconds(2),
-                                          std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_2 = setRegionAttributesTimeouts(
+        std::chrono::seconds(20), std::chrono::seconds(2),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R2;
     cacheImpl->createRegion("R2", attrs_2, R2);
@@ -136,8 +141,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_3;
     // rttl = 20, reit = 2
-    attrs_3 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(0),
-                                          std::chrono::seconds(20), std::chrono::seconds(2));
+    attrs_3 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(0),
+        std::chrono::seconds(20), std::chrono::seconds(2));
 
     std::shared_ptr<Region> R3;
     cacheImpl->createRegion("R3", attrs_3, R3);
@@ -149,8 +155,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_4;
 
-    attrs_4 = setRegionAttributesTimeouts(std::chrono::seconds(5), std::chrono::seconds(0),
-                                          std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_4 = setRegionAttributesTimeouts(
+        std::chrono::seconds(5), std::chrono::seconds(0),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R4;
     cacheImpl->createRegion("R4", attrs_4, R4);
@@ -168,8 +175,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_5;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_5 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(5),
-                                          std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_5 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(5),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R5;
     cacheImpl->createRegion("R5", attrs_5, R5);
@@ -196,8 +204,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_6;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_6 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(0),
-                                          std::chrono::seconds(5), std::chrono::seconds(0));
+    attrs_6 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(0),
+        std::chrono::seconds(5), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R6;
     cacheImpl->createRegion("R6", attrs_6, R6);
@@ -215,8 +224,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_7;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_7 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(0),
-                                          std::chrono::seconds(0), std::chrono::seconds(5));
+    attrs_7 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(0),
+        std::chrono::seconds(0), std::chrono::seconds(5));
 
     std::shared_ptr<Region> R7;
     cacheImpl->createRegion("R7", attrs_7, R7);
@@ -234,8 +244,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_8;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_8 = setRegionAttributesTimeouts(std::chrono::seconds(10), std::chrono::seconds(0),
-                                          std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_8 = setRegionAttributesTimeouts(
+        std::chrono::seconds(10), std::chrono::seconds(0),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R8;
     cacheImpl->createRegion("R8", attrs_8, R8);
@@ -254,8 +265,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_9;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_9 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(0),
-                                          std::chrono::seconds(0), std::chrono::seconds(8));
+    attrs_9 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(0),
+        std::chrono::seconds(0), std::chrono::seconds(8));
 
     std::shared_ptr<Region> R9;
     cacheImpl->createRegion("R9", attrs_9, R9);
@@ -276,8 +288,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_10;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_10 = setRegionAttributesTimeouts(std::chrono::seconds(6), std::chrono::seconds(0),
-                                           std::chrono::seconds(0), std::chrono::seconds(12));
+    attrs_10 = setRegionAttributesTimeouts(
+        std::chrono::seconds(6), std::chrono::seconds(0),
+        std::chrono::seconds(0), std::chrono::seconds(12));
 
     std::shared_ptr<Region> R10;
     cacheImpl->createRegion("R10", attrs_10, R10);
@@ -297,8 +310,9 @@ BEGIN_TEST(TEST_EXPIRATION)
     RegionAttributes attrs_11;
 
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_11 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(4),
-                                           std::chrono::seconds(0), std::chrono::seconds(7));
+    attrs_11 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(4),
+        std::chrono::seconds(0), std::chrono::seconds(7));
 
     std::shared_ptr<Region> R11;
     cacheImpl->createRegion("R11", attrs_11, R11);
@@ -324,8 +338,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_12;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_12 = setRegionAttributesTimeouts(std::chrono::seconds(5), std::chrono::seconds(0),
-                                           std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_12 = setRegionAttributesTimeouts(
+        std::chrono::seconds(5), std::chrono::seconds(0),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R12;
     cacheImpl->createRegion("R12", attrs_12, R12);
@@ -343,8 +358,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_14;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_14 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(0),
-                                           std::chrono::seconds(10), std::chrono::seconds(0));
+    attrs_14 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(0),
+        std::chrono::seconds(10), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R14;
     cacheImpl->createRegion("R14", attrs_14, R14);
@@ -358,8 +374,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_15;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_15 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(5),
-                                           std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_15 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(5),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R15;
     cacheImpl->createRegion("R15", attrs_15, R15);
@@ -378,8 +395,9 @@ BEGIN_TEST(TEST_EXPIRATION)
     //////////////
     RegionAttributes attrs_18;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_18 = setRegionAttributesTimeouts(std::chrono::seconds(6), std::chrono::seconds(3),
-                                           std::chrono::seconds(0), std::chrono::seconds(0));
+    attrs_18 = setRegionAttributesTimeouts(
+        std::chrono::seconds(6), std::chrono::seconds(3),
+        std::chrono::seconds(0), std::chrono::seconds(0));
 
     std::shared_ptr<Region> R18;
     cacheImpl->createRegion("R18", attrs_18, R18);
@@ -398,8 +416,9 @@ BEGIN_TEST(TEST_EXPIRATION)
 
     RegionAttributes attrs_19;
     // ettl = 0, eit = 0, rttl = 0, reit = 0
-    attrs_19 = setRegionAttributesTimeouts(std::chrono::seconds(0), std::chrono::seconds(0),
-                                           std::chrono::seconds(6), std::chrono::seconds(3));
+    attrs_19 = setRegionAttributesTimeouts(
+        std::chrono::seconds(0), std::chrono::seconds(0),
+        std::chrono::seconds(6), std::chrono::seconds(3));
 
     std::shared_ptr<Region> R19;
     cacheImpl->createRegion("R19x", attrs_19, R19);
diff --git a/cppcache/integration-test/testLinkage.cpp b/cppcache/integration-test/testLinkage.cpp
index 51a32f4..777a522 100644
--- a/cppcache/integration-test/testLinkage.cpp
+++ b/cppcache/integration-test/testLinkage.cpp
@@ -15,7 +15,10 @@
  * limitations under the License.
  */
 
+#include <geode/AttributesMutator.hpp>
+#include <geode/Region.hpp>
 #include <geode/RegionAttributesFactory.hpp>
+
 #include "fw_helper.hpp"
 
 using namespace apache::geode::client;
diff --git a/cppcache/integration-test/testOverflowPutGetSqLite.cpp b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
index e624fee..e10f19b 100644
--- a/cppcache/integration-test/testOverflowPutGetSqLite.cpp
+++ b/cppcache/integration-test/testOverflowPutGetSqLite.cpp
@@ -20,10 +20,14 @@
 
 #include <ace/OS.h>
 
-#include "fw_helper.hpp"
+#include <geode/RegionShortcut.hpp>
+#include <geode/RegionFactory.hpp>
+
 #include <CacheableToken.hpp>
-#include <MapEntry.hpp>
 #include <CacheRegionHelper.hpp>
+#include <MapEntry.hpp>
+
+#include "fw_helper.hpp"
 
 using namespace apache::geode::client;
 
diff --git a/cppcache/integration-test/testRegionAttributesFactory.cpp b/cppcache/integration-test/testRegionAttributesFactory.cpp
index 526643d..b0a8a46 100644
--- a/cppcache/integration-test/testRegionAttributesFactory.cpp
+++ b/cppcache/integration-test/testRegionAttributesFactory.cpp
@@ -15,9 +15,15 @@
  * limitations under the License.
  */
 
-#include "fw_helper.hpp"
+#include <geode/CacheFactory.hpp>
+#include <geode/Region.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
+
 #include <CacheRegionHelper.hpp>
 
+#include "fw_helper.hpp"
+
 using namespace apache::geode::client;
 
 /* testing attributes with invalid value */
diff --git a/cppcache/integration-test/testRegionTemplateArgs.cpp b/cppcache/integration-test/testRegionTemplateArgs.cpp
index 38ba8df..fcec68a 100644
--- a/cppcache/integration-test/testRegionTemplateArgs.cpp
+++ b/cppcache/integration-test/testRegionTemplateArgs.cpp
@@ -15,8 +15,14 @@
  * limitations under the License.
  */
 
-#include "CacheRegionHelper.hpp"
+#include <geode/CacheFactory.hpp>
+#include <geode/Region.hpp>
+#include <geode/RegionEntry.hpp>
+#include <geode/RegionAttributesFactory.hpp>
+
 #include "CacheImpl.hpp"
+#include "CacheRegionHelper.hpp"
+
 #include "fw_helper.hpp"
 
 using namespace apache::geode::client;
diff --git a/cppcache/integration-test/testThinClientCqDurable.cpp b/cppcache/integration-test/testThinClientCqDurable.cpp
index 07539d3..ced2e40 100644
--- a/cppcache/integration-test/testThinClientCqDurable.cpp
+++ b/cppcache/integration-test/testThinClientCqDurable.cpp
@@ -14,26 +14,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "fw_dunit.hpp"
-#include "ThinClientHelper.hpp"
+
+#include <string>
+#include <thread>
+#include <chrono>
+
+#include <ace/OS.h>
+#include <ace/High_Res_Timer.h>
+
 #include <geode/CqAttributesFactory.hpp>
 #include <geode/CqAttributes.hpp>
 #include <geode/CqListener.hpp>
 #include <geode/CqQuery.hpp>
-#include <ace/OS.h>
-#include <ace/High_Res_Timer.h>
-#include <string>
-#include <thread>
-#include <chrono>
+#include <geode/RegionFactory.hpp>
 
-#define ROOT_SCOPE DISTRIBUTED_ACK
+#include "fw_dunit.hpp"
+#include "ThinClientHelper.hpp"
 
-#include "QueryStrings.hpp"
-#include "QueryHelper.hpp"
+#define ROOT_SCOPE DISTRIBUTED_ACK
 
 #include <geode/Query.hpp>
 #include <geode/QueryService.hpp>
+#include <geode/RegionShortcut.hpp>
 
+#include "QueryStrings.hpp"
+#include "QueryHelper.hpp"
 #include "ThinClientCQ.hpp"
 
 using namespace apache::geode::client;
diff --git a/cppcache/integration-test/testThinClientSecurityMultiUserTest.cpp b/cppcache/integration-test/testThinClientSecurityMultiUserTest.cpp
index ffc0a60..1da4069 100644
--- a/cppcache/integration-test/testThinClientSecurityMultiUserTest.cpp
+++ b/cppcache/integration-test/testThinClientSecurityMultiUserTest.cpp
@@ -16,6 +16,8 @@
  */
 
 #include <geode/AuthInitialize.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
 
 #include "fw_dunit.hpp"
 #include "ThinClientSecurity.hpp"
diff --git a/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp b/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
index ff1b5b3..56d34fc 100644
--- a/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
+++ b/cppcache/integration-test/testXmlCacheCreationWithRefid.cpp
@@ -20,6 +20,7 @@
 #include <math.h>
 
 #include <geode/CacheFactory.hpp>
+#include <geode/Region.hpp>
 
 #include "fw_helper.hpp"
 
@@ -35,8 +36,8 @@ int testXmlCacheCreationWithRefid(const char* fileName) {
 
   std::cout << "create DistributedSytem with name=" << host_name << std::endl;
   std::cout << "Create cache with the configurations provided in "
-          "valid_cache_refid.xml"
-       << std::endl;
+               "valid_cache_refid.xml"
+            << std::endl;
 
   try {
     const auto filePath = directory + fileName;
@@ -77,7 +78,8 @@ int testXmlCacheCreationWithRefid(const char* fileName) {
     return -1;
   }
 
-  std::cout << "Verify whether region 'SubRegion11' has correct attributes" << std::endl;
+  std::cout << "Verify whether region 'SubRegion11' has correct attributes"
+            << std::endl;
 
   auto atts = SubRegion11->getAttributes();
 
@@ -101,7 +103,8 @@ int testXmlCacheCreationWithRefid(const char* fileName) {
     return -1;
   }
 
-  std::cout << "Verify whether region 'SubRegion2' has correct attributes" << std::endl;
+  std::cout << "Verify whether region 'SubRegion2' has correct attributes"
+            << std::endl;
 
   atts = SubRegion2->getAttributes();
 
@@ -125,7 +128,8 @@ int testXmlCacheCreationWithRefid(const char* fileName) {
     return -1;
   }
 
-  std::cout << "Verify whether region 'SubRegion21' has correct attributes" << std::endl;
+  std::cout << "Verify whether region 'SubRegion21' has correct attributes"
+            << std::endl;
 
   atts = SubRegion21->getAttributes();
 
@@ -169,7 +173,8 @@ int testXmlCacheCreationWithRefid(const char* fileName) {
     return -1;
   }
 
-  std::cout << "Verify whether region 'Root2' has correct attributes" << std::endl;
+  std::cout << "Verify whether region 'Root2' has correct attributes"
+            << std::endl;
 
   atts = Root2->getAttributes();
 
diff --git a/cppcache/src/AuthenticatedView.cpp b/cppcache/src/AuthenticatedView.cpp
index 08363e5..e6bc77e 100644
--- a/cppcache/src/AuthenticatedView.cpp
+++ b/cppcache/src/AuthenticatedView.cpp
@@ -89,7 +89,7 @@ std::shared_ptr<Region> AuthenticatedView::getRegion(
     std::shared_ptr<Region> result;
 
     if (m_cacheImpl != nullptr && !m_cacheImpl->isClosed()) {
-      m_cacheImpl->getRegion(path.c_str(), result);
+      result = m_cacheImpl->getRegion(path);
     }
 
     if (result != nullptr) {
@@ -136,11 +136,9 @@ std::vector<std::shared_ptr<Region>> AuthenticatedView::rootRegions() const {
   std::vector<std::shared_ptr<Region>> regions;
 
   if (!m_isAuthenticatedViewClosed && m_cacheImpl && !m_cacheImpl->isClosed()) {
-    std::vector<std::shared_ptr<Region>> tmp;
-
     // this can cause issue when pool attached with region in multiuserSecure
     // mode
-    m_cacheImpl->rootRegions(tmp);
+    auto tmp = m_cacheImpl->rootRegions();
     regions.reserve(tmp.size());
 
     for (const auto& reg : tmp) {
@@ -167,8 +165,9 @@ AuthenticatedView::AuthenticatedView(std::shared_ptr<Properties> credentials,
       m_cacheImpl(cacheImpl) {}
 
 AuthenticatedView::~AuthenticatedView() {}
+
 std::shared_ptr<PdxInstanceFactory> AuthenticatedView::createPdxInstanceFactory(
-    std::string className) const {
+    const std::string& className) const {
   return std::make_shared<PdxInstanceFactoryImpl>(
       className.c_str(), &(m_cacheImpl->getCachePerfStats()),
       m_cacheImpl->getPdxTypeRegistry(), m_cacheImpl,
diff --git a/cppcache/src/Cache.cpp b/cppcache/src/Cache.cpp
index 56e5baf..4aed84c 100644
--- a/cppcache/src/Cache.cpp
+++ b/cppcache/src/Cache.cpp
@@ -22,22 +22,20 @@
 #include <geode/PoolManager.hpp>
 #include <geode/DistributedSystem.hpp>
 #include <geode/Cache.hpp>
+#include <geode/RegionFactory.hpp>
 
 #include "DistributedSystemImpl.hpp"
-#include "CacheXmlParser.hpp"
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"
 #include "UserAttributes.hpp"
 #include "ProxyRegion.hpp"
-#include "PdxInstanceFactoryImpl.hpp"
-
-#define DEFAULT_DS_NAME "default_GeodeDS"
 
 namespace apache {
 namespace geode {
 namespace client {
 
-/** Returns the name of this cache.
+/**
+ * Returns the name of this cache.
  * This method does not throw
  * <code>CacheClosedException</code> if the cache is closed.
  * @return the string name of this cache
@@ -63,6 +61,14 @@ DistributedSystem& Cache::getDistributedSystem() const {
   return m_cacheImpl->getDistributedSystem();
 }
 
+/**
+ * Returns the type registry that this cache was
+ * {@link CacheFactory::create created} with.
+ */
+TypeRegistry& Cache::getTypeRegistry() {
+  return m_cacheImpl->getTypeRegistry();
+}
+
 void Cache::close() { close(false); }
 
 /**
@@ -73,32 +79,10 @@ void Cache::close() { close(false); }
  * @param keepalive whether to keep the durable client's queue
  * @throws CacheClosedException,  if the cache is already closed.
  */
-void Cache::close(bool keepalive) {
-  m_cacheImpl->close(keepalive);
-
-  try {
-    getDistributedSystem().disconnect();
-  } catch (const apache::geode::client::NotConnectedException&) {
-  } catch (const apache::geode::client::Exception&) {
-  } catch (...) {
-  }
-}
+void Cache::close(bool keepalive) { m_cacheImpl->close(keepalive); }
 
 std::shared_ptr<Region> Cache::getRegion(const std::string& path) const {
-  LOGDEBUG("Cache::getRegion " + path);
-  std::shared_ptr<Region> result;
-  m_cacheImpl->getRegion(path.c_str(), result);
-
-  if (result != nullptr) {
-    if (isPoolInMultiuserMode(result)) {
-      LOGWARN("Pool " + result->getAttributes().getPoolName() +
-              " attached with region " + result->getFullPath() +
-              " is in multiuser authentication mode. Operations may fail as "
-              "this instance does not have any credentials.");
-    }
-  }
-
-  return result;
+  return m_cacheImpl->getRegion(path);
 }
 
 /**
@@ -109,11 +93,8 @@ std::shared_ptr<Region> Cache::getRegion(const std::string& path) const {
  * @param regions the region collection object containing the returned set of
  * regions when the function returns
  */
-
 std::vector<std::shared_ptr<Region>> Cache::rootRegions() const {
-  std::vector<std::shared_ptr<Region>> regions;
-  m_cacheImpl->rootRegions(regions);
-  return regions;
+  return m_cacheImpl->rootRegions();
 }
 
 RegionFactory Cache::createRegionFactory(RegionShortcut preDefinedRegion) {
@@ -123,39 +104,32 @@ RegionFactory Cache::createRegionFactory(RegionShortcut preDefinedRegion) {
 std::shared_ptr<QueryService> Cache::getQueryService() {
   return m_cacheImpl->getQueryService();
 }
+
 std::shared_ptr<QueryService> Cache::getQueryService(
     const std::string& poolName) const {
   return m_cacheImpl->getQueryService(poolName.c_str());
 }
+
 std::shared_ptr<CacheTransactionManager> Cache::getCacheTransactionManager()
     const {
   return m_cacheImpl->getCacheTransactionManager();
 }
 
-TypeRegistry& Cache::getTypeRegistry() { return *(m_typeRegistry.get()); }
-
-Cache::Cache(std::shared_ptr<Properties> dsProp, bool ignorePdxUnreadFields,
-             bool readPdxSerialized,
-             const std::shared_ptr<AuthInitialize>& authInitialize) {
-  auto distributedSystem = DistributedSystem::create(DEFAULT_DS_NAME, dsProp);
-  m_cacheImpl = std::unique_ptr<CacheImpl>(
-      new CacheImpl(this, std::move(distributedSystem), ignorePdxUnreadFields,
-                    readPdxSerialized, authInitialize));
-  m_cacheImpl->getDistributedSystem().connect(this);
-  m_typeRegistry =
-      std::unique_ptr<TypeRegistry>(new TypeRegistry(m_cacheImpl.get()));
-}
+Cache::Cache(const std::shared_ptr<Properties>& dsProp,
+             bool ignorePdxUnreadFields, bool readPdxSerialized,
+             const std::shared_ptr<AuthInitialize>& authInitialize)
+    : m_cacheImpl(std::unique_ptr<CacheImpl>(
+          new CacheImpl(this, dsProp, ignorePdxUnreadFields, readPdxSerialized,
+                        authInitialize))) {}
 
 Cache::Cache(Cache&& other) noexcept
-    : m_cacheImpl(std::move(other.m_cacheImpl)),
-      m_typeRegistry(std::move(other.m_typeRegistry)) {
+    : m_cacheImpl(std::move(other.m_cacheImpl)) {
   m_cacheImpl->setCache(this);
 }
 
 Cache& Cache::operator=(Cache&& other) noexcept {
   if (this != &other) {
     m_cacheImpl = std::move(other.m_cacheImpl);
-    m_typeRegistry = std::move(other.m_typeRegistry);
     m_cacheImpl->setCache(this);
   }
   return *this;
@@ -164,26 +138,13 @@ Cache& Cache::operator=(Cache&& other) noexcept {
 Cache::~Cache() = default;
 
 void Cache::initializeDeclarativeCache(const std::string& cacheXml) {
-  CacheXmlParser* xmlParser = CacheXmlParser::parse(cacheXml.c_str(), this);
-  xmlParser->setAttributes(this);
-  m_cacheImpl->initServices();
-  xmlParser->create(this);
-  delete xmlParser;
-  xmlParser = nullptr;
+  m_cacheImpl->initializeDeclarativeCache(cacheXml);
 }
 
 void Cache::readyForEvents() { m_cacheImpl->readyForEvents(); }
 
 bool Cache::isPoolInMultiuserMode(std::shared_ptr<Region> regionPtr) {
-  const auto& poolName = regionPtr->getAttributes().getPoolName();
-
-  if (!poolName.empty()) {
-    auto poolPtr = regionPtr->getCache().getPoolManager().find(poolName);
-    if (poolPtr != nullptr && !poolPtr->isDestroyed()) {
-      return poolPtr->getMultiuserAuthentication();
-    }
-  }
-  return false;
+  return CacheImpl::isPoolInMultiuserMode(regionPtr);
 }
 
 bool Cache::getPdxIgnoreUnreadFields() const {
@@ -193,44 +154,16 @@ bool Cache::getPdxIgnoreUnreadFields() const {
 bool Cache::getPdxReadSerialized() const {
   return m_cacheImpl->getPdxReadSerialized();
 }
+
 std::shared_ptr<PdxInstanceFactory> Cache::createPdxInstanceFactory(
-    std::string className) const {
-  return std::make_shared<PdxInstanceFactoryImpl>(
-      className.c_str(), m_cacheImpl->m_cacheStats,
-      m_cacheImpl->getPdxTypeRegistry(), m_cacheImpl.get(),
-      m_cacheImpl->getDistributedSystem()
-          .getSystemProperties()
-          .getEnableTimeStatistics());
+    const std::string& className) const {
+  return m_cacheImpl->createPdxInstanceFactory(className);
 }
+
 AuthenticatedView Cache::createAuthenticatedView(
-    std::shared_ptr<Properties> userSecurityProperties,
+    const std::shared_ptr<Properties>& userSecurityProperties,
     const std::string& poolName) {
-  if (poolName.empty()) {
-    auto pool = m_cacheImpl->getPoolManager().getDefaultPool();
-    if (!this->isClosed() && pool != nullptr) {
-      return pool->createAuthenticatedView(userSecurityProperties,
-                                           m_cacheImpl.get());
-    }
-
-    throw IllegalStateException(
-        "Either cache has been closed or there are more than two pool."
-        "Pass poolname to get the secure Cache");
-  } else {
-    if (!this->isClosed()) {
-      if (!poolName.empty()) {
-        auto poolPtr = m_cacheImpl->getPoolManager().find(poolName);
-        if (poolPtr != nullptr && !poolPtr->isDestroyed()) {
-          return poolPtr->createAuthenticatedView(userSecurityProperties,
-                                                  m_cacheImpl.get());
-        }
-        throw IllegalStateException(
-            "Either pool not found or it has been destroyed");
-      }
-      throw IllegalArgumentException("poolname is nullptr");
-    }
-
-    throw IllegalStateException("Cache has been closed");
-  }
+  return m_cacheImpl->createAuthenticatedView(userSecurityProperties, poolName);
 }
 
 PoolManager& Cache::getPoolManager() const {
diff --git a/cppcache/src/CacheImpl.cpp b/cppcache/src/CacheImpl.cpp
index 330933c..549960d 100644
--- a/cppcache/src/CacheImpl.cpp
+++ b/cppcache/src/CacheImpl.cpp
@@ -23,6 +23,7 @@
 #include <geode/PoolManager.hpp>
 #include <geode/RegionAttributes.hpp>
 #include <geode/PersistenceManager.hpp>
+#include <geode/RegionFactory.hpp>
 
 #include "CacheImpl.hpp"
 #include "Utils.hpp"
@@ -42,10 +43,14 @@
 #include "PdxTypeRegistry.hpp"
 #include "SerializationRegistry.hpp"
 #include "ThreadPool.hpp"
+#include "PdxInstanceFactoryImpl.hpp"
+#include "CacheXmlParser.hpp"
+
+#define DEFAULT_DS_NAME "default_GeodeDS"
 
 using namespace apache::geode::client;
 
-CacheImpl::CacheImpl(Cache* c, DistributedSystem&& distributedSystem,
+CacheImpl::CacheImpl(Cache* c, const std::shared_ptr<Properties>& dsProps,
                      bool ignorePdxUnreadFields, bool readPdxSerialized,
                      const std::shared_ptr<AuthInitialize>& authInitialize)
     : m_ignorePdxUnreadFields(ignorePdxUnreadFields),
@@ -55,7 +60,7 @@ CacheImpl::CacheImpl(Cache* c, DistributedSystem&& distributedSystem,
       m_statisticsManager(nullptr),
       m_closed(false),
       m_initialized(false),
-      m_distributedSystem(std::move(distributedSystem)),
+      m_distributedSystem(DistributedSystem::create(DEFAULT_DS_NAME, dsProps)),
       m_clientProxyMembershipIDFactory(m_distributedSystem.getName()),
       m_cache(c),
       m_cond(m_mutex),
@@ -73,7 +78,6 @@ CacheImpl::CacheImpl(Cache* c, DistributedSystem&& distributedSystem,
       m_threadPool(new ThreadPool(
           m_distributedSystem.getSystemProperties().threadPoolSize())),
       m_authInitialize(authInitialize) {
-
   m_cacheTXManager = std::shared_ptr<InternalCacheTransactionManager2PC>(
       new InternalCacheTransactionManager2PCImpl(this));
 
@@ -91,6 +95,7 @@ CacheImpl::CacheImpl(Cache* c, DistributedSystem&& distributedSystem,
   m_initialized = true;
   m_pdxTypeRegistry = std::make_shared<PdxTypeRegistry>(this);
   m_poolManager = std::unique_ptr<PoolManager>(new PoolManager(this));
+  m_typeRegistry = std::unique_ptr<TypeRegistry>(new TypeRegistry(this));
 
   try {
     m_statisticsManager =
@@ -104,6 +109,8 @@ CacheImpl::CacheImpl(Cache* c, DistributedSystem&& distributedSystem,
     Log::close();
     throw;
   }
+
+  m_distributedSystem.connect(m_cache);
 }
 
 void CacheImpl::initServices() {
@@ -246,6 +253,8 @@ DistributedSystem& CacheImpl::getDistributedSystem() {
   return m_distributedSystem;
 }
 
+TypeRegistry& CacheImpl::getTypeRegistry() { return *m_typeRegistry.get(); }
+
 void CacheImpl::sendNotificationCloseMsgs() {
   for (const auto& iter : getPoolManager().getAll()) {
     if (const auto& pool =
@@ -333,6 +342,13 @@ void CacheImpl::close(bool keepalive) {
 
   m_expiryTaskManager->stopExpiryTaskManager();
 
+  try {
+    getDistributedSystem().disconnect();
+  } catch (const apache::geode::client::NotConnectedException&) {
+  } catch (const apache::geode::client::Exception&) {
+  } catch (...) {
+  }
+
   m_closed = true;
 
   LOGFINE("Cache closed.");
@@ -475,13 +491,13 @@ void CacheImpl::createRegion(std::string name,
  * @throws IllegalArgumentException if path is null, the empty string, or "/"
  */
 
-void CacheImpl::getRegion(const std::string& path,
-                          std::shared_ptr<Region>& rptr) {
+std::shared_ptr<Region> CacheImpl::getRegion(const std::string& path) {
+  LOGDEBUG("Cache::getRegion " + path);
+
   TryReadGuard guardCacheDestroy(m_destroyCacheMutex, m_destroyPending);
-  rptr = nullptr;
 
   if (m_destroyPending) {
-    return;
+    return nullptr;
   }
 
   MapOfRegionGuard guard(m_regions->mutex());
@@ -494,24 +510,31 @@ void CacheImpl::getRegion(const std::string& path,
   if (fullname.substr(0, 1) == slash) {
     fullname = path.substr(1);
   }
+
   // find second separator
-  uint32_t idx = static_cast<uint32_t>(fullname.find('/'));
+  auto idx = static_cast<uint32_t>(fullname.find('/'));
   auto stepname = fullname.substr(0, idx);
-  std::shared_ptr<Region> region;
+
+  std::shared_ptr<Region> region = nullptr;
+
   if (0 == m_regions->find(stepname, region)) {
-    if (stepname == fullname) {
-      // done...
-      rptr = region;
-      return;
-    }
-    auto remainder = fullname.substr(stepname.length() + 1);
-    if (region != nullptr) {
-      rptr = region->getSubregion(remainder.c_str());
-    } else {
-      rptr = nullptr;
-      return;  // Return null if the parent region was not found.
+    if (stepname != fullname) {
+      auto remainder = fullname.substr(stepname.length() + 1);
+
+      if (region != nullptr) {
+        region = region->getSubregion(remainder.c_str());
+      }
     }
   }
+
+  if (region != nullptr && isPoolInMultiuserMode(region)) {
+    LOGWARN("Pool " + region->getAttributes().getPoolName() +
+            " attached with region " + region->getFullPath() +
+            " is in multiuser authentication mode. Operations may fail as "
+            "this instance does not have any credentials.");
+  }
+
+  return region;
 }
 
 std::shared_ptr<RegionInternal> CacheImpl::createRegion_internal(
@@ -580,17 +603,32 @@ std::shared_ptr<RegionInternal> CacheImpl::createRegion_internal(
   return rptr;
 }
 
-void CacheImpl::rootRegions(std::vector<std::shared_ptr<Region>>& regions) {
-  regions.clear();
+std::vector<std::shared_ptr<Region>> CacheImpl::rootRegions() {
+  std::vector<std::shared_ptr<Region>> regions;
+
   MapOfRegionGuard guard(m_regions->mutex());
-  if (m_regions->current_size() == 0) return;
-  regions.reserve(static_cast<int32_t>(m_regions->current_size()));
-  for (MapOfRegionWithLock::iterator q = m_regions->begin();
-       q != m_regions->end(); ++q) {
-    if (!(*q).int_id_->isDestroyed()) {
-      regions.push_back((*q).int_id_);
+
+  if (m_regions->current_size() != 0) {
+    regions.reserve(static_cast<int32_t>(m_regions->current_size()));
+
+    for (MapOfRegionWithLock::iterator q = m_regions->begin();
+         q != m_regions->end(); ++q) {
+      if (!(*q).int_id_->isDestroyed()) {
+        regions.push_back((*q).int_id_);
+      }
     }
   }
+
+  return regions;
+}
+
+void CacheImpl::initializeDeclarativeCache(const std::string& cacheXml) {
+  CacheXmlParser* xmlParser = CacheXmlParser::parse(cacheXml.c_str(), m_cache);
+  xmlParser->setAttributes(m_cache);
+  initServices();
+  xmlParser->create(m_cache);
+  delete xmlParser;
+  xmlParser = nullptr;
 }
 
 EvictionController* CacheImpl::getEvictionController() {
@@ -636,6 +674,19 @@ void CacheImpl::readyForEvents() {
   }
 }
 
+bool CacheImpl::isPoolInMultiuserMode(std::shared_ptr<Region> regionPtr) {
+  const auto& poolName = regionPtr->getAttributes().getPoolName();
+
+  if (!poolName.empty()) {
+    auto poolPtr = regionPtr->getCache().getPoolManager().find(poolName);
+    if (poolPtr != nullptr && !poolPtr->isDestroyed()) {
+      return poolPtr->getMultiuserAuthentication();
+    }
+  }
+
+  return false;
+}
+
 bool CacheImpl::getEndpointStatus(const std::string& endpoint) {
   const auto& pools = getPoolManager().getAll();
   std::string fullName = endpoint;
@@ -784,4 +835,40 @@ std::unique_ptr<DataInput> CacheImpl::createDataInput(const uint8_t* buffer,
   return std::unique_ptr<DataInput>(new DataInput(buffer, len, this, pool));
 }
 
+std::shared_ptr<PdxInstanceFactory> CacheImpl::createPdxInstanceFactory(
+    const std::string& className) const {
+  return std::make_shared<PdxInstanceFactoryImpl>(
+      className, m_cacheStats, m_pdxTypeRegistry, this,
+      m_distributedSystem.getSystemProperties().getEnableTimeStatistics());
+}
+
+AuthenticatedView CacheImpl::createAuthenticatedView(
+    std::shared_ptr<Properties> userSecurityProperties,
+    const std::string& poolName) {
+  if (poolName.empty()) {
+    auto pool = m_poolManager->getDefaultPool();
+    if (!this->isClosed() && pool != nullptr) {
+      return pool->createAuthenticatedView(userSecurityProperties, this);
+    }
+
+    throw IllegalStateException(
+        "Either cache has been closed or there are more than two pool."
+        "Pass poolname to get the secure Cache");
+  } else {
+    if (!this->isClosed()) {
+      if (!poolName.empty()) {
+        auto poolPtr = m_poolManager->find(poolName);
+        if (poolPtr != nullptr && !poolPtr->isDestroyed()) {
+          return poolPtr->createAuthenticatedView(userSecurityProperties, this);
+        }
+        throw IllegalStateException(
+            "Either pool not found or it has been destroyed");
+      }
+      throw IllegalArgumentException("poolname is nullptr");
+    }
+
+    throw IllegalStateException("Cache has been closed");
+  }
+}
+
 void CacheImpl::setCache(Cache* cache) { m_cache = cache; }
diff --git a/cppcache/src/CacheImpl.hpp b/cppcache/src/CacheImpl.hpp
index efeb409..6477009 100644
--- a/cppcache/src/CacheImpl.hpp
+++ b/cppcache/src/CacheImpl.hpp
@@ -21,18 +21,20 @@
 #define GEODE_CACHEIMPL_H_
 
 #include <atomic>
-
-#include <geode/internal/geode_globals.hpp>
 #include <memory>
 
-#include <geode/Cache.hpp>
-#include <geode/CacheAttributes.hpp>
-#include <geode/DistributedSystem.hpp>
-#include "MapWithLock.hpp"
 #include <ace/ACE.h>
 #include <ace/Time_Value.h>
 #include <ace/Guard_T.h>
 #include <ace/Recursive_Thread_Mutex.h>
+
+#include <geode/internal/geode_globals.hpp>
+#include <geode/Cache.hpp>
+#include <geode/CacheAttributes.hpp>
+#include <geode/DistributedSystem.hpp>
+#include <geode/TypeRegistry.hpp>
+
+#include "MapWithLock.hpp"
 #include "Condition.hpp"
 #include "TcrConnectionManager.hpp"
 #include "EvictionController.hpp"
@@ -42,12 +44,8 @@
 #include "PdxTypeRegistry.hpp"
 #include "MemberListForVersionStamp.hpp"
 #include "ClientProxyMembershipIDFactory.hpp"
-
-#include <string>
-#include <string>
-#include <map>
-
 #include "NonCopyable.hpp"
+
 #define DEFAULT_LRU_MAXIMUM_ENTRIES 100000
 /** @todo period '.' consistency */
 /** @todo fix returns to param documentation of result ptr... */
@@ -60,11 +58,14 @@ namespace apache {
 namespace geode {
 namespace client {
 
-class ThreadPool;
 class CacheFactory;
+class CacheStatistics;
 class ExpiryTaskManager;
 class PdxTypeRegistry;
+class Pool;
+class RegionAttributes;
 class SerializationRegistry;
+class ThreadPool;
 
 /**
  * @class Cache Cache.hpp
@@ -146,6 +147,12 @@ class APACHE_GEODE_EXPORT CacheImpl : private NonCopyable,
   DistributedSystem& getDistributedSystem();
 
   /**
+   * Returns the type registry that this cache was
+   * {@link CacheFactory::create created} with.
+   */
+  TypeRegistry& getTypeRegistry();
+
+  /**
    * Terminates this object cache and releases all the local resources.
    * After this cache is closed, any further
    * method call on this cache or any region object will throw
@@ -175,7 +182,7 @@ class APACHE_GEODE_EXPORT CacheImpl : private NonCopyable,
   void createRegion(std::string name, RegionAttributes aRegionAttributes,
                     std::shared_ptr<Region>& regionPtr);
 
-  void getRegion(const std::string& path, std::shared_ptr<Region>& rptr);
+  std::shared_ptr<Region> getRegion(const std::string& path);
 
   /**
    * Returns a set of root regions in the cache. Does not cause any
@@ -185,20 +192,23 @@ class APACHE_GEODE_EXPORT CacheImpl : private NonCopyable,
    * @param regions the region collection object containing the returned set of
    * regions when the function returns
    */
-  void rootRegions(std::vector<std::shared_ptr<Region>>& regions);
+  std::vector<std::shared_ptr<Region>> rootRegions();
 
   virtual RegionFactory createRegionFactory(RegionShortcut preDefinedRegion);
 
+  void initializeDeclarativeCache(const std::string& cacheXml);
+
   std::shared_ptr<CacheTransactionManager> getCacheTransactionManager();
 
   /**
    * @brief destructor
    */
   virtual ~CacheImpl();
+
   /**
    * @brief constructors
    */
-  CacheImpl(Cache* c, DistributedSystem&& distributedSystem,
+  CacheImpl(Cache* c, const std::shared_ptr<Properties>& dsProps,
             bool ignorePdxUnreadFields, bool readPdxSerialized,
             const std::shared_ptr<AuthInitialize>& authInitialize);
 
@@ -234,6 +244,8 @@ class APACHE_GEODE_EXPORT CacheImpl : private NonCopyable,
    */
   void readyForEvents();
 
+  static bool isPoolInMultiuserMode(std::shared_ptr<Region> regionPtr);
+
   //  TESTING: Durable clients. Not thread safe.
   bool getEndpointStatus(const std::string& endpoint);
 
@@ -288,6 +300,13 @@ class APACHE_GEODE_EXPORT CacheImpl : private NonCopyable,
                                                      size_t len,
                                                      Pool* pool) const;
 
+  std::shared_ptr<PdxInstanceFactory> createPdxInstanceFactory(
+      const std::string& className) const;
+
+  AuthenticatedView createAuthenticatedView(
+      std::shared_ptr<Properties> userSecurityProperties,
+      const std::string& poolName);
+
  private:
   std::atomic<bool> m_networkhop;
   std::atomic<int> m_blacklistBucketTimeout;
@@ -353,6 +372,7 @@ class APACHE_GEODE_EXPORT CacheImpl : private NonCopyable,
   std::shared_ptr<PdxTypeRegistry> m_pdxTypeRegistry;
   ThreadPool* m_threadPool;
   const std::shared_ptr<AuthInitialize> m_authInitialize;
+  std::unique_ptr<TypeRegistry> m_typeRegistry;
 
   friend class CacheFactory;
   friend class Cache;
diff --git a/cppcache/src/ClientMetadataService.cpp b/cppcache/src/ClientMetadataService.cpp
index 8109692..26d9302 100644
--- a/cppcache/src/ClientMetadataService.cpp
+++ b/cppcache/src/ClientMetadataService.cpp
@@ -199,7 +199,7 @@ std::shared_ptr<ClientMetadata> ClientMetadataService::SendClientPRMetadata(
   GfErrType err = tcrdm->sendSyncRequest(request, reply);
   if (err == GF_NOERR &&
       reply.getMessageType() == TcrMessage::RESPONSE_CLIENT_PR_METADATA) {
-    tcrdm->getConnectionManager().getCacheImpl()->getRegion(regionPath, region);
+    region = tcrdm->getConnectionManager().getCacheImpl()->getRegion(regionPath);
     if (region != nullptr) {
       LocalRegion* lregion = dynamic_cast<LocalRegion*>(region.get());
       lregion->getRegionStats()->incMetaDataRefreshCount();
@@ -302,10 +302,9 @@ void ClientMetadataService::enqueueForMetadataRefresh(
     throw IllegalArgumentException(
         "ClientMetaData: pool cast to ThinClientPoolDM failed");
   }
-  std::shared_ptr<Region> region;
 
   auto cache = tcrdm->getConnectionManager().getCacheImpl();
-  cache->getRegion(regionFullPath, region);
+  auto region = cache->getRegion(regionFullPath);
 
   std::string serverGroup = tcrdm->getServerGroup();
   if (serverGroup.length() != 0) {
diff --git a/cppcache/src/EvictionController.cpp b/cppcache/src/EvictionController.cpp
index 2590e70..e6b3278 100644
--- a/cppcache/src/EvictionController.cpp
+++ b/cppcache/src/EvictionController.cpp
@@ -147,22 +147,21 @@ void EvictionController::evict(int32_t percentage) {
   // On the flip side, this requires a copy of the registered region list
   // every time eviction is ordered and that might not be cheap
   //@TODO: Discuss with team
-  VectorOfString regionTmpVector;
+  VectorOfString regionTempVector;
   {
     ReadGuard guard(m_regionLock);
     for (size_t i = 0; i < m_regions.size(); i++) {
-      regionTmpVector.push_back(m_regions.at(i));
+      regionTempVector.push_back(m_regions.at(i));
     }
   }
 
-  for (size_t i = 0; i < regionTmpVector.size(); i++) {
-    std::string str = regionTmpVector.at(i);
-    std::shared_ptr<Region> rptr;
-    m_cacheImpl->getRegion(str.c_str(), rptr);
-    if (rptr != nullptr) {
-      RegionInternal* rimpl = dynamic_cast<RegionInternal*>(rptr.get());
-      if (rimpl != nullptr) {
-        rimpl->evict(percentage);
+  for (size_t i = 0; i < regionTempVector.size(); i++) {
+    std::string region_name = regionTempVector.at(i);
+    auto region = m_cacheImpl->getRegion(region_name);
+    if (region != nullptr) {
+      RegionInternal* regionImpl = dynamic_cast<RegionInternal*>(region.get());
+      if (regionImpl != nullptr) {
+        regionImpl->evict(percentage);
       }
     }
   }
diff --git a/cppcache/src/FunctionService.cpp b/cppcache/src/FunctionService.cpp
index 098bc99..f4a7f54 100644
--- a/cppcache/src/FunctionService.cpp
+++ b/cppcache/src/FunctionService.cpp
@@ -57,8 +57,7 @@ Execution FunctionService::onRegion(const std::shared_ptr<Region>& region) {
       }
       // getting real region to execute function on region
       if (!realRegion->getCache().isClosed()) {
-        realRegion->getCache().m_cacheImpl->getRegion(realRegion->getName(),
-                                                      realRegion);
+        realRegion = realRegion->getCache().m_cacheImpl->getRegion(realRegion->getName());
       } else {
         throw IllegalStateException("Cache has been closed");
       }
diff --git a/cppcache/src/PdxInstanceFactoryImpl.cpp b/cppcache/src/PdxInstanceFactoryImpl.cpp
index ef6860d..bf28168 100644
--- a/cppcache/src/PdxInstanceFactoryImpl.cpp
+++ b/cppcache/src/PdxInstanceFactoryImpl.cpp
@@ -27,7 +27,7 @@ namespace client {
 PdxInstanceFactoryImpl::~PdxInstanceFactoryImpl() {}
 
 PdxInstanceFactoryImpl::PdxInstanceFactoryImpl(
-    std::string className, CachePerfStats* cachePerfStats,
+    const std::string& className, CachePerfStats* cachePerfStats,
     std::shared_ptr<PdxTypeRegistry> pdxTypeRegistry, const CacheImpl* cache,
     bool enableTimeStatistics)
     : m_created(false),
diff --git a/cppcache/src/PdxInstanceFactoryImpl.hpp b/cppcache/src/PdxInstanceFactoryImpl.hpp
index 975bac6..b8beebf 100644
--- a/cppcache/src/PdxInstanceFactoryImpl.hpp
+++ b/cppcache/src/PdxInstanceFactoryImpl.hpp
@@ -137,7 +137,8 @@ class APACHE_GEODE_EXPORT PdxInstanceFactoryImpl
   virtual std::shared_ptr<PdxInstanceFactory> markIdentityField(
       const std::string& fieldName) override;
 
-  PdxInstanceFactoryImpl(std::string className, CachePerfStats* cachePerfStats,
+  PdxInstanceFactoryImpl(const std::string& className,
+                         CachePerfStats* cachePerfStats,
                          std::shared_ptr<PdxTypeRegistry> m_pdxTypeRegistry,
                          const CacheImpl* cache, bool enableTimeStatistics);
 
diff --git a/cppcache/src/PdxType.cpp b/cppcache/src/PdxType.cpp
index fe56b90..9034942 100644
--- a/cppcache/src/PdxType.cpp
+++ b/cppcache/src/PdxType.cpp
@@ -42,10 +42,8 @@ PdxType::~PdxType() noexcept {
   _GEODE_SAFE_DELETE_ARRAY(m_localToRemoteFieldMap);
 }
 
-// PdxType::PdxType() : PdxType(nullptr, false) {}
-
 PdxType::PdxType(std::shared_ptr<PdxTypeRegistry> pdxTypeRegistryPtr,
-                 std::string pdxDomainClassName, bool isLocal)
+                 const std::string& pdxDomainClassName, bool isLocal)
     : Serializable(),
       m_pdxFieldTypes(new std::vector<std::shared_ptr<PdxFieldType>>()),
       m_className(pdxDomainClassName),
@@ -88,8 +86,8 @@ void PdxType::toData(DataOutput& output) const {
 }
 
 void PdxType::fromData(DataInput& input) {
-  input.read();  // ignore dsByte
-  input.read();  // ignore classByte
+  input.read();        // ignore dsByte
+  input.read();        // ignore classByte
   input.readString();  // ignore classtypeId
 
   m_className = input.readString();
@@ -405,77 +403,79 @@ std::shared_ptr<PdxType> PdxType::isContains(std::shared_ptr<PdxType> first,
   }
   return first;
 }
- std::shared_ptr<PdxType> PdxType::clone() {
-   auto clone =
-       std::make_shared<PdxType>(m_pdxTypeRegistryPtr, m_className, false);
-   clone->m_geodeTypeId = 0;
-   clone->m_numberOfVarLenFields = m_numberOfVarLenFields;
-
-   for (std::vector<std::shared_ptr<PdxFieldType>>::iterator it =
-            m_pdxFieldTypes->begin();
-        it != m_pdxFieldTypes->end(); ++it) {
-     auto pdxPtr = *it;
-     clone->m_pdxFieldTypes->push_back(pdxPtr);
-   }
-   return clone;
- }
- std::shared_ptr<PdxType> PdxType::isLocalTypeContains(
-     std::shared_ptr<PdxType> otherType) {
-   if (m_pdxFieldTypes->size() >= otherType->m_pdxFieldTypes->size()) {
-     return isContains(shared_from_this(), otherType);
-   }
-   return nullptr;
+std::shared_ptr<PdxType> PdxType::clone() {
+  auto clone =
+      std::make_shared<PdxType>(m_pdxTypeRegistryPtr, m_className, false);
+  clone->m_geodeTypeId = 0;
+  clone->m_numberOfVarLenFields = m_numberOfVarLenFields;
+
+  for (std::vector<std::shared_ptr<PdxFieldType>>::iterator it =
+           m_pdxFieldTypes->begin();
+       it != m_pdxFieldTypes->end(); ++it) {
+    auto pdxPtr = *it;
+    clone->m_pdxFieldTypes->push_back(pdxPtr);
+  }
+  return clone;
+}
+std::shared_ptr<PdxType> PdxType::isLocalTypeContains(
+    std::shared_ptr<PdxType> otherType) {
+  if (m_pdxFieldTypes->size() >= otherType->m_pdxFieldTypes->size()) {
+    return isContains(shared_from_this(), otherType);
+  }
+  return nullptr;
 }
- std::shared_ptr<PdxType> PdxType::isRemoteTypeContains(std::shared_ptr<PdxType> remoteType) {
+std::shared_ptr<PdxType> PdxType::isRemoteTypeContains(
+    std::shared_ptr<PdxType> remoteType) {
   if (m_pdxFieldTypes->size() <= remoteType->m_pdxFieldTypes->size()) {
     return isContains(remoteType, shared_from_this());
   }
   return nullptr;
 }
- std::shared_ptr<PdxType> PdxType::mergeVersion(std::shared_ptr<PdxType> otherVersion) {
+std::shared_ptr<PdxType> PdxType::mergeVersion(
+    std::shared_ptr<PdxType> otherVersion) {
   // int nTotalFields = otherVersion->m_pdxFieldTypes->size();
-std::shared_ptr<PdxType> contains = nullptr;
-
-if (isLocalTypeContains(otherVersion) != nullptr) return shared_from_this();
-
-if (isRemoteTypeContains(otherVersion) != nullptr) return otherVersion;
-
-// need to create new one, clone of local
-auto newone = clone();
-int varLenFields = newone->getNumberOfVarLenFields();
-
-for (std::vector<std::shared_ptr<PdxFieldType>>::iterator it =
-         otherVersion->m_pdxFieldTypes->begin();
-     it != otherVersion->m_pdxFieldTypes->end(); ++it) {
-  bool found = false;
-  // for each(PdxFieldType^ tmpNew in newone->m_pdxFieldTypes)
-  for (std::vector<std::shared_ptr<PdxFieldType>>::iterator it2 =
-           newone->m_pdxFieldTypes->begin();
-       it2 != newone->m_pdxFieldTypes->end(); ++it2) {
-    if ((*it2)->equals(*it)) {
-      found = true;
-      break;
+  std::shared_ptr<PdxType> contains = nullptr;
+
+  if (isLocalTypeContains(otherVersion) != nullptr) return shared_from_this();
+
+  if (isRemoteTypeContains(otherVersion) != nullptr) return otherVersion;
+
+  // need to create new one, clone of local
+  auto newone = clone();
+  int varLenFields = newone->getNumberOfVarLenFields();
+
+  for (std::vector<std::shared_ptr<PdxFieldType>>::iterator it =
+           otherVersion->m_pdxFieldTypes->begin();
+       it != otherVersion->m_pdxFieldTypes->end(); ++it) {
+    bool found = false;
+    // for each(PdxFieldType^ tmpNew in newone->m_pdxFieldTypes)
+    for (std::vector<std::shared_ptr<PdxFieldType>>::iterator it2 =
+             newone->m_pdxFieldTypes->begin();
+         it2 != newone->m_pdxFieldTypes->end(); ++it2) {
+      if ((*it2)->equals(*it)) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      auto newFt = std::make_shared<PdxFieldType>(
+          (*it)->getFieldName(), (*it)->getClassName(), (*it)->getTypeId(),
+          static_cast<int32_t>(newone->m_pdxFieldTypes->size()),  // sequence id
+          (*it)->IsVariableLengthType(), (*it)->getFixedSize(),
+          ((*it)->IsVariableLengthType()
+               ? varLenFields++ /*it increase after that*/
+               : 0));
+      newone->m_pdxFieldTypes->push_back(
+          newFt);  // fieldnameVsPFT will happen after that
     }
   }
-  if (!found) {
-    auto newFt = std::make_shared<PdxFieldType>(
-        (*it)->getFieldName(), (*it)->getClassName(), (*it)->getTypeId(),
-        static_cast<int32_t>(newone->m_pdxFieldTypes->size()),  // sequence id
-        (*it)->IsVariableLengthType(), (*it)->getFixedSize(),
-        ((*it)->IsVariableLengthType()
-             ? varLenFields++ /*it increase after that*/
-             : 0));
-    newone->m_pdxFieldTypes->push_back(
-        newFt);  // fieldnameVsPFT will happen after that
-  }
-}
 
-newone->setNumberOfVarLenFields(varLenFields);
-if (varLenFields > 0) newone->setVarLenFieldIdx(varLenFields);
+  newone->setNumberOfVarLenFields(varLenFields);
+  if (varLenFields > 0) newone->setVarLenFieldIdx(varLenFields);
 
-// need to keep all versions in local version
-// m_otherVersions->Add(newone);
-return newone;
+  // need to keep all versions in local version
+  // m_otherVersions->Add(newone);
+  return newone;
 }
 
 void PdxType::generatePositionMap() {
@@ -483,10 +483,10 @@ void PdxType::generatePositionMap() {
   int lastVarLenSeqId = 0;
   int prevFixedSizeOffsets = 0;
   // set offsets from back first
-std::shared_ptr<PdxFieldType> previousField = nullptr;
+  std::shared_ptr<PdxFieldType> previousField = nullptr;
 
   for (int i = static_cast<int>(m_pdxFieldTypes->size()) - 1; i >= 0; i--) {
-   auto tmpft = m_pdxFieldTypes->at(i);
+    auto tmpft = m_pdxFieldTypes->at(i);
     std::string temp = tmpft->getFieldName();
     std::pair<std::string, std::shared_ptr<PdxFieldType>> pc(temp, tmpft);
     m_fieldNameVsPdxType.insert(pc);
@@ -520,7 +520,7 @@ std::shared_ptr<PdxFieldType> previousField = nullptr;
   prevFixedSizeOffsets = 0;
   // now do optimization till you don't fine var len
   for (uint32_t i = 0; (i < m_pdxFieldTypes->size()) && !foundVarLen; i++) {
-   auto tmpft = m_pdxFieldTypes->at(i);
+    auto tmpft = m_pdxFieldTypes->at(i);
 
     if (tmpft->IsVariableLengthType()) {
       tmpft->setVarLenOffsetIndex(-1);  // first var len field
diff --git a/cppcache/src/PdxType.hpp b/cppcache/src/PdxType.hpp
index e04226d..adccd5f 100644
--- a/cppcache/src/PdxType.hpp
+++ b/cppcache/src/PdxType.hpp
@@ -105,7 +105,7 @@ class PdxType : public Serializable,
 
  public:
   PdxType(std::shared_ptr<PdxTypeRegistry> pdxTypeRegistryPtr,
-          std::string pdxDomainClassName, bool isLocal);
+          const std::string& pdxDomainClassName, bool isLocal);
 
   ~PdxType() noexcept override;
 
diff --git a/cppcache/src/PoolManagerImpl.cpp b/cppcache/src/PoolManagerImpl.cpp
index 9bdb42d..4f55824 100644
--- a/cppcache/src/PoolManagerImpl.cpp
+++ b/cppcache/src/PoolManagerImpl.cpp
@@ -17,6 +17,7 @@
 
 #include <geode/Pool.hpp>
 #include <geode/PoolFactory.hpp>
+#include <geode/Region.hpp>
 
 #include "PoolManagerImpl.hpp"
 #include "CacheImpl.hpp"
diff --git a/cppcache/src/RegionEntry.cpp b/cppcache/src/RegionEntry.cpp
index 3238c8e..939433a 100644
--- a/cppcache/src/RegionEntry.cpp
+++ b/cppcache/src/RegionEntry.cpp
@@ -17,6 +17,7 @@
 
 #include <geode/Cache.hpp>
 #include <geode/CacheableKey.hpp>
+#include <geode/RegionEntry.hpp>
 
 #include "CacheableToken.hpp"
 
diff --git a/cppcache/src/RegionFactory.cpp b/cppcache/src/RegionFactory.cpp
index c367d3f..fdd7acb 100644
--- a/cppcache/src/RegionFactory.cpp
+++ b/cppcache/src/RegionFactory.cpp
@@ -18,19 +18,20 @@
 #include <map>
 #include <string>
 
-#include <ace/Recursive_Thread_Mutex.h>
 #include <ace/Guard_T.h>
+#include <ace/Recursive_Thread_Mutex.h>
 
+#include <geode/Cache.hpp>
 #include <geode/CacheFactory.hpp>
+#include <geode/PoolManager.hpp>
 #include <geode/RegionFactory.hpp>
-#include <geode/Cache.hpp>
+#include <geode/RegionShortcut.hpp>
 #include <geode/SystemProperties.hpp>
-#include <geode/PoolManager.hpp>
 
-#include "CppCacheLibrary.hpp"
 #include "CacheImpl.hpp"
 #include "CacheConfig.hpp"
 #include "CacheRegionHelper.hpp"
+#include "CppCacheLibrary.hpp"
 
 namespace apache {
 namespace geode {
@@ -70,12 +71,14 @@ void RegionFactory::setRegionShortcut() {
     } break;
     case RegionShortcut::CACHING_PROXY_ENTRY_LRU: {
       m_regionAttributesFactory->setCachingEnabled(true);
-      m_regionAttributesFactory->setLruEntriesLimit(DEFAULT_LRU_MAXIMUM_ENTRIES);
+      m_regionAttributesFactory->setLruEntriesLimit(
+          DEFAULT_LRU_MAXIMUM_ENTRIES);
     } break;
     case RegionShortcut::LOCAL: {
     } break;
     case RegionShortcut::LOCAL_ENTRY_LRU: {
-      m_regionAttributesFactory->setLruEntriesLimit(DEFAULT_LRU_MAXIMUM_ENTRIES);
+      m_regionAttributesFactory->setLruEntriesLimit(
+          DEFAULT_LRU_MAXIMUM_ENTRIES);
     } break;
   }
 }
@@ -178,8 +181,7 @@ RegionFactory& RegionFactory::setLruEntriesLimit(const uint32_t entriesLimit) {
   return *this;
 }
 
-RegionFactory& RegionFactory::setDiskPolicy(
-    const DiskPolicyType diskPolicy) {
+RegionFactory& RegionFactory::setDiskPolicy(const DiskPolicyType diskPolicy) {
   m_regionAttributesFactory->setDiskPolicy(diskPolicy);
   return *this;
 }
diff --git a/cppcache/src/TcrEndpoint.cpp b/cppcache/src/TcrEndpoint.cpp
index e46fc07..d0cfcd0 100644
--- a/cppcache/src/TcrEndpoint.cpp
+++ b/cppcache/src/TcrEndpoint.cpp
@@ -638,8 +638,8 @@ int TcrEndpoint::receiveNotification(volatile bool& isRunning) {
         if (!msg->hasCqPart()) {
           if (msg->getMessageType() != TcrMessage::CLIENT_MARKER) {
             const std::string& regionFullPath1 = msg->getRegionName();
-            std::shared_ptr<Region> region1;
-            m_cacheImpl->getRegion(regionFullPath1.c_str(), region1);
+            auto region1 = m_cacheImpl->getRegion(regionFullPath1);
+
             if (region1 != nullptr &&
                 !static_cast<ThinClientRegion*>(region1.get())
                      ->getDistMgr()
@@ -672,8 +672,8 @@ int TcrEndpoint::receiveNotification(volatile bool& isRunning) {
           if (!msg->hasCqPart())  // || msg->isInterestListPassed())
           {
             const std::string& regionFullPath = msg->getRegionName();
-            std::shared_ptr<Region> region;
-            m_cacheImpl->getRegion(regionFullPath.c_str(), region);
+            auto region = m_cacheImpl->getRegion(regionFullPath);
+
             if (region != nullptr) {
               static_cast<ThinClientRegion*>(region.get())
                   ->receiveNotification(msg);
diff --git a/cppcache/src/ThinClientPoolDM.cpp b/cppcache/src/ThinClientPoolDM.cpp
index c397f58..61b1bbb 100644
--- a/cppcache/src/ThinClientPoolDM.cpp
+++ b/cppcache/src/ThinClientPoolDM.cpp
@@ -1173,8 +1173,7 @@ TcrEndpoint* ThinClientPoolDM::getSingleHopServer(
   auto region = nullptr == r ? nullptr : r->shared_from_this();
   TcrEndpoint* ep = nullptr;
   if (region == nullptr) {
-    m_connManager.getCacheImpl()->getRegion(request.getRegionName().c_str(),
-                                            region);
+    region = m_connManager.getCacheImpl()->getRegion(request.getRegionName());
   }
   if (region != nullptr) {
     m_clientMetadataService->getBucketServerLocation(
@@ -1270,9 +1269,8 @@ GfErrType ThinClientPoolDM::sendSyncRequest(TcrMessage& request,
        type == TcrMessage::GET_ALL_WITH_CALLBACK) &&
       m_clientMetadataService != nullptr) {
     GfErrType error = GF_NOERR;
-    std::shared_ptr<Region> region;
-    m_connManager.getCacheImpl()->getRegion(request.getRegionName().c_str(),
-                                            region);
+
+    auto region = m_connManager.getCacheImpl()->getRegion(request.getRegionName());
     auto locationMap = m_clientMetadataService->getServerToFilterMap(
         *(request.getKeys()), region, request.forPrimary());
 
@@ -1429,9 +1427,8 @@ GfErrType ThinClientPoolDM::sendSyncRequest(
       return GF_CLIENT_WAIT_TIMEOUT;
     } else if (queueErr == GF_CLIENT_WAIT_TIMEOUT_REFRESH_PRMETADATA) {
       // need to refresh meta data
-      std::shared_ptr<Region> region;
-      m_connManager.getCacheImpl()->getRegion(request.getRegionName().c_str(),
-                                              region);
+      auto region = m_connManager.getCacheImpl()->getRegion(request.getRegionName());
+
       if (region != nullptr) {
         LOGFINE(
             "Need to refresh pr-meta-data timeout in client only  with refresh "
@@ -1558,9 +1555,8 @@ GfErrType ThinClientPoolDM::sendSyncRequest(
             request.getKeyRef() != nullptr && reply.isFEAnotherHop()))) {
         // Need to get direct access to Region's name to avoid referencing
         // temp data and causing crashes
-        std::shared_ptr<Region> region;
-        m_connManager.getCacheImpl()->getRegion(request.getRegionName().c_str(),
-                                                region);
+        auto region = m_connManager.getCacheImpl()->getRegion(request.getRegionName());
+
         if (region != nullptr) {
           if (!connFound)  // max limit case then don't refresh otherwise always
                            // refresh
@@ -2449,9 +2445,8 @@ TcrConnection* ThinClientPoolDM::getConnectionFromQueueW(
         if (m_clientMetadataService == nullptr || request.getKey() == nullptr) {
           return nullptr;
         }
-        std::shared_ptr<Region> region;
-        m_connManager.getCacheImpl()->getRegion(request.getRegionName().c_str(),
-                                                region);
+
+        auto region = m_connManager.getCacheImpl()->getRegion(request.getRegionName());
         if (region != nullptr) {
           slTmp = nullptr;
           m_clientMetadataService
diff --git a/examples/cpp/customserializable/main.cpp b/examples/cpp/customserializable/main.cpp
index a7c9017..ec14839 100644
--- a/examples/cpp/customserializable/main.cpp
+++ b/examples/cpp/customserializable/main.cpp
@@ -19,8 +19,10 @@
 #include <sstream>
 
 #include <geode/CacheFactory.hpp>
-#include <geode/PdxWrapper.hpp>
 #include <geode/PoolManager.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
+#include <geode/TypeRegistry.hpp>
 
 #include "Order.hpp"
 
diff --git a/examples/cpp/customserializer/main.cpp b/examples/cpp/customserializer/main.cpp
index 8460e30..51cc9f6 100644
--- a/examples/cpp/customserializer/main.cpp
+++ b/examples/cpp/customserializer/main.cpp
@@ -21,6 +21,10 @@
 #include <geode/PoolManager.hpp>
 #include <geode/PdxSerializer.hpp>
 #include <geode/PdxWrapper.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
+#include <geode/TypeRegistry.hpp>
+
 #include "Order.hpp"
 #include "OrderSerializer.hpp"
 
diff --git a/examples/cpp/put-get-remove/main.cpp b/examples/cpp/put-get-remove/main.cpp
index 87bcdb6..8005682 100644
--- a/examples/cpp/put-get-remove/main.cpp
+++ b/examples/cpp/put-get-remove/main.cpp
@@ -19,11 +19,12 @@
 
 #include <geode/CacheFactory.hpp>
 #include <geode/PoolManager.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
 
 using namespace apache::geode::client;
 
 int main(int argc, char** argv) {
-
   auto cacheFactory = CacheFactory();
   cacheFactory.set("log-level", "none");
   auto cache = cacheFactory.create();
@@ -41,16 +42,19 @@ int main(int argc, char** argv) {
   std::cout << "Getting the user info from the region" << std::endl;
   auto user1 = region->get("rtimmons");
   auto user2 = region->get("scharles");
-  std::cout << "  rtimmons = " << std::dynamic_pointer_cast<CacheableString>(user1)->value() << std::endl;
-  std::cout << "  scharles = " << std::dynamic_pointer_cast<CacheableString>(user2)->value() << std::endl;
+  std::cout << "  rtimmons = "
+            << std::dynamic_pointer_cast<CacheableString>(user1)->value()
+            << std::endl;
+  std::cout << "  scharles = "
+            << std::dynamic_pointer_cast<CacheableString>(user2)->value()
+            << std::endl;
 
   std::cout << "Removing rtimmons info from the region" << std::endl;
   region->remove("rtimmons");
 
-  if(region->existsValue("rtimmons")) {
+  if (region->existsValue("rtimmons")) {
     std::cout << "rtimmons's info not deleted" << std::endl;
-  }
-  else {
+  } else {
     std::cout << "rtimmons's info successfully deleted" << std::endl;
   }
 
diff --git a/tests/cpp/fwklib/RegionHelper.hpp b/tests/cpp/fwklib/RegionHelper.hpp
index 5a4f8b1..b45f8c7 100644
--- a/tests/cpp/fwklib/RegionHelper.hpp
+++ b/tests/cpp/fwklib/RegionHelper.hpp
@@ -25,6 +25,8 @@
 #include <map>
 
 #include <geode/internal/chrono/duration.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
 
 #include "fwklib/FrameworkTest.hpp"
 #include "fwklib/FwkObjects.hpp"

-- 
To stop receiving notification emails like this one, please contact
jbarrett@apache.org.

Mime
View raw message