[
https://issues.apache.org/jira/browse/GEODE-4188?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16318812#comment-16318812
]
ASF GitHub Bot commented on GEODE-4188:
---------------------------------------
pivotal-jbarrett closed pull request #182: GEODE-4188: Moves headers and
templates internal.
URL: https://github.com/apache/geode-native/pull/182
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/cppcache/include/geode/AttributesFactory.hpp
b/cppcache/include/geode/AttributesFactory.hpp
index 4d1f550a6..c8142e755 100644
--- a/cppcache/include/geode/AttributesFactory.hpp
+++ b/cppcache/include/geode/AttributesFactory.hpp
@@ -33,7 +33,7 @@
#include "RegionAttributes.hpp"
#include "DiskPolicyType.hpp"
#include "Pool.hpp"
-#include "util/chrono/duration.hpp"
+#include "internal/chrono/duration.hpp"
/**
* @file
diff --git a/cppcache/include/geode/Cacheable.hpp
b/cppcache/include/geode/Cacheable.hpp
index 450bfb818..aa4554c5a 100644
--- a/cppcache/include/geode/Cacheable.hpp
+++ b/cppcache/include/geode/Cacheable.hpp
@@ -26,7 +26,7 @@
#include "geode_globals.hpp"
#include "Serializable.hpp"
-#include "util/functional.hpp"
+#include "internal/functional.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/include/geode/CacheableKey.hpp
b/cppcache/include/geode/CacheableKey.hpp
index dd6d535d8..bcbeea998 100644
--- a/cppcache/include/geode/CacheableKey.hpp
+++ b/cppcache/include/geode/CacheableKey.hpp
@@ -26,7 +26,7 @@
#include "geode_globals.hpp"
#include "Cacheable.hpp"
-#include "util/functional.hpp"
+#include "internal/functional.hpp"
/**
* @file
@@ -103,6 +103,8 @@ class CPPCACHE_EXPORT CacheableKey : public Cacheable {
void operator=(const CacheableKey& other);
};
+using namespace apache::geode::client::internal;
+
typedef std::unordered_map<std::shared_ptr<CacheableKey>,
std::shared_ptr<Cacheable>,
dereference_hash<std::shared_ptr<CacheableKey>>,
@@ -114,6 +116,7 @@ typedef std::unordered_set<std::shared_ptr<CacheableKey>,
dereference_equal_to<std::shared_ptr<CacheableKey>>>
HashSetOfCacheableKey;
+
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/include/geode/Exception.hpp
b/cppcache/include/geode/Exception.hpp
index 7891f0732..2804f8c56 100644
--- a/cppcache/include/geode/Exception.hpp
+++ b/cppcache/include/geode/Exception.hpp
@@ -25,7 +25,7 @@
#include <unordered_map>
#include "geode_globals.hpp"
-#include "util/functional.hpp"
+#include "internal/functional.hpp"
/**
* @file
@@ -84,13 +84,6 @@ class CPPCACHE_EXPORT Exception : public std::exception {
#pragma warning(pop)
-class CacheableKey;
-typedef std::unordered_map<std::shared_ptr<CacheableKey>,
- std::shared_ptr<Exception>,
- dereference_hash<std::shared_ptr<CacheableKey>>,
- dereference_equal_to<std::shared_ptr<CacheableKey>>>
- HashMapOfException;
-
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/include/geode/Pool.hpp b/cppcache/include/geode/Pool.hpp
index 5f7c1d055..cae595613 100644
--- a/cppcache/include/geode/Pool.hpp
+++ b/cppcache/include/geode/Pool.hpp
@@ -29,7 +29,7 @@
#include "CacheableBuiltins.hpp"
#include "geode_base.hpp"
#include "geode_globals.hpp"
-#include "util/chrono/duration.hpp"
+#include "internal/chrono/duration.hpp"
/**
* @file
diff --git a/cppcache/include/geode/PoolFactory.hpp
b/cppcache/include/geode/PoolFactory.hpp
index 4daa109e3..03cb4c1a3 100644
--- a/cppcache/include/geode/PoolFactory.hpp
+++ b/cppcache/include/geode/PoolFactory.hpp
@@ -23,7 +23,7 @@
#include <chrono>
#include "geode_globals.hpp"
-#include "util/chrono/duration.hpp"
+#include "internal/chrono/duration.hpp"
#include "Pool.hpp"
/**
diff --git a/cppcache/include/geode/Properties.hpp
b/cppcache/include/geode/Properties.hpp
index 144569060..54f87658a 100644
--- a/cppcache/include/geode/Properties.hpp
+++ b/cppcache/include/geode/Properties.hpp
@@ -30,12 +30,14 @@
#include "geode_globals.hpp"
#include "Serializable.hpp"
#include "Cacheable.hpp"
-#include "util/chrono/duration.hpp"
+#include "internal/chrono/duration.hpp"
namespace apache {
namespace geode {
namespace client {
+using namespace apache::geode::internal::chrono::duration;
+
class DataInput;
class DataOutput;
class CacheableKey;
@@ -47,7 +49,6 @@ class CacheableString;
* the property; value, the value of the property.
*
*/
-
class CPPCACHE_EXPORT Properties : public Serializable {
public:
class Visitor {
@@ -97,7 +98,7 @@ class CPPCACHE_EXPORT Properties : public Serializable {
template <class _Rep, class _Period>
void insert(std::string key,
const std::chrono::duration<_Rep, _Period>& value) {
- insert(key, util::chrono::duration::to_string(value));
+ insert(key, to_string(value));
}
/**
diff --git a/cppcache/include/geode/RegionAttributes.hpp
b/cppcache/include/geode/RegionAttributes.hpp
index 53fbf8bc7..38fa23ad6 100644
--- a/cppcache/include/geode/RegionAttributes.hpp
+++ b/cppcache/include/geode/RegionAttributes.hpp
@@ -36,7 +36,7 @@
#include "Serializable.hpp"
#include "DiskPolicyType.hpp"
#include "PersistenceManager.hpp"
-#include "util/chrono/duration.hpp"
+#include "internal/chrono/duration.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/include/geode/RegionFactory.hpp
b/cppcache/include/geode/RegionFactory.hpp
index 74d4da9d8..e5e462875 100644
--- a/cppcache/include/geode/RegionFactory.hpp
+++ b/cppcache/include/geode/RegionFactory.hpp
@@ -24,7 +24,7 @@
#include "geode_globals.hpp"
#include "AttributesFactory.hpp"
-#include "util/chrono/duration.hpp"
+#include "internal/chrono/duration.hpp"
/**
* @file
diff --git a/cppcache/include/geode/util/chrono/duration.hpp
b/cppcache/include/geode/internal/chrono/duration.hpp
similarity index 96%
rename from cppcache/include/geode/util/chrono/duration.hpp
rename to cppcache/include/geode/internal/chrono/duration.hpp
index a97d029a8..519d48bc7 100644
--- a/cppcache/include/geode/util/chrono/duration.hpp
+++ b/cppcache/include/geode/internal/chrono/duration.hpp
@@ -17,8 +17,8 @@
#pragma once
-#ifndef GEODE_UTIL_CHRONO_DURATION_H_
-#define GEODE_UTIL_CHRONO_DURATION_H_
+#ifndef GEODE_INTERNAL_CHRONO_DURATION_H_
+#define GEODE_INTERNAL_CHRONO_DURATION_H_
#include <chrono>
#include <iosfwd>
@@ -29,7 +29,7 @@
namespace apache {
namespace geode {
-namespace util {
+namespace internal {
namespace chrono {
namespace duration {
@@ -158,8 +158,8 @@ inline std::string to_string(
} // namespace duration
} // namespace chrono
-} // namespace util
+} // namespace internal
} // namespace geode
} // namespace apache
-#endif /* GEODE_UTIL_CHRONO_DURATION_H_ */
+#endif /* GEODE_INTERNAL_CHRONO_DURATION_H_ */
diff --git a/cppcache/include/geode/util/functional.hpp
b/cppcache/include/geode/internal/functional.hpp
similarity index 98%
rename from cppcache/include/geode/util/functional.hpp
rename to cppcache/include/geode/internal/functional.hpp
index f5a34362d..0c4a7abdd 100644
--- a/cppcache/include/geode/util/functional.hpp
+++ b/cppcache/include/geode/internal/functional.hpp
@@ -27,11 +27,10 @@
#include <codecvt>
#include <locale>
-//#include "string.hpp"
-
namespace apache {
namespace geode {
namespace client {
+namespace internal {
template <class _T>
struct dereference_hash;
@@ -108,6 +107,7 @@ struct geode_hash<std::string> {
int32_t operator()(const std::string& val);
};
+} // namespace internal
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/integration-test/CacheHelper.cpp
b/cppcache/integration-test/CacheHelper.cpp
index 1fb9bf942..6072b9bf7 100644
--- a/cppcache/integration-test/CacheHelper.cpp
+++ b/cppcache/integration-test/CacheHelper.cpp
@@ -26,7 +26,7 @@
#include <geode/SystemProperties.hpp>
#include <geode/PoolManager.hpp>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "CacheRegionHelper.hpp"
#include "DistributedSystemImpl.hpp"
@@ -62,7 +62,7 @@
#endif
using namespace apache::geode::client;
-using namespace apache::geode::util::chrono::duration;
+using namespace apache::geode::internal::chrono::duration;
extern ClientCleanup gClientCleanup;
@@ -501,7 +501,7 @@ std::shared_ptr<Pool> CacheHelper::createPool2(
}
void CacheHelper::logPoolAttributes(std::shared_ptr<Pool>& pool) {
- using namespace apache::geode::util::chrono::duration;
+ using namespace apache::geode::internal::chrono::duration;
LOG("logPoolAttributes() entered");
LOGINFO("CPPTEST: Pool attributes for pool %s are as follows" +
pool->getName());
diff --git a/cppcache/integration-test/testThinClientLRUExpiration.cpp
b/cppcache/integration-test/testThinClientLRUExpiration.cpp
index 969a7a54f..6ec8299bc 100644
--- a/cppcache/integration-test/testThinClientLRUExpiration.cpp
+++ b/cppcache/integration-test/testThinClientLRUExpiration.cpp
@@ -22,7 +22,7 @@
#include <ace/OS.h>
#include <ace/High_Res_Timer.h>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#define ROOT_NAME "testThinClientLRUExpiration"
#define ROOT_SCOPE DISTRIBUTED_ACK
@@ -33,7 +33,7 @@
using namespace apache::geode::client;
using namespace test;
-using namespace apache::geode::util::chrono::duration;
+using namespace apache::geode::internal::chrono::duration;
#define CLIENT1 s1p1
#define CLIENT2 s1p2
diff --git a/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
b/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
index c494e35f0..967a29cb1 100644
--- a/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
+++ b/cppcache/integration-test/testXmlCacheCreationWithPools.cpp
@@ -21,7 +21,7 @@
#include "fw_dunit.hpp"
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#define CLIENT1 s1p1
#define CLIENT2 s1p2
@@ -84,7 +84,7 @@ bool checkPoolAttribs(std::shared_ptr<Pool> pool, SLIST&
locators,
int subscriptionAckInterval, int subscriptionRedundancy,
int statisticInterval, int threadLocalConnections,
bool prSingleHopEnabled, int updateLocatorListInterval) {
- using namespace apache::geode::util::chrono::duration;
+ using namespace apache::geode::internal::chrono::duration;
char logmsg[500] = {0};
diff --git a/cppcache/src/CacheXmlParser.cpp b/cppcache/src/CacheXmlParser.cpp
index 859ab60e8..ce1788215 100644
--- a/cppcache/src/CacheXmlParser.cpp
+++ b/cppcache/src/CacheXmlParser.cpp
@@ -17,7 +17,7 @@
#include <chrono>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include <geode/PoolManager.hpp>
#include <geode/PoolFactory.hpp>
@@ -40,7 +40,6 @@ namespace impl {
void* getFactoryFunc(const std::string& lib, const std::string& funcName);
} // namespace impl
-
namespace {
using namespace apache::geode::client::impl;
@@ -636,10 +635,11 @@ void CacheXmlParser::endPool() {
void CacheXmlParser::setPoolInfo(PoolFactory* factory, const char* name,
const char* value) {
+ using namespace apache::geode::internal::chrono::duration;
+
if (strcmp(name, FREE_CONNECTION_TIMEOUT) == 0) {
factory->setFreeConnectionTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, MULTIUSER_SECURE_MODE) == 0) {
if (ACE_OS::strcasecmp(value, "true") == 0) {
factory->setMultiuserAuthentication(true);
@@ -648,28 +648,23 @@ void CacheXmlParser::setPoolInfo(PoolFactory* factory,
const char* name,
}
} else if (strcmp(name, IDLE_TIMEOUT) == 0) {
factory->setIdleTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, LOAD_CONDITIONING_INTERVAL) == 0) {
factory->setLoadConditioningInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, MAX_CONNECTIONS) == 0) {
factory->setMaxConnections(atoi(value));
} else if (strcmp(name, MIN_CONNECTIONS) == 0) {
factory->setMinConnections(atoi(value));
} else if (strcmp(name, PING_INTERVAL) == 0) {
factory->setPingInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, UPDATE_LOCATOR_LIST_INTERVAL) == 0) {
factory->setUpdateLocatorListInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, READ_TIMEOUT) == 0) {
factory->setReadTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, RETRY_ATTEMPTS) == 0) {
factory->setRetryAttempts(atoi(value));
} else if (strcmp(name, SERVER_GROUP) == 0) {
@@ -678,12 +673,10 @@ void CacheXmlParser::setPoolInfo(PoolFactory* factory,
const char* name,
factory->setSocketBufferSize(atoi(value));
} else if (strcmp(name, STATISTIC_INTERVAL) == 0) {
factory->setStatisticInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, SUBSCRIPTION_ACK_INTERVAL) == 0) {
factory->setSubscriptionAckInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, SUBSCRIPTION_ENABLED) == 0) {
if (ACE_OS::strcasecmp(value, "true") == 0) {
factory->setSubscriptionEnabled(true);
@@ -692,8 +685,7 @@ void CacheXmlParser::setPoolInfo(PoolFactory* factory,
const char* name,
}
} else if (strcmp(name, SUBSCRIPTION_MTT) == 0) {
factory->setSubscriptionMessageTrackingTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(
- std::string(value)));
+ from_string<std::chrono::milliseconds>(std::string(value)));
} else if (strcmp(name, SUBSCRIPTION_REDUNDANCY) == 0) {
factory->setSubscriptionRedundancy(atoi(value));
} else if (strcmp(name, THREAD_LOCAL_CONNECTIONS) == 0) {
@@ -1078,8 +1070,7 @@ void CacheXmlParser::startExpirationAttributes(const
xmlChar** atts) {
"XML:Value for attribute <timeout> needs to be specified";
throw CacheXmlException(s.c_str());
}
- timeOutSeconds =
- util::chrono::duration::from_string<std::chrono::seconds>(timeOut);
+ timeOutSeconds = from_string<std::chrono::seconds>(timeOut);
} else if (strcmp(ACTION, (char*)atts[i]) == 0) {
i++;
char* action = (char*)atts[i];
diff --git a/cppcache/src/CacheableEnum.cpp b/cppcache/src/CacheableEnum.cpp
index 79785fae3..c72a22bef 100644
--- a/cppcache/src/CacheableEnum.cpp
+++ b/cppcache/src/CacheableEnum.cpp
@@ -16,13 +16,13 @@
*/
#include <geode/CacheableEnum.hpp>
+#include <geode/internal/functional.hpp>
#include "Utils.hpp"
#include "PdxHelper.hpp"
#include "GeodeTypeIdsImpl.hpp"
#include "EnumInfo.hpp"
#include "CacheRegionHelper.hpp"
-#include "util/functional.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/CacheableObjectPartList.hpp
b/cppcache/src/CacheableObjectPartList.hpp
index bd57052bb..a79b91b1b 100644
--- a/cppcache/src/CacheableObjectPartList.hpp
+++ b/cppcache/src/CacheableObjectPartList.hpp
@@ -20,13 +20,15 @@
#ifndef GEODE_CACHEABLEOBJECTPARTLIST_H_
#define GEODE_CACHEABLEOBJECTPARTLIST_H_
+#include <vector>
+
#include <geode/geode_globals.hpp>
#include <geode/DataOutput.hpp>
#include <geode/DataInput.hpp>
#include <geode/Cacheable.hpp>
-#include "MapWithLock.hpp"
-#include <vector>
+#include "MapWithLock.hpp"
+#include "HashMapOfException.hpp"
/** @file
*/
diff --git a/cppcache/src/ClientMetadataService.hpp
b/cppcache/src/ClientMetadataService.hpp
index e714863cf..fd4d45f4e 100644
--- a/cppcache/src/ClientMetadataService.hpp
+++ b/cppcache/src/ClientMetadataService.hpp
@@ -26,10 +26,10 @@
#include <ace/Task.h>
-#include <memory>
#include <geode/CacheableKey.hpp>
#include <geode/Cacheable.hpp>
#include <geode/Region.hpp>
+#include <geode/internal/functional.hpp>
#include "ClientMetadata.hpp"
#include "ServerLocation.hpp"
@@ -37,7 +37,6 @@
#include "Queue.hpp"
#include "DistributedSystemImpl.hpp"
#include "NonCopyable.hpp"
-#include "util/functional.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/ClientProxyMembershipID.hpp
b/cppcache/src/ClientProxyMembershipID.hpp
index 99346f4ef..a15d974de 100644
--- a/cppcache/src/ClientProxyMembershipID.hpp
+++ b/cppcache/src/ClientProxyMembershipID.hpp
@@ -26,7 +26,7 @@
#include <geode/geode_globals.hpp>
#include <geode/DataOutput.hpp>
-#include <geode/util/functional.hpp>
+#include <geode/internal/functional.hpp>
#include "GeodeTypeIdsImpl.hpp"
#include "DSMemberForVersionStamp.hpp"
diff --git a/cppcache/src/EventIdMap.hpp b/cppcache/src/EventIdMap.hpp
index bd26ff3a7..6a1525a3b 100644
--- a/cppcache/src/EventIdMap.hpp
+++ b/cppcache/src/EventIdMap.hpp
@@ -31,9 +31,10 @@
#include <ace/Recursive_Thread_Mutex.h>
#include <ace/Guard_T.h>
+#include <geode/internal/functional.hpp>
+
#include "EventId.hpp"
#include "EventSource.hpp"
-#include "util/functional.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/ExpiryTaskManager.hpp
b/cppcache/src/ExpiryTaskManager.hpp
index 6c16aee1e..84cf4f55e 100644
--- a/cppcache/src/ExpiryTaskManager.hpp
+++ b/cppcache/src/ExpiryTaskManager.hpp
@@ -27,7 +27,7 @@
#include <ace/Timer_Heap.h>
#include <geode/geode_globals.hpp>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "ReadWriteLock.hpp"
#include "util/Log.hpp"
@@ -39,6 +39,9 @@
namespace apache {
namespace geode {
namespace client {
+
+using namespace apache::geode::internal::chrono::duration;
+
/**
* @class ExpiryTaskManager ExpiryTaskManager.hpp
*
@@ -246,8 +249,8 @@ class CPPCACHE_EXPORT ExpiryTaskManager : public
ACE_Task_Base {
bool cancelExistingTask = false) {
LOGFINER(
"ExpiryTaskManager: expTime %s, interval %s, cancelExistingTask %d",
- util::chrono::duration::to_string(expTime).c_str(),
- util::chrono::duration::to_string(interval).c_str(),
+ to_string(expTime).c_str(),
+ to_string(interval).c_str(),
cancelExistingTask);
if (cancelExistingTask) {
m_reactor->cancel_timer(handler, 1);
diff --git a/cppcache/src/HashMapOfException.hpp
b/cppcache/src/HashMapOfException.hpp
new file mode 100644
index 000000000..ed1aa444b
--- /dev/null
+++ b/cppcache/src/HashMapOfException.hpp
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifndef GEODE_HASHMAPOFEXCEPTION_H_
+#define GEODE_HASHMAPOFEXCEPTION_H_
+
+#include <unordered_map>
+#include <memory>
+
+#include <geode/internal/functional.hpp>
+
+namespace apache {
+namespace geode {
+namespace client {
+
+class CacheableKey;
+class Exception;
+
+using namespace apache::geode::client::internal;
+typedef std::unordered_map<std::shared_ptr<CacheableKey>,
+ std::shared_ptr<Exception>,
+ dereference_hash<std::shared_ptr<CacheableKey>>,
+ dereference_equal_to<std::shared_ptr<CacheableKey>>>
+ HashMapOfException;
+
+} // namespace client
+} // namespace geode
+} // namespace apache
+
+#endif // GEODE_HASHMAPOFEXCEPTION_H_
diff --git a/cppcache/src/PdxTypeRegistry.hpp b/cppcache/src/PdxTypeRegistry.hpp
index 7548debdf..30957e54a 100644
--- a/cppcache/src/PdxTypeRegistry.hpp
+++ b/cppcache/src/PdxTypeRegistry.hpp
@@ -28,6 +28,7 @@
#include <geode/PdxSerializable.hpp>
#include <geode/Cache.hpp>
+#include <geode/internal/functional.hpp>
#include "PdxRemotePreservedData.hpp"
#include "ReadWriteLock.hpp"
@@ -35,7 +36,6 @@
#include "EnumInfo.hpp"
#include "PreservedDataExpiryHandler.hpp"
#include "ExpiryTaskManager.hpp"
-#include "util/functional.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/RegionInternal.hpp b/cppcache/src/RegionInternal.hpp
index 29014cb8c..efd499385 100644
--- a/cppcache/src/RegionInternal.hpp
+++ b/cppcache/src/RegionInternal.hpp
@@ -28,6 +28,7 @@
#include "RegionStats.hpp"
#include "EventId.hpp"
+#include "HashMapOfException.hpp"
namespace apache {
namespace geode {
diff --git a/cppcache/src/SystemProperties.cpp
b/cppcache/src/SystemProperties.cpp
index 31ad64050..96c9662ea 100644
--- a/cppcache/src/SystemProperties.cpp
+++ b/cppcache/src/SystemProperties.cpp
@@ -23,7 +23,7 @@
#include <ace/DLL.h>
#include <geode/geode_globals.hpp>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include <geode/SystemProperties.hpp>
#include <geode/ExceptionTypes.hpp>
#include <geode/CacheableKey.hpp>
@@ -270,9 +270,9 @@ template <class _Rep, class _Period>
void SystemProperties::parseDurationProperty(
const std::string& property, const std::string& value,
std::chrono::duration<_Rep, _Period>& duration) {
+ using namespace apache::geode::internal::chrono::duration;
try {
- duration = util::chrono::duration::from_string<
- std::chrono::duration<_Rep, _Period>>(value);
+ duration = from_string<std::chrono::duration<_Rep, _Period>>(value);
} catch (std::invalid_argument&) {
throwError(("SystemProperties: non-duration " + property + "=" + value));
}
@@ -383,6 +383,8 @@ void SystemProperties::processProperty(const std::string&
property,
}
void SystemProperties::logSettings() {
+ using namespace apache::geode::internal::chrono::duration;
+
// *** PLEASE ADD IN ALPHABETICAL ORDER - USER VISIBLE ***
std::string settings = "Geode Native Client System Properties:";
@@ -397,7 +399,7 @@ void SystemProperties::logSettings() {
settings += autoReadyForEvents() ? "true" : "false";
settings += "\n bucket-wait-timeout = ";
- settings += util::chrono::duration::to_string(bucketWaitTimeout());
+ settings += to_string(bucketWaitTimeout());
settings += "\n cache-xml-file = ";
settings += cacheXMLFile();
@@ -406,13 +408,13 @@ void SystemProperties::logSettings() {
settings += conflateEvents();
settings += "\n connect-timeout = ";
- settings += util::chrono::duration::to_string(connectTimeout());
+ settings += to_string(connectTimeout());
settings += "\n connection-pool-size = ";
settings += std::to_string(javaConnectionPoolSize());
settings += "\n connect-wait-timeout = ";
- settings += util::chrono::duration::to_string(connectWaitTimeout());
+ settings += to_string(connectWaitTimeout());
settings += "\n disable-chunk-handler-thread = ";
settings += disableChunkHandlerThread() ? "true" : "false";
@@ -424,7 +426,7 @@ void SystemProperties::logSettings() {
settings += durableClientId();
settings += "\n durable-timeout = ";
- settings += util::chrono::duration::to_string(durableTimeout());
+ settings += to_string(durableTimeout());
// *** PLEASE ADD IN ALPHABETICAL ORDER - USER VISIBLE ***
@@ -459,10 +461,10 @@ void SystemProperties::logSettings() {
settings += std::to_string(maxSocketBufferSize());
settings += "\n notify-ack-interval = ";
- settings += util::chrono::duration::to_string(notifyAckInterval());
+ settings += to_string(notifyAckInterval());
settings += "\n notify-dupcheck-life = ";
- settings += util::chrono::duration::to_string(notifyDupCheckLife());
+ settings += to_string(notifyDupCheckLife());
settings += "\n on-client-disconnect-clear-pdxType-Ids = ";
settings += onClientDisconnectClearPdxTypeIds() ? "true" : "false";
@@ -470,10 +472,10 @@ void SystemProperties::logSettings() {
// *** PLEASE ADD IN ALPHABETICAL ORDER - USER VISIBLE ***
settings += "\n ping-interval = ";
- settings += util::chrono::duration::to_string(pingInterval());
+ settings += to_string(pingInterval());
settings += "\n redundancy-monitor-interval = ";
- settings += util::chrono::duration::to_string(redundancyMonitorInterval());
+ settings += to_string(redundancyMonitorInterval());
settings += "\n security-client-dhalgo = ";
settings += securityClientDhAlgo();
@@ -497,13 +499,13 @@ void SystemProperties::logSettings() {
settings += statisticsEnabled() ? "true" : "false";
settings += "\n statistic-sample-rate = ";
- settings += util::chrono::duration::to_string(statisticsSampleInterval());
+ settings += to_string(statisticsSampleInterval());
settings += "\n suspended-tx-timeout = ";
- settings += util::chrono::duration::to_string(suspendedTxTimeout());
+ settings += to_string(suspendedTxTimeout());
settings += "\n tombstone-timeout = ";
- settings += util::chrono::duration::to_string(tombstoneTimeout());
+ settings += to_string(tombstoneTimeout());
// *** PLEASE ADD IN ALPHABETICAL ORDER - USER VISIBLE ***
diff --git a/cppcache/src/TcpConn.cpp b/cppcache/src/TcpConn.cpp
index 7e683c383..d694c20b6 100644
--- a/cppcache/src/TcpConn.cpp
+++ b/cppcache/src/TcpConn.cpp
@@ -25,7 +25,7 @@
#include <geode/DistributedSystem.hpp>
#include <geode/SystemProperties.hpp>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "TcpConn.hpp"
#include "CacheImpl.hpp"
@@ -162,6 +162,8 @@ void TcpConn::listen(const char *ipaddr,
void TcpConn::listen(ACE_INET_Addr addr,
std::chrono::microseconds waitSeconds) {
+ using namespace apache::geode::internal::chrono::duration;
+
GF_DEV_ASSERT(m_io != nullptr);
ACE_SOCK_Acceptor listener(addr, 1);
@@ -178,7 +180,7 @@ void TcpConn::listen(ACE_INET_Addr addr,
if (lastError == ETIME || lastError == ETIMEDOUT) {
throw TimeoutException(
"TcpConn::listen Attempt to listen timed out after " +
- util::chrono::duration::to_string(waitSeconds) + ".");
+ to_string(waitSeconds) + ".");
}
ACE_OS::snprintf(msg, 256, "TcpConn::listen failed with errno: %d: %s",
lastError, ACE_OS::strerror(lastError));
@@ -203,6 +205,8 @@ void TcpConn::connect(const char *ipaddr,
}
void TcpConn::connect() {
+ using namespace apache::geode::internal::chrono::duration;
+
GF_DEV_ASSERT(m_io != nullptr);
ACE_INET_Addr ipaddr = m_addr;
@@ -230,7 +234,7 @@ void TcpConn::connect() {
GF_SAFE_DELETE(m_io);
throw TimeoutException(
"TcpConn::connect Attempt to connect timed out after" +
- util::chrono::duration::to_string(waitMicroSeconds) + ".");
+ to_string(waitMicroSeconds) + ".");
}
ACE_OS::snprintf(msg, 256, "TcpConn::connect failed with errno: %d: %s",
lastError, ACE_OS::strerror(lastError));
diff --git a/cppcache/src/TcpSslConn.cpp b/cppcache/src/TcpSslConn.cpp
index e8dc56c3c..5d214b11e 100644
--- a/cppcache/src/TcpSslConn.cpp
+++ b/cppcache/src/TcpSslConn.cpp
@@ -55,6 +55,8 @@ void TcpSslConn::createSocket(ACE_SOCKET sock) {
void TcpSslConn::listen(ACE_INET_Addr addr,
std::chrono::microseconds waitSeconds) {
+ using namespace apache::geode::internal::chrono::duration;
+
GF_DEV_ASSERT(m_ssl != nullptr);
int32_t retVal = m_ssl->listen(addr, waitSeconds);
@@ -65,7 +67,7 @@ void TcpSslConn::listen(ACE_INET_Addr addr,
if (lastError == ETIME || lastError == ETIMEDOUT) {
throw TimeoutException(
"TcpSslConn::listen Attempt to listen timed out after" +
- util::chrono::duration::to_string(waitSeconds) + ".");
+ to_string(waitSeconds) + ".");
}
// sprintf( msg, "TcpSslConn::listen failed with errno: %d: %s", lastError,
// ACE_OS::strerror(lastError) );
@@ -76,6 +78,8 @@ void TcpSslConn::listen(ACE_INET_Addr addr,
}
void TcpSslConn::connect() {
+ using namespace apache::geode::internal::chrono::duration;
+
GF_DEV_ASSERT(m_ssl != nullptr);
ACE_OS::signal(SIGPIPE, SIG_IGN); // Ignore broken pipe
@@ -97,7 +101,7 @@ void TcpSslConn::connect() {
GF_SAFE_DELETE(m_ssl);
throw TimeoutException(
"TcpSslConn::connect Attempt to connect timed out after " +
- util::chrono::duration::to_string(waitMicroSeconds) + ".");
+ to_string(waitMicroSeconds) + ".");
}
ACE_OS::snprintf(msg, 256, "TcpSslConn::connect failed with errno: %d: %s",
lastError, ACE_OS::strerror(lastError));
diff --git a/cppcache/src/ThinClientRegion.hpp
b/cppcache/src/ThinClientRegion.hpp
index cdea10ca7..d454e1823 100644
--- a/cppcache/src/ThinClientRegion.hpp
+++ b/cppcache/src/ThinClientRegion.hpp
@@ -34,7 +34,7 @@
#include "TcrChunkedContext.hpp"
#include "CacheableObjectPartList.hpp"
#include "ClientMetadataService.hpp"
-#include "util/functional.hpp"
+#include <geode/internal/functional.hpp>
/**
* @file
*/
diff --git a/cppcache/src/TombstoneList.hpp b/cppcache/src/TombstoneList.hpp
index 774e6d505..79bbe64e9 100644
--- a/cppcache/src/TombstoneList.hpp
+++ b/cppcache/src/TombstoneList.hpp
@@ -30,7 +30,7 @@
#include <geode/CacheableBuiltins.hpp>
#include "MapEntry.hpp"
-#include "util/functional.hpp"
+#include <geode/internal/functional.hpp>
namespace apache {
namespace geode {
diff --git a/cppcache/src/util/chrono/duration.cpp
b/cppcache/src/internal/duration.cpp
similarity index 93%
rename from cppcache/src/util/chrono/duration.cpp
rename to cppcache/src/internal/duration.cpp
index c2424a75c..ef001bff8 100644
--- a/cppcache/src/util/chrono/duration.cpp
+++ b/cppcache/src/internal/duration.cpp
@@ -15,11 +15,11 @@
* limitations under the License.
*/
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
namespace apache {
namespace geode {
-namespace util {
+namespace internal {
namespace chrono {
namespace duration {
@@ -32,6 +32,6 @@ constexpr char const* _suffix<std::nano>::value;
} // namespace duration
} // namespace chrono
-} // namespace util
+} // namespace internal
} // namespace geode
} // namespace apache
diff --git a/cppcache/src/util/chrono/duration_bounds.hpp
b/cppcache/src/util/chrono/duration_bounds.hpp
index 38f273062..17d87a23d 100644
--- a/cppcache/src/util/chrono/duration_bounds.hpp
+++ b/cppcache/src/util/chrono/duration_bounds.hpp
@@ -32,6 +32,7 @@ namespace chrono {
namespace duration {
using namespace apache::geode::client;
+using namespace apache::geode::internal::chrono::duration;
template <class LimitRep, class LimitPeriod,
LimitRep lower = std::numeric_limits<LimitRep>::lowest(),
diff --git a/cppcache/src/util/functional.cpp b/cppcache/src/util/functional.cpp
index 15dbad2d6..76aca54c0 100644
--- a/cppcache/src/util/functional.cpp
+++ b/cppcache/src/util/functional.cpp
@@ -19,19 +19,21 @@
#include <codecvt>
#include <locale>
-#include <geode/util/functional.hpp>
+#include <geode/internal/functional.hpp>
#include "string.hpp"
namespace apache {
namespace geode {
namespace client {
+namespace internal {
int32_t geode_hash<std::string>::operator()(const std::string& val) {
// TODO string optimize without conversion to UTF-16
return geode_hash<std::u16string>{}(to_utf16(val));
}
+} // namespace internal
} // namespace client
} // namespace geode
} // namespace apache
diff --git a/cppcache/src/util/functional.hpp b/cppcache/src/util/functional.hpp
deleted file mode 100644
index e5fee780a..000000000
--- a/cppcache/src/util/functional.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#ifndef GEODE_UTIL_FUNCTIONAL_H_
-#define GEODE_UTIL_FUNCTIONAL_H_
-
-#include <functional>
-#include <memory>
-#include <type_traits>
-#include <string>
-#include <codecvt>
-#include <locale>
-
-#include "string.hpp"
-
-namespace apache {
-namespace geode {
-namespace client {
-
-template <class _T>
-struct dereference_hash;
-
-template <class _T>
-struct dereference_hash<std::shared_ptr<_T>>
- : public std::unary_function<std::shared_ptr<_T>, size_t> {
- size_t operator()(const std::shared_ptr<_T>& val) const {
- return std::hash<_T>{}(*val);
- }
-};
-
-template <class _T>
-struct dereference_hash<_T*> : public std::unary_function<_T*, size_t> {
- typedef _T* argument_type;
- size_t operator()(const argument_type& val) const {
- return std::hash<_T>{}(*val);
- }
-};
-
-template <class _T>
-struct dereference_equal_to;
-
-template <class _T>
-struct dereference_equal_to<std::shared_ptr<_T>>
- : public std::binary_function<std::shared_ptr<_T>, std::shared_ptr<_T>,
- bool> {
- constexpr bool operator()(const std::shared_ptr<_T>& lhs,
- const std::shared_ptr<_T>& rhs) const {
- return std::equal_to<_T>{}(*lhs, *rhs);
- }
-};
-
-template <class _T>
-struct dereference_equal_to<_T*> : std::equal_to<_T*> {
- typedef _T* first_argument_type;
- typedef _T* second_argument_type;
- constexpr bool operator()(const first_argument_type& lhs,
- const second_argument_type& rhs) const {
- return std::equal_to<_T>{}(*lhs, *rhs);
- }
-};
-
-/**
- * Hashes based on the same algorithm used in the Geode server.
- *
- * @tparam _T class type to hash.
- */
-template <class _T>
-struct geode_hash {
- typedef _T argument_type;
- int32_t operator()(const argument_type& val);
-};
-
-/**
- * Hashes like java.lang.String
- */
-template <>
-struct geode_hash<std::u16string> {
- inline int32_t operator()(const std::u16string& val) {
- int32_t hash = 0;
- for (auto&& c : val) {
- hash = 31 * hash + c;
- }
- return hash;
- }
-};
-
-/**
- * Hashes like java.lang.String
- */
-template <>
-struct geode_hash<std::string> {
- inline int32_t operator()(const std::string& val) {
- // TODO string optimize without conversion to UTF-16
- return geode_hash<std::u16string>{}(to_utf16(val));
- }
-};
-
-} // namespace client
-} // namespace geode
-} // namespace apache
-
-#endif // GEODE_UTIL_FUNCTIONAL_H_
diff --git a/cppcache/test/CacheableStringEqualityTest.cpp
b/cppcache/test/CacheableStringEqualityTest.cpp
index ad71d7f0e..7f3ef7bee 100644
--- a/cppcache/test/CacheableStringEqualityTest.cpp
+++ b/cppcache/test/CacheableStringEqualityTest.cpp
@@ -22,7 +22,7 @@
#include <unordered_map>
#include <geode/CacheableString.hpp>
-#include <geode/util/functional.hpp>
+#include <geode/internal/functional.hpp>
using namespace apache::geode::client;
diff --git a/cppcache/test/util/chrono/durationTest.cpp
b/cppcache/test/util/chrono/durationTest.cpp
index 9565a856b..262d212fc 100644
--- a/cppcache/test/util/chrono/durationTest.cpp
+++ b/cppcache/test/util/chrono/durationTest.cpp
@@ -20,10 +20,11 @@
#include <gtest/gtest.h>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "util/chrono/duration_bounds.hpp"
+using namespace apache::geode::internal::chrono::duration;
using namespace apache::geode::util::chrono::duration;
TEST(util_chrono_durationTest, ceil) {
diff --git a/cppcache/test/util/functionalTests.cpp
b/cppcache/test/util/functionalTests.cpp
index cc2ad34fd..410ccbc0c 100644
--- a/cppcache/test/util/functionalTests.cpp
+++ b/cppcache/test/util/functionalTests.cpp
@@ -19,9 +19,9 @@
#include <gtest/gtest.h>
-#include <geode/util/functional.hpp>
+#include <geode/internal/functional.hpp>
-using namespace apache::geode::client;
+using namespace apache::geode::client::internal;
TEST(string, geode_hash) {
auto&& hash = geode_hash<std::string>{};
diff --git a/tests/cpp/fwklib/FrameworkTest.cpp
b/tests/cpp/fwklib/FrameworkTest.cpp
index 0d80f8a70..1f5ab2d79 100644
--- a/tests/cpp/fwklib/FrameworkTest.cpp
+++ b/tests/cpp/fwklib/FrameworkTest.cpp
@@ -17,7 +17,7 @@
#include <geode/AttributesFactory.hpp>
#include <geode/PoolFactory.hpp>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "fwklib/FrameworkTest.hpp"
#include "fwklib/TestClient.hpp"
@@ -479,7 +479,7 @@ void FrameworkTest::setTestScheme() {
}
std::string FrameworkTest::poolAttributesToString(std::shared_ptr<Pool>& pool)
{
- using namespace apache::geode::util::chrono::duration;
+ using namespace apache::geode::internal::chrono::duration;
std::string sString;
sString += "\npoolName: ";
@@ -511,7 +511,8 @@ std::string
FrameworkTest::poolAttributesToString(std::shared_ptr<Pool>& pool) {
sString += "\nServerGroup: ";
sString += pool->getServerGroup();
sString += "\nIdleTimeout: ";
- sString += util::chrono::duration::to_string(pool->getIdleTimeout());
+ sString += apache::geode::internal::chrono::duration::to_string(
+ pool->getIdleTimeout());
sString += "\nPingInterval: ";
sString += to_string(pool->getPingInterval());
sString += "\nThreadLocalConnections: ";
diff --git a/tests/cpp/fwklib/FwkObjects.hpp b/tests/cpp/fwklib/FwkObjects.hpp
index 9b188ad5c..e8afcbecd 100644
--- a/tests/cpp/fwklib/FwkObjects.hpp
+++ b/tests/cpp/fwklib/FwkObjects.hpp
@@ -35,7 +35,7 @@
#include <geode/RegionAttributes.hpp>
#include <geode/AttributesFactory.hpp>
#include <geode/PoolManager.hpp>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "fwklib/FwkStrCvt.hpp"
#include "fwklib/FwkLog.hpp"
@@ -502,12 +502,14 @@ class FwkPool {
void setFreeConnectionTimeout(std::string val) {
m_poolFactory->setFreeConnectionTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setLoadConditioningInterval(std::string val) {
m_poolFactory->setLoadConditioningInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setSocketBufferSize(std::string val) {
@@ -516,7 +518,8 @@ class FwkPool {
void setReadTimeout(std::string val) {
m_poolFactory->setReadTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setMinConnections(std::string val) {
@@ -529,7 +532,8 @@ class FwkPool {
void setIdleTimeout(std::string val) {
m_poolFactory->setIdleTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setRetryAttempts(std::string val) {
@@ -538,12 +542,14 @@ class FwkPool {
void setPingInterval(std::string val) {
m_poolFactory->setPingInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setStatisticInterval(std::string val) {
m_poolFactory->setStatisticInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setServerGroup(std::string val) {
@@ -560,12 +566,14 @@ class FwkPool {
void setSubscriptionMessageTrackingTimeout(std::string val) {
m_poolFactory->setSubscriptionMessageTrackingTimeout(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setSubscriptionAckInterval(std::string val) {
m_poolFactory->setSubscriptionAckInterval(
- util::chrono::duration::from_string<std::chrono::milliseconds>(val));
+ apache::geode::internal::chrono::duration::from_string<
+ std::chrono::milliseconds>(val));
}
void setThreadLocalConnections(std::string val) {
diff --git a/tests/cpp/fwklib/RegionHelper.hpp
b/tests/cpp/fwklib/RegionHelper.hpp
index 58f18868b..9f4cad96d 100644
--- a/tests/cpp/fwklib/RegionHelper.hpp
+++ b/tests/cpp/fwklib/RegionHelper.hpp
@@ -24,7 +24,7 @@
#include <string>
#include <map>
-#include <geode/util/chrono/duration.hpp>
+#include <geode/internal/chrono/duration.hpp>
#include "fwklib/FrameworkTest.hpp"
#include "fwklib/FwkObjects.hpp"
@@ -36,7 +36,7 @@ namespace geode {
namespace client {
namespace testframework {
-using namespace apache::geode::util::chrono::duration;
+using namespace apache::geode::internal::chrono::duration;
// ----------------------------------------------------------------------------
----------------------------------------------------------------
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]
> Move internal use templates and headers under internal namespace.
> -----------------------------------------------------------------
>
> Key: GEODE-4188
> URL: https://issues.apache.org/jira/browse/GEODE-4188
> Project: Geode
> Issue Type: Task
> Components: native client
> Reporter: Jacob S. Barrett
> Assignee: Jacob S. Barrett
> Labels: optimize
>
> Move internal use only headers and templates into an internal namespace.
> Headers should be in {{cppcache/include/geode/internal}}.
> All types, headers, etc. should be in namespace
> {{apache::geode::client::internal}}.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
