geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [10/50] [abbrv] geode git commit: GEODE-2316: Rename namespace gemfire to apache::geode::client.
Date Mon, 23 Jan 2017 19:17:02 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp b/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
index 8f22cf7..e49cbce 100644
--- a/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
+++ b/src/cppcache/include/gfcpp/PdxAutoSerializer.hpp
@@ -27,150 +27,154 @@
 #include "GemfireTypeIds.hpp"
 #include "TypeHelper.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 namespace PdxAutoSerializable {
 // Read and write methods for various types
 // uint8_t
 //------------------------------------------------------------------------------------------------
 #ifdef _SOLARIS
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int8_t value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int8_t value) {
   pw->writeByte(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int8_t& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int8_t& value) {
   value = pr->readByte(fieldName);
 }
 #else
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           char value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, char value) {
   pw->writeChar(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          char& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, char& value) {
   value = pr->readChar(fieldName);
 }
 #endif
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           wchar_t value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, wchar_t value) {
   pw->writeWideChar(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          wchar_t& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, wchar_t& value) {
   value = pr->readWideChar(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           bool value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, bool value) {
   pw->writeBoolean(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          bool& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, bool& value) {
   value = pr->readBoolean(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           signed char value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, signed char value) {
   pw->writeByte(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          signed char& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, signed char& value) {
   value = pr->readByte(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int16_t value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int16_t value) {
   pw->writeShort(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int16_t& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int16_t& value) {
   value = pr->readShort(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int32_t value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int32_t value) {
   pw->writeInt(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int32_t& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int32_t& value) {
   value = pr->readInt(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int64_t value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int64_t value) {
   pw->writeLong(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int64_t& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int64_t& value) {
   value = pr->readLong(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           float value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, float value) {
   pw->writeFloat(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          float& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, float& value) {
   value = pr->readFloat(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           double value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, double value) {
   pw->writeDouble(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          double& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, double& value) {
   value = pr->readDouble(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           CacheableDatePtr value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, CacheableDatePtr value) {
   pw->writeDate(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          CacheableDatePtr& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, CacheableDatePtr& value) {
   value = pr->readDate(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           const char* value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, const char* value) {
   pw->writeString(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          char*& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, char*& value) {
   value = pr->readString(fieldName);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           const wchar_t* value) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, const wchar_t* value) {
   pw->writeWideString(fieldName, value);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          wchar_t*& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, wchar_t*& value) {
   value = pr->readWideString(fieldName);
 }
 // ---- helper methods for bytearrayofarray -------
 #ifdef _SOLARIS
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           char** value, int32_t arraySize,
-                           int32_t* elemArraySize) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, char** value,
+                           int32_t arraySize, int32_t* elemArraySize) {
   pw->writeArrayOfByteArrays(fieldName, (char**)value, arraySize,
                              elemArraySize);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          char**& value, int32_t& len, int32_t*& Lengtharr) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, char**& value, int32_t& len,
+                          int32_t*& Lengtharr) {
   GF_NEW(Lengtharr, int32_t[len]);
   value = (char**)pr->readArrayOfByteArrays(fieldName, len, &Lengtharr);
 }
 #else
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int8_t** value, int32_t arraySize,
-                           int32_t* elemArraySize) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int8_t** value,
+                           int32_t arraySize, int32_t* elemArraySize) {
   pw->writeArrayOfByteArrays(fieldName, value, arraySize, elemArraySize);
 }
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int8_t**& value, int32_t& len, int32_t*& Lengtharr) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int8_t**& value, int32_t& len,
+                          int32_t*& Lengtharr) {
   GF_NEW(Lengtharr, int32_t[len]);
   value = (signed char**)pr->readArrayOfByteArrays(fieldName, len, &Lengtharr);
 }
@@ -179,167 +183,183 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //------------------------------------------------------------------------------------------------
 // Base Serializable types
 template <typename TObj>
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           const gemfire::SharedPtr<TObj>& value,
-                           gemfire::TypeHelper::yes_type isSerializable) {
+inline void writePdxObject(
+    apache::geode::client::PdxWriterPtr& pw, const char* fieldName,
+    const apache::geode::client::SharedPtr<TObj>& value,
+    apache::geode::client::TypeHelper::yes_type isSerializable) {
   pw->writeObject(fieldName, value);
 }
 
 template <typename TObj>
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           const gemfire::SharedPtr<TObj>& value) {
+inline void writePdxObject(
+    apache::geode::client::PdxWriterPtr& pw, const char* fieldName,
+    const apache::geode::client::SharedPtr<TObj>& value) {
   writePdxObject(pw, fieldName, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
 }
 
 template <typename TObj>
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          gemfire::SharedPtr<TObj>& value,
-                          gemfire::TypeHelper::yes_type isSerializable) {
-  value = dynCast<gemfire::SharedPtr<TObj> >(pr->readObject(fieldName));
+inline void readPdxObject(
+    apache::geode::client::PdxReaderPtr& pr, const char* fieldName,
+    apache::geode::client::SharedPtr<TObj>& value,
+    apache::geode::client::TypeHelper::yes_type isSerializable) {
+  value = dynCast<apache::geode::client::SharedPtr<TObj> >(
+      pr->readObject(fieldName));
 }
 
 template <typename TObj>
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          gemfire::SharedPtr<TObj>& value) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName,
+                          apache::geode::client::SharedPtr<TObj>& value) {
   readPdxObject(pr, fieldName, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           bool* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, bool* value, int32_t len) {
   pw->writeBooleanArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          bool*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, bool*& value, int32_t& len) {
   value = pr->readBooleanArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           wchar_t* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, wchar_t* value, int32_t len) {
   pw->writeWideCharArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          wchar_t*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, wchar_t*& value,
+                          int32_t& len) {
   value = pr->readWideCharArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
 #ifdef _SOLARIS
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int8_t* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int8_t* value, int32_t len) {
   pw->writeByteArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int8_t*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int8_t*& value, int32_t& len) {
   value = (int8_t*)pr->readByteArray(fieldName, len);
 }
 #else
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           char* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, char* value, int32_t len) {
   pw->writeCharArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          char*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, char*& value, int32_t& len) {
   value = pr->readCharArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           signed char* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, signed char* value,
+                           int32_t len) {
   pw->writeByteArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          signed char*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, signed char*& value,
+                          int32_t& len) {
   value = (signed char*)pr->readByteArray(fieldName, len);
 }
 #endif
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int16_t* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int16_t* value, int32_t len) {
   pw->writeShortArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int16_t*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int16_t*& value,
+                          int32_t& len) {
   value = pr->readShortArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int32_t* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int32_t* value, int32_t len) {
   pw->writeIntArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int32_t*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int32_t*& value,
+                          int32_t& len) {
   value = pr->readIntArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           int64_t* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, int64_t* value, int32_t len) {
   pw->writeLongArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          int64_t*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, int64_t*& value,
+                          int32_t& len) {
   value = pr->readLongArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           float* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, float* value, int32_t len) {
   pw->writeFloatArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          float*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, float*& value, int32_t& len) {
   value = pr->readFloatArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           double* value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, double* value, int32_t len) {
   pw->writeDoubleArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          double*& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, double*& value, int32_t& len) {
   value = pr->readDoubleArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           char** value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, char** value, int32_t len) {
   pw->writeStringArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          char**& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, char**& value, int32_t& len) {
   value = pr->readStringArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
-                           wchar_t** value, int32_t len) {
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName, wchar_t** value,
+                           int32_t len) {
   pw->writeWideStringArray(fieldName, value, len);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
-                          wchar_t**& value, int32_t& len) {
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName, wchar_t**& value,
+                          int32_t& len) {
   value = pr->readWideStringArray(fieldName, len);
 }
 //------------------------------------------------------------------------------------------------
-inline void writePdxObject(gemfire::PdxWriterPtr& pw, const char* fieldName,
+inline void writePdxObject(apache::geode::client::PdxWriterPtr& pw,
+                           const char* fieldName,
                            CacheableObjectArrayPtr value) {
   pw->writeObjectArray(fieldName, value);
 }
 
-inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
+inline void readPdxObject(apache::geode::client::PdxReaderPtr& pr,
+                          const char* fieldName,
                           CacheableObjectArrayPtr& value) {
   value = pr->readObjectArray(fieldName);
 }
 //------------------------------------------------------------------------------------------------
 // For containers vector/hashmap/hashset
 // template <typename TObj>
-// inline void writePdxObject( gemfire::PdxWriterPtr& pw,  const char*
+// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw,  const
+// char*
 // fieldName,
 //    const VectorT< TObj >& value )
 //{
@@ -365,7 +385,8 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //}
 
 // template <typename TObj>
-// inline void readPdxObject( gemfire::PdxReaderPtr& pr,  const char* fieldName,
+// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr,  const
+// char* fieldName,
 //    VectorT< TObj >& value )
 //{
 //  int32_t len;
@@ -380,7 +401,8 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //}
 
 // template <typename TKey, typename TValue>
-// inline void writePdxObject( gemfire::PdxWriterPtr& pw,  const char*
+// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw,  const
+// char*
 // fieldName,
 //    const HashMapT< TKey, TValue >& value )
 //{
@@ -411,7 +433,8 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //}
 
 // template <typename TKey, typename TValue>
-// inline void readPdxObject( gemfire::PdxReaderPtr& pr,  const char* fieldName,
+// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr,  const
+// char* fieldName,
 //    HashMapT< TKey, TValue >& value )
 //{
 //  int32_t len;
@@ -428,7 +451,8 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //}
 
 // template <typename TKey>
-// inline void writePdxObject( gemfire::PdxWriterPtr& pw,  const char*
+// inline void writePdxObject( apache::geode::client::PdxWriterPtr& pw,  const
+// char*
 // fieldName,
 //  const HashSetT< TKey >& value )
 //{
@@ -454,7 +478,8 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //}
 
 // template <typename TKey>
-// inline void readPdxObject( gemfire::PdxReaderPtr& pr,  const char* fieldName,
+// inline void readPdxObject( apache::geode::client::PdxReaderPtr& pr,  const
+// char* fieldName,
 //    HashSetT< TKey >& value )
 //{
 //  int32_t len;
@@ -495,6 +520,8 @@ inline void readPdxObject(gemfire::PdxReaderPtr& pr, const char* fieldName,
 //}
 
 }  // namespace PdxAutoSerializable
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // _GEMFIRE_SERIALIZER_HPP_

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxFieldTypes.hpp b/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
index c468222..d425ce5 100644
--- a/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
+++ b/src/cppcache/include/gfcpp/PdxFieldTypes.hpp
@@ -18,7 +18,9 @@
  * limitations under the License.
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class CPPCACHE_EXPORT PdxFieldTypes {
  public:
@@ -47,5 +49,7 @@ class CPPCACHE_EXPORT PdxFieldTypes {
     ARRAY_OF_BYTE_ARRAYS
   };
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif /* __GEMFIRE_PDXFIELDTYPES_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxInstance.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxInstance.hpp b/src/cppcache/include/gfcpp/PdxInstance.hpp
index 4a0a58f..2d80a69 100644
--- a/src/cppcache/include/gfcpp/PdxInstance.hpp
+++ b/src/cppcache/include/gfcpp/PdxInstance.hpp
@@ -22,7 +22,9 @@
 #include "CacheableBuiltins.hpp"
 #include "PdxFieldTypes.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
 * PdxInstance provides run time access to the fields of a PDX without
@@ -607,5 +609,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
   PdxInstance(const PdxInstance& other);
   void operator=(const PdxInstance& other);
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif /* __GEMFIRE_PDXINSTANCE_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxInstanceFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxInstanceFactory.hpp b/src/cppcache/include/gfcpp/PdxInstanceFactory.hpp
index f66b3b5..d2ec544 100644
--- a/src/cppcache/include/gfcpp/PdxInstanceFactory.hpp
+++ b/src/cppcache/include/gfcpp/PdxInstanceFactory.hpp
@@ -25,7 +25,9 @@
 #include "CacheableDate.hpp"
 #include "CacheableObjectArray.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
 * PdxInstanceFactory gives you a way to create PdxInstances.
@@ -465,6 +467,8 @@ class CPPCACHE_EXPORT PdxInstanceFactory : public SharedBase {
   */
   virtual PdxInstanceFactoryPtr markIdentityField(const char* fieldName) = 0;
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif /* __PDXINSTANCE_FACTORY_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxReader.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxReader.hpp b/src/cppcache/include/gfcpp/PdxReader.hpp
index 79713b4..ff9cdb3 100644
--- a/src/cppcache/include/gfcpp/PdxReader.hpp
+++ b/src/cppcache/include/gfcpp/PdxReader.hpp
@@ -21,7 +21,9 @@
 #include "CacheableBuiltins.hpp"
 #include "PdxUnreadFields.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class PdxReader;
 typedef SharedPtr<PdxReader> PdxReaderPtr;
@@ -409,5 +411,7 @@ class CPPCACHE_EXPORT PdxReader : public SharedBase {
    */
   virtual PdxUnreadFieldsPtr readUnreadFields() = 0;
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif /* PDXREADER_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxSerializable.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxSerializable.hpp b/src/cppcache/include/gfcpp/PdxSerializable.hpp
index ae35083..1180b48 100644
--- a/src/cppcache/include/gfcpp/PdxSerializable.hpp
+++ b/src/cppcache/include/gfcpp/PdxSerializable.hpp
@@ -20,7 +20,9 @@
 
 #include "CacheableKey.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 typedef PdxSerializable* (*PdxTypeFactoryMethod)();
 
@@ -103,6 +105,8 @@ class CPPCACHE_EXPORT PdxSerializable : public CacheableKey {
    */
   virtual const char* getClassName() const = 0;
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif /* PDXSERIALIZABLE_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxSerializer.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxSerializer.hpp b/src/cppcache/include/gfcpp/PdxSerializer.hpp
index fe71ff6..5ba641a 100644
--- a/src/cppcache/include/gfcpp/PdxSerializer.hpp
+++ b/src/cppcache/include/gfcpp/PdxSerializer.hpp
@@ -21,7 +21,9 @@
 #include "Serializable.hpp"
 #include "PdxReader.hpp"
 #include "PdxWriter.hpp"
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * Function pointer type which takes a void pointer to an instance of a user
@@ -81,6 +83,8 @@ class CPPCACHE_EXPORT PdxSerializer : public SharedBase {
     return NULL;
   };
 };
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
-} /* namespace gemfire */
 #endif /* PDXSERIALIZER_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxUnreadFields.hpp b/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
index f6326bc..113101f 100644
--- a/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
+++ b/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
@@ -21,7 +21,9 @@
 #include "gf_base.hpp"
 #include "SharedBase.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * Marker interface for an object that GemFire creates and returns
@@ -42,6 +44,8 @@ class CPPCACHE_EXPORT PdxUnreadFields : public SharedBase {
   PdxUnreadFields() {}
   virtual ~PdxUnreadFields() {}
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif /* __GEMFIRE_PDXUNREADFIELDS_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxWrapper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxWrapper.hpp b/src/cppcache/include/gfcpp/PdxWrapper.hpp
index 88d59af..03a6099 100644
--- a/src/cppcache/include/gfcpp/PdxWrapper.hpp
+++ b/src/cppcache/include/gfcpp/PdxWrapper.hpp
@@ -21,7 +21,9 @@
 #include "PdxSerializer.hpp"
 #include "PdxSerializable.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
   /**
@@ -127,6 +129,8 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
 
   const PdxWrapper& operator=(const PdxWrapper&);
 };
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
-} /* namespace gemfire */
 #endif /* _PDXWRAPPER_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PdxWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxWriter.hpp b/src/cppcache/include/gfcpp/PdxWriter.hpp
index a0c410b..ec2197e 100644
--- a/src/cppcache/include/gfcpp/PdxWriter.hpp
+++ b/src/cppcache/include/gfcpp/PdxWriter.hpp
@@ -23,7 +23,9 @@
 #include "CacheableBuiltins.hpp"
 #include "CacheableDate.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class PdxWriter;
 typedef SharedPtr<PdxWriter> PdxWriterPtr;
@@ -440,5 +442,7 @@ class CPPCACHE_EXPORT PdxWriter : public SharedBase {
    */
   virtual PdxWriterPtr writeUnreadFields(PdxUnreadFieldsPtr unread) = 0;
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif /* PDXWRITER_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PersistenceManager.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PersistenceManager.hpp b/src/cppcache/include/gfcpp/PersistenceManager.hpp
index aac9d1d..135e4a0 100644
--- a/src/cppcache/include/gfcpp/PersistenceManager.hpp
+++ b/src/cppcache/include/gfcpp/PersistenceManager.hpp
@@ -31,7 +31,9 @@
 #define PAGE_SIZE "PageSize"
 #define PERSISTENCE_DIR "PersistenceDirectory"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 typedef PersistenceManagerPtr (*getPersistenceManagerInstance)(
     const RegionPtr&);
@@ -128,6 +130,7 @@ class CPPCACHE_EXPORT PersistenceManager : public SharedBase {
    */
   const RegionPtr m_regionPtr;
 };
-
-};      // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif  // ifndef __GEMFIRE_PERSISTENCEMANAGER_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Pool.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Pool.hpp b/src/cppcache/include/gfcpp/Pool.hpp
index eaef02e..06f07a4 100644
--- a/src/cppcache/include/gfcpp/Pool.hpp
+++ b/src/cppcache/include/gfcpp/Pool.hpp
@@ -27,7 +27,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 class Cache;
 class CacheFactory;
 class PoolAttributes;
@@ -276,6 +278,8 @@ class CPPCACHE_EXPORT Pool : public SharedBase {
   friend class CacheFactory;
   friend class Cache;
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_POOL_HPP__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PoolFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PoolFactory.hpp b/src/cppcache/include/gfcpp/PoolFactory.hpp
index 2fdd263..cb74e49 100644
--- a/src/cppcache/include/gfcpp/PoolFactory.hpp
+++ b/src/cppcache/include/gfcpp/PoolFactory.hpp
@@ -26,7 +26,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class CacheImpl;
 class PoolAttributes;
@@ -527,5 +529,7 @@ class CPPCACHE_EXPORT PoolFactory : public SharedBase {
   friend class CacheFactory;
   friend class CacheXmlCreation;
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif  // ifndef __GEMFIRE_POOL_FACTORY_HPP__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/PoolManager.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PoolManager.hpp b/src/cppcache/include/gfcpp/PoolManager.hpp
index 1b63400..5a5ef4f 100644
--- a/src/cppcache/include/gfcpp/PoolManager.hpp
+++ b/src/cppcache/include/gfcpp/PoolManager.hpp
@@ -23,7 +23,9 @@
 #include "PoolFactory.hpp"
 #include "Region.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 typedef HashMapT<CacheableStringPtr, PoolPtr> HashMapOfPools;
 
@@ -89,6 +91,8 @@ class CPPCACHE_EXPORT PoolManager {
  private:
   PoolManager();
 };
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
-};      // Namespace gemfire
 #endif  //__GEMFIRE_POOL_MANAGER_HPP__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Properties.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Properties.hpp b/src/cppcache/include/gfcpp/Properties.hpp
index 532237d..a3df51f 100644
--- a/src/cppcache/include/gfcpp/Properties.hpp
+++ b/src/cppcache/include/gfcpp/Properties.hpp
@@ -29,7 +29,9 @@
 #include "CacheableKey.hpp"
 #include "CacheableString.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * @class Properties Properties.hpp
@@ -152,6 +154,7 @@ class CPPCACHE_EXPORT Properties : public Serializable {
   Properties(const Properties&);
   const Properties& operator=(const Properties&);
 };
-
-};      // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif  // ifndef __GEMFIRE_PROPERTIES_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Query.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Query.hpp b/src/cppcache/include/gfcpp/Query.hpp
index 6f8f1c5..27a77aa 100644
--- a/src/cppcache/include/gfcpp/Query.hpp
+++ b/src/cppcache/include/gfcpp/Query.hpp
@@ -26,7 +26,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * @class Query Query.hpp
@@ -112,7 +114,8 @@ class CPPCACHE_EXPORT Query : public SharedBase {
    */
   virtual bool isCompiled() = 0;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_QUERY_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/QueryService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/QueryService.hpp b/src/cppcache/include/gfcpp/QueryService.hpp
index e5c0bc8..d5e9021 100644
--- a/src/cppcache/include/gfcpp/QueryService.hpp
+++ b/src/cppcache/include/gfcpp/QueryService.hpp
@@ -30,7 +30,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * @class QueryService QueryService.hpp
@@ -165,7 +167,8 @@ class CPPCACHE_EXPORT QueryService : public SharedBase {
    */
   virtual CacheableArrayListPtr getAllDurableCqsFromServer() = 0;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_QUERYSERVICE_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Region.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Region.hpp b/src/cppcache/include/gfcpp/Region.hpp
index 60fda55..6b04225 100644
--- a/src/cppcache/include/gfcpp/Region.hpp
+++ b/src/cppcache/include/gfcpp/Region.hpp
@@ -46,7 +46,9 @@
 #include "Query.hpp"
 #define DEFAULT_RESPONSE_TIMEOUT 15
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 /**
 * @class Region Region.hpp
 *
@@ -1444,7 +1446,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   Region(const Region&);
   Region& operator=(const Region&);
 };
-
-};  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_REGION_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/RegionAttributes.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionAttributes.hpp b/src/cppcache/include/gfcpp/RegionAttributes.hpp
index ca6e406..7c72e56 100644
--- a/src/cppcache/include/gfcpp/RegionAttributes.hpp
+++ b/src/cppcache/include/gfcpp/RegionAttributes.hpp
@@ -33,7 +33,9 @@
 #include "DiskPolicyType.hpp"
 #include "PersistenceManager.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 class CacheImpl;
 
 /**
@@ -391,7 +393,8 @@ class CPPCACHE_EXPORT RegionAttributes : public Serializable {
  private:
   const RegionAttributes& operator=(const RegionAttributes&);
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_REGIONATTRIBUTES_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/RegionEntry.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionEntry.hpp b/src/cppcache/include/gfcpp/RegionEntry.hpp
index 7a39958..143ccd9 100644
--- a/src/cppcache/include/gfcpp/RegionEntry.hpp
+++ b/src/cppcache/include/gfcpp/RegionEntry.hpp
@@ -26,7 +26,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class RegionInternal;
 
@@ -99,7 +101,8 @@ class CPPCACHE_EXPORT RegionEntry : public SharedBase {
   bool m_destroyed;
   friend class RegionInternal;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/RegionEvent.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionEvent.hpp b/src/cppcache/include/gfcpp/RegionEvent.hpp
index 447fb8e..043b775 100644
--- a/src/cppcache/include/gfcpp/RegionEvent.hpp
+++ b/src/cppcache/include/gfcpp/RegionEvent.hpp
@@ -25,7 +25,9 @@
 /** @file
 */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /** Declares region events.
 */
@@ -65,6 +67,8 @@ class CPPCACHE_EXPORT RegionEvent {
   RegionEvent(const RegionEvent& other);
   void operator=(const RegionEvent& other);
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/RegionFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionFactory.hpp b/src/cppcache/include/gfcpp/RegionFactory.hpp
index cdfa766..e83c426 100644
--- a/src/cppcache/include/gfcpp/RegionFactory.hpp
+++ b/src/cppcache/include/gfcpp/RegionFactory.hpp
@@ -24,7 +24,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 class CacheImpl;
 class CPPCACHE_EXPORT RegionFactory : public SharedBase {
  public:
@@ -248,7 +250,7 @@ class CPPCACHE_EXPORT RegionFactory : public SharedBase {
   RegionFactoryPtr setTombstoneTimeout(uint32_t tombstoneTimeoutInMSec);
 
  private:
-  RegionFactory(gemfire::RegionShortcut preDefinedRegion);
+  RegionFactory(apache::geode::client::RegionShortcut preDefinedRegion);
 
   RegionShortcut m_preDefinedRegion;
 
@@ -259,6 +261,8 @@ class CPPCACHE_EXPORT RegionFactory : public SharedBase {
   ~RegionFactory();
   friend class CacheImpl;
 };
-};  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_REGIONFACTORY_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/RegionService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionService.hpp b/src/cppcache/include/gfcpp/RegionService.hpp
index 2b65d9b..4553f6c 100644
--- a/src/cppcache/include/gfcpp/RegionService.hpp
+++ b/src/cppcache/include/gfcpp/RegionService.hpp
@@ -25,7 +25,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class Region;
 class QueryService;
@@ -112,6 +114,7 @@ class CPPCACHE_EXPORT RegionService : public SharedBase {
   virtual PdxInstanceFactoryPtr createPdxInstanceFactory(
       const char* className) = 0;
 };
-
-};      // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif  // ifndef __GEMFIRE_RegionService_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/RegionShortcut.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionShortcut.hpp b/src/cppcache/include/gfcpp/RegionShortcut.hpp
index d781c94..3a8119c 100644
--- a/src/cppcache/include/gfcpp/RegionShortcut.hpp
+++ b/src/cppcache/include/gfcpp/RegionShortcut.hpp
@@ -29,7 +29,9 @@
  * the refid attribute on a region element or region-attributes element to the
  * string of each value.
  */
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 enum RegionShortcut {
 
   /**
@@ -68,7 +70,8 @@ enum RegionShortcut {
    */
   LOCAL_ENTRY_LRU
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_REGIONSHORTCUT_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/ResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/ResultCollector.hpp b/src/cppcache/include/gfcpp/ResultCollector.hpp
index 7397c9d..683e88e 100644
--- a/src/cppcache/include/gfcpp/ResultCollector.hpp
+++ b/src/cppcache/include/gfcpp/ResultCollector.hpp
@@ -27,7 +27,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 /**
  * @class ResultCollector ResultCollector.hpp
  * Defines the interface for a container that gathers results from function
@@ -102,6 +104,7 @@ class CPPCACHE_EXPORT ResultCollector : public SharedBase {
   CacheableVectorPtr m_resultList;
   volatile bool m_isResultReady;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif  // ifndef __GEMFIRE_RESULTCOLLECTOR_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/ResultSet.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/ResultSet.hpp b/src/cppcache/include/gfcpp/ResultSet.hpp
index bb82bc0..b4703c7 100644
--- a/src/cppcache/include/gfcpp/ResultSet.hpp
+++ b/src/cppcache/include/gfcpp/ResultSet.hpp
@@ -30,7 +30,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * @class ResultSet ResultSet.hpp
@@ -75,7 +77,8 @@ class CPPCACHE_EXPORT ResultSet : public SelectResults {
    */
   virtual ~ResultSet(){};
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_RESULTSET_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/SelectResults.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SelectResults.hpp b/src/cppcache/include/gfcpp/SelectResults.hpp
index a6fd726..bc3e9f4 100644
--- a/src/cppcache/include/gfcpp/SelectResults.hpp
+++ b/src/cppcache/include/gfcpp/SelectResults.hpp
@@ -26,7 +26,9 @@
 #include "ExceptionTypes.hpp"
 #include "Serializable.hpp"
 #include "CacheableBuiltins.hpp"
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class SelectResultsIterator;
 
@@ -78,7 +80,8 @@ class CPPCACHE_EXPORT SelectResults : public SharedBase {
   /** Get an iterator pointing to the end of vector. */
   virtual Iterator end() const = 0;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_SELECTRESULTS_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/SelectResultsIterator.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SelectResultsIterator.hpp b/src/cppcache/include/gfcpp/SelectResultsIterator.hpp
index d0a7e3d..f4f2004 100644
--- a/src/cppcache/include/gfcpp/SelectResultsIterator.hpp
+++ b/src/cppcache/include/gfcpp/SelectResultsIterator.hpp
@@ -29,7 +29,9 @@
 #include "SelectResults.hpp"
 #include "CacheableBuiltins.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class ResultSetImpl;
 class StructSetImpl;
@@ -92,7 +94,8 @@ class CPPCACHE_EXPORT SelectResultsIterator : public SharedBase {
   friend class ResultSetImpl;
   friend class StructSetImpl;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_SELECTRESULTSITERATOR_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Serializable.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Serializable.hpp b/src/cppcache/include/gfcpp/Serializable.hpp
index 528922d..6056754 100644
--- a/src/cppcache/include/gfcpp/Serializable.hpp
+++ b/src/cppcache/include/gfcpp/Serializable.hpp
@@ -24,7 +24,9 @@
 #include "gfcpp_globals.hpp"
 #include "gf_types.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class DataOutput;
 class DataInput;
@@ -137,9 +139,9 @@ class CPPCACHE_EXPORT Serializable : public SharedBase {
   /** Factory method that creates the Serializable object that matches the type
    * of value.
    * For customer defined derivations of Serializable, the method
-   * gemfire::createValue
+   * apache::geode::client::createValue
    * may be overloaded. For pointer types (e.g. char*) the method
-   * gemfire::createValueArr may be overloaded.
+   * apache::geode::client::createValueArr may be overloaded.
    */
   template <class PRIM>
   inline static SerializablePtr create(const PRIM value);
@@ -160,7 +162,8 @@ class CPPCACHE_EXPORT Serializable : public SharedBase {
   Serializable(const Serializable& other);
   void operator=(const Serializable& other);
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_SERIALIZABLE_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Serializer.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Serializer.hpp b/src/cppcache/include/gfcpp/Serializer.hpp
index 4207164..0ef3096 100644
--- a/src/cppcache/include/gfcpp/Serializer.hpp
+++ b/src/cppcache/include/gfcpp/Serializer.hpp
@@ -27,203 +27,230 @@
 #include "GemfireTypeIds.hpp"
 #include "TypeHelper.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 namespace serializer {
 
 // Read and write methods for various types
 
-inline void writeObject(gemfire::DataOutput& output, uint8_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        uint8_t value) {
   output.write(value);
 }
 
-inline void readObject(gemfire::DataInput& input, uint8_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       uint8_t& value) {
   input.read(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, int8_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        int8_t value) {
   output.write(value);
 }
 
-inline void readObject(gemfire::DataInput& input, int8_t& value) {
+inline void readObject(apache::geode::client::DataInput& input, int8_t& value) {
   input.read(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, const uint8_t* bytes,
-                        int32_t len) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const uint8_t* bytes, int32_t len) {
   output.writeBytes(bytes, len);
 }
 
-inline void readObject(gemfire::DataInput& input, uint8_t*& bytes,
+inline void readObject(apache::geode::client::DataInput& input, uint8_t*& bytes,
                        int32_t& len) {
   input.readBytes(&bytes, &len);
 }
 
-inline void writeObject(gemfire::DataOutput& output, const int8_t* bytes,
-                        int32_t len) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const int8_t* bytes, int32_t len) {
   output.writeBytes(bytes, len);
 }
 
-inline void readObject(gemfire::DataInput& input, int8_t*& bytes,
+inline void readObject(apache::geode::client::DataInput& input, int8_t*& bytes,
                        int32_t& len) {
   input.readBytes(&bytes, &len);
 }
 
-inline void writeObject(gemfire::DataOutput& output, int16_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        int16_t value) {
   output.writeInt(value);
 }
 
-inline void readObject(gemfire::DataInput& input, int16_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       int16_t& value) {
   input.readInt(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, int32_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        int32_t value) {
   output.writeInt(value);
 }
 
-inline void readObject(gemfire::DataInput& input, int32_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       int32_t& value) {
   input.readInt(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, int64_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        int64_t value) {
   output.writeInt(value);
 }
 
-inline void readObject(gemfire::DataInput& input, int64_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       int64_t& value) {
   input.readInt(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, uint16_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        uint16_t value) {
   output.writeInt(value);
 }
 
-inline void readObject(gemfire::DataInput& input, uint16_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       uint16_t& value) {
   input.readInt(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, uint32_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        uint32_t value) {
   output.writeInt(value);
 }
 
-inline void readObject(gemfire::DataInput& input, uint32_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       uint32_t& value) {
   input.readInt(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, uint64_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        uint64_t value) {
   output.writeInt(value);
 }
 
-inline void readObject(gemfire::DataInput& input, uint64_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       uint64_t& value) {
   input.readInt(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, bool value) {
+inline void writeObject(apache::geode::client::DataOutput& output, bool value) {
   output.writeBoolean(value);
 }
 
-inline void readObject(gemfire::DataInput& input, bool& value) {
+inline void readObject(apache::geode::client::DataInput& input, bool& value) {
   input.readBoolean(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, double value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        double value) {
   output.writeDouble(value);
 }
 
-inline void readObject(gemfire::DataInput& input, double& value) {
+inline void readObject(apache::geode::client::DataInput& input, double& value) {
   input.readDouble(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, float value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        float value) {
   output.writeFloat(value);
 }
 
-inline void readObject(gemfire::DataInput& input, float& value) {
+inline void readObject(apache::geode::client::DataInput& input, float& value) {
   input.readFloat(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, wchar_t value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        wchar_t value) {
   output.writeInt(static_cast<int16_t>(value));
 }
 
-inline void readObject(gemfire::DataInput& input, wchar_t& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       wchar_t& value) {
   int16_t val;
   input.readInt(&val);
   value = val;
 }
 
-inline void writeObject(gemfire::DataOutput& output, const char* value,
-                        uint32_t length) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const char* value, uint32_t length) {
   output.writeASCII(value, length);
 }
 
 template <typename TLen>
-inline void readObject(gemfire::DataInput& input, char*& value, TLen& length) {
+inline void readObject(apache::geode::client::DataInput& input, char*& value,
+                       TLen& length) {
   uint16_t len;
   input.readASCII(&value, &len);
   length = len;
 }
 
-inline void writeObject(gemfire::DataOutput& output, const char* value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const char* value) {
   output.writeASCII(value);
 }
 
-inline void readObject(gemfire::DataInput& input, char*& value) {
+inline void readObject(apache::geode::client::DataInput& input, char*& value) {
   input.readASCII(&value);
 }
 
-inline void writeObject(gemfire::DataOutput& output, const wchar_t* value,
-                        uint32_t length) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const wchar_t* value, uint32_t length) {
   output.writeUTF(value, length);
 }
 
 template <typename TLen>
-inline void readObject(gemfire::DataInput& input, wchar_t*& value,
+inline void readObject(apache::geode::client::DataInput& input, wchar_t*& value,
                        TLen& length) {
   uint16_t len;
   input.readUTF(&value, &len);
   length = len;
 }
 
-inline void writeObject(gemfire::DataOutput& output, const wchar_t* value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const wchar_t* value) {
   output.writeUTF(value);
 }
 
-inline void readObject(gemfire::DataInput& input, wchar_t*& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       wchar_t*& value) {
   input.readUTF(&value);
 }
 
 // Base Serializable types
 
 template <typename TObj>
-inline void writeObject(gemfire::DataOutput& output,
-                        const gemfire::SharedPtr<TObj>& value,
-                        gemfire::TypeHelper::yes_type isSerializable) {
+inline void writeObject(
+    apache::geode::client::DataOutput& output,
+    const apache::geode::client::SharedPtr<TObj>& value,
+    apache::geode::client::TypeHelper::yes_type isSerializable) {
   output.writeObject(value);
 }
 
 template <typename TObj>
-inline void writeObject(gemfire::DataOutput& output,
-                        const gemfire::SharedPtr<TObj>& value) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const apache::geode::client::SharedPtr<TObj>& value) {
   writeObject(output, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
 }
 
 template <typename TObj>
-inline void readObject(gemfire::DataInput& input,
-                       gemfire::SharedPtr<TObj>& value,
-                       gemfire::TypeHelper::yes_type isSerializable) {
+inline void readObject(
+    apache::geode::client::DataInput& input,
+    apache::geode::client::SharedPtr<TObj>& value,
+    apache::geode::client::TypeHelper::yes_type isSerializable) {
   input.readObject(value, true);
 }
 
 template <typename TObj>
-inline void readObject(gemfire::DataInput& input,
-                       gemfire::SharedPtr<TObj>& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       apache::geode::client::SharedPtr<TObj>& value) {
   readObject(input, value, GF_TYPE_IS_SERIALIZABLE_TYPE(TObj));
 }
 
 // For arrays
 
 template <typename TObj, typename TLen>
-inline void writeObject(gemfire::DataOutput& output, const TObj* array,
-                        TLen len) {
+inline void writeObject(apache::geode::client::DataOutput& output,
+                        const TObj* array, TLen len) {
   if (array == NULL) {
     output.write(static_cast<int8_t>(-1));
   } else {
@@ -236,7 +263,8 @@ inline void writeObject(gemfire::DataOutput& output, const TObj* array,
 }
 
 template <typename TObj, typename TLen>
-inline void readObject(gemfire::DataInput& input, TObj*& array, TLen& len) {
+inline void readObject(apache::geode::client::DataInput& input, TObj*& array,
+                       TLen& len) {
   input.readArrayLen(&len);
   if (len > 0) {
     GF_NEW(array, TObj[len]);
@@ -251,8 +279,9 @@ inline void readObject(gemfire::DataInput& input, TObj*& array, TLen& len) {
 }
 
 template <typename TObj, typename TLen>
-inline uint32_t objectSize(const TObj* array, TLen len,
-                           gemfire::TypeHelper::yes_type isSerializable) {
+inline uint32_t objectSize(
+    const TObj* array, TLen len,
+    apache::geode::client::TypeHelper::yes_type isSerializable) {
   uint32_t size = 0;
   const TObj* endArray = array + len;
   while (array < endArray) {
@@ -266,8 +295,9 @@ inline uint32_t objectSize(const TObj* array, TLen len,
 }
 
 template <typename TObj, typename TLen>
-inline uint32_t objectSize(const TObj* array, TLen len,
-                           gemfire::TypeHelper::no_type isNotSerializable) {
+inline uint32_t objectSize(
+    const TObj* array, TLen len,
+    apache::geode::client::TypeHelper::no_type isNotSerializable) {
   return (uint32_t)(sizeof(TObj) * len);
 }
 
@@ -279,7 +309,7 @@ inline uint32_t objectSize(const TObj* array, TLen len) {
 // For containers vector/hashmap/hashset
 
 template <typename TObj>
-inline void writeObject(gemfire::DataOutput& output,
+inline void writeObject(apache::geode::client::DataOutput& output,
                         const VectorT<TObj>& value) {
   int32_t len = (int32_t)value.size();
   output.writeArrayLen(len);
@@ -302,7 +332,8 @@ inline uint32_t objectSize(const _VectorOfCacheable& value) {
 }
 
 template <typename TObj>
-inline void readObject(gemfire::DataInput& input, VectorT<TObj>& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       VectorT<TObj>& value) {
   int32_t len;
   input.readArrayLen(&len);
   if (len >= 0) {
@@ -315,7 +346,7 @@ inline void readObject(gemfire::DataInput& input, VectorT<TObj>& value) {
 }
 
 template <typename TKey, typename TValue>
-inline void writeObject(gemfire::DataOutput& output,
+inline void writeObject(apache::geode::client::DataOutput& output,
                         const HashMapT<TKey, TValue>& value) {
   int32_t len = (int32_t)value.size();
   output.writeArrayLen(len);
@@ -343,7 +374,7 @@ inline uint32_t objectSize(const _HashMapOfCacheable& value) {
 }
 
 template <typename TKey, typename TValue>
-inline void readObject(gemfire::DataInput& input,
+inline void readObject(apache::geode::client::DataInput& input,
                        HashMapT<TKey, TValue>& value) {
   int32_t len;
   input.readArrayLen(&len);
@@ -359,7 +390,7 @@ inline void readObject(gemfire::DataInput& input,
 }
 
 template <typename TKey>
-inline void writeObject(gemfire::DataOutput& output,
+inline void writeObject(apache::geode::client::DataOutput& output,
                         const HashSetT<TKey>& value) {
   int32_t len = (int32_t)value.size();
   output.writeArrayLen(len);
@@ -382,7 +413,8 @@ inline uint32_t objectSize(const _HashSetOfCacheableKey& value) {
 }
 
 template <typename TKey>
-inline void readObject(gemfire::DataInput& input, HashSetT<TKey>& value) {
+inline void readObject(apache::geode::client::DataInput& input,
+                       HashSetT<TKey>& value) {
   int32_t len;
   input.readArrayLen(&len);
   if (len > 0) {
@@ -416,6 +448,8 @@ inline float zeroObject<float>() {
   return 0.0F;
 }
 }  // namespace serializer
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // _GEMFIRE_SERIALIZER_HPP_

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/SharedBase.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SharedBase.hpp b/src/cppcache/include/gfcpp/SharedBase.hpp
index b6c9b5f..cc9132a 100644
--- a/src/cppcache/include/gfcpp/SharedBase.hpp
+++ b/src/cppcache/include/gfcpp/SharedBase.hpp
@@ -25,7 +25,9 @@
 /** @file
 */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * @class SharedBase SharedBase.hpp
@@ -78,8 +80,10 @@ class CPPCACHE_EXPORT NullSharedBase : public SharedBase {
 
   friend class SharedBase;  // just to get rid of warning with gcc3.x
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
-#define NULLPTR gemfire::NullSharedBase::s_instancePtr
+#define NULLPTR ::apache::geode::client::NullSharedBase::s_instancePtr
 
 #endif  //#define _GEMFIRE_SHAREDBASE_HPP_

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/SharedPtr.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SharedPtr.hpp b/src/cppcache/include/gfcpp/SharedPtr.hpp
index 9525d8b..c83b2c5 100644
--- a/src/cppcache/include/gfcpp/SharedPtr.hpp
+++ b/src/cppcache/include/gfcpp/SharedPtr.hpp
@@ -27,13 +27,16 @@
 /** @file
 */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 #if GF_DEVEL_ASSERTS == 1
-#define GF_CHECK_NPE(x) \
-  if (x != NULL) {      \
-  } else                \
-    gemfire::SPEHelper::throwNullPointerException(typeid(*this).name())
+#define GF_CHECK_NPE(x)                                          \
+  if (x != NULL) {                                               \
+  } else                                                         \
+    apache::geode::client::SPEHelper::throwNullPointerException( \
+        typeid(*this).name())
 #else
 #define GF_CHECK_NPE(x)
 #endif
@@ -273,6 +276,8 @@ template <class TargetSP, class Other>
 bool instanceOf(const SharedPtr<Other>& other) {
   return (dynamic_cast<GF_UNWRAP_SP(TargetSP)*>(other.ptr()) != NULL);
 }
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/SharedPtrHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SharedPtrHelper.hpp b/src/cppcache/include/gfcpp/SharedPtrHelper.hpp
index 11a4db0..8ab568f 100644
--- a/src/cppcache/include/gfcpp/SharedPtrHelper.hpp
+++ b/src/cppcache/include/gfcpp/SharedPtrHelper.hpp
@@ -22,7 +22,9 @@
 #include "TypeHelper.hpp"
 #include <typeinfo>
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class SharedBase;
 
@@ -39,14 +41,16 @@ class CPPCACHE_EXPORT SPEHelper {
 /* Helper function template for type conversion.
  */
 template <class Target, class Src>
-Target* getTargetHelper(Src* ptr, gemfire::TypeHelper::yes_type yes) {
+Target* getTargetHelper(Src* ptr,
+                        apache::geode::client::TypeHelper::yes_type yes) {
   return ptr;
 }
 
 /* Helper function template for type conversion.
  */
 template <class Target, class Src>
-Target* getTargetHelper(Src* ptr, gemfire::TypeHelper::no_type no) {
+Target* getTargetHelper(Src* ptr,
+                        apache::geode::client::TypeHelper::no_type no) {
   Target* tptr = dynamic_cast<Target*>(ptr);
   if (tptr) {
     return tptr;
@@ -70,6 +74,8 @@ template <class Src>
 SharedBase* getSB(Src* ptr) {
   return getTarget<SharedBase>(ptr);
 }
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/Struct.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Struct.hpp b/src/cppcache/include/gfcpp/Struct.hpp
index 3861d90..1aed4e2 100644
--- a/src/cppcache/include/gfcpp/Struct.hpp
+++ b/src/cppcache/include/gfcpp/Struct.hpp
@@ -30,7 +30,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class StructSet;
 
@@ -151,7 +153,8 @@ class CPPCACHE_EXPORT Struct : public Serializable {
 
   int32_t m_lastAccessIndex;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_STRUCT_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/StructSet.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/StructSet.hpp b/src/cppcache/include/gfcpp/StructSet.hpp
index c838271..128a6ad 100644
--- a/src/cppcache/include/gfcpp/StructSet.hpp
+++ b/src/cppcache/include/gfcpp/StructSet.hpp
@@ -29,7 +29,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 /**
  * @class StructSet StructSet.hpp
  *
@@ -93,7 +95,8 @@ class CPPCACHE_EXPORT StructSet : public CqResults {
    */
   virtual ~StructSet(){};
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_STRUCTSET_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/SystemProperties.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SystemProperties.hpp b/src/cppcache/include/gfcpp/SystemProperties.hpp
index d608af3..9c81d2a 100644
--- a/src/cppcache/include/gfcpp/SystemProperties.hpp
+++ b/src/cppcache/include/gfcpp/SystemProperties.hpp
@@ -25,7 +25,9 @@
 /** @file
 */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
  * The SystemProperties class
@@ -501,7 +503,8 @@ class CPPCACHE_EXPORT SystemProperties {
 
   friend class DistributedSystemImpl;
 };
-
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/TransactionId.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/TransactionId.hpp b/src/cppcache/include/gfcpp/TransactionId.hpp
index d49d13a..c329010 100644
--- a/src/cppcache/include/gfcpp/TransactionId.hpp
+++ b/src/cppcache/include/gfcpp/TransactionId.hpp
@@ -26,18 +26,22 @@
 
 #include "SharedBase.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /** The TransactionId interface is a "marker" interface that
 * represents a unique GemFire transaction.
 * @see Cache#getCacheTransactionManager
 * @see CacheTransactionManager#getTransactionId
 */
-class CPPCACHE_EXPORT TransactionId : public gemfire::SharedBase {
+class CPPCACHE_EXPORT TransactionId : public apache::geode::client::SharedBase {
  protected:
   TransactionId();
   virtual ~TransactionId();
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif /* TRANSACTIONID_H_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/TypeHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/TypeHelper.hpp b/src/cppcache/include/gfcpp/TypeHelper.hpp
index 56d0ccb..41a98a3 100644
--- a/src/cppcache/include/gfcpp/TypeHelper.hpp
+++ b/src/cppcache/include/gfcpp/TypeHelper.hpp
@@ -24,7 +24,9 @@
 
 #include "gfcpp_globals.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 // Forward declaration of SharedPtr<T>
 template <typename Target>
 class SharedPtr;
@@ -117,28 +119,34 @@ struct UnwrapSharedPtr<SharedArrayPtr<T, ID> > {
   typedef CacheableArrayType<T, ID> type;
 };
 }  // namespace TypeHelper
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 /** @brief Macro to unwrap the type <code>T</code> inside SharedPtr. */
-#define GF_UNWRAP_SP(T) typename gemfire::TypeHelper::UnwrapSharedPtr<T>::type
+#define GF_UNWRAP_SP(T) \
+  typename apache::geode::client::TypeHelper::UnwrapSharedPtr<T>::type
 
 /**
  * @brief Macro to determine if the type <code>T</code> is derived from
  *        <code>Serializable</code>.
  */
-#define GF_TYPE_IS_SERIALIZABLE(T) \
-  gemfire::TypeHelper::SuperSubclass<gemfire::Serializable, T>::result
+#define GF_TYPE_IS_SERIALIZABLE(T)                  \
+  apache::geode::client::TypeHelper::SuperSubclass< \
+      apache::geode::client::Serializable, T>::result
 
 /**
  * @brief Macro that returns <code>yes_type</code> if the type <code>T</code> is
  *        derived from <code>Serializable</code> and <code>no_type</code>
  *        otherwise. Useful for overloaded template functions.
  */
-#define GF_TYPE_IS_SERIALIZABLE_TYPE(T) \
-  gemfire::TypeHelper::YesNoType<GF_TYPE_IS_SERIALIZABLE(T)>::value
-
-#define GF_SRC_IS_TARGET_TYPE(TARGET, SRC) \
-  gemfire::TypeHelper::YesNoType<          \
-      gemfire::TypeHelper::SuperSubclass<TARGET, SRC>::result>::value
+#define GF_TYPE_IS_SERIALIZABLE_TYPE(T)                                 \
+  apache::geode::client::TypeHelper::YesNoType<GF_TYPE_IS_SERIALIZABLE( \
+      T)>::value
+
+#define GF_SRC_IS_TARGET_TYPE(TARGET, SRC)                     \
+  apache::geode::client::TypeHelper::YesNoType<                \
+      apache::geode::client::TypeHelper::SuperSubclass<TARGET, \
+                                                       SRC>::result>::value
 
 #endif  // _GEMFIRE_TYPEHELPER_HPP_

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/UserData.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/UserData.hpp b/src/cppcache/include/gfcpp/UserData.hpp
index a9e6fdf..e6526e4 100644
--- a/src/cppcache/include/gfcpp/UserData.hpp
+++ b/src/cppcache/include/gfcpp/UserData.hpp
@@ -24,10 +24,14 @@
 #include "gfcpp_globals.hpp"
 #include "Serializable.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 typedef Serializable UserData;
 typedef SharedPtr<UserData> UserDataPtr;
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif  // ifndef __GEMFIRE_USERDATA_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp b/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
index 30be621..bc0f9de 100644
--- a/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
+++ b/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
@@ -20,7 +20,9 @@
 #include "Serializable.hpp"
 #include "CacheableString.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 class UserFunctionExecutionException;
 typedef SharedPtr<UserFunctionExecutionException>
     UserFunctionExecutionExceptionPtr;
@@ -113,5 +115,7 @@ class UserFunctionExecutionException : public Serializable {
 
   CacheableStringPtr m_message;  // error message
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/VectorOfSharedBase.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/VectorOfSharedBase.hpp b/src/cppcache/include/gfcpp/VectorOfSharedBase.hpp
index 8eb4d23..0d014a4 100644
--- a/src/cppcache/include/gfcpp/VectorOfSharedBase.hpp
+++ b/src/cppcache/include/gfcpp/VectorOfSharedBase.hpp
@@ -29,17 +29,19 @@
 /** @file
 */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 #ifdef BUILD_CPPCACHE
-typedef std::vector<gemfire::SharedBasePtr> VofSBP;
+typedef std::vector<apache::geode::client::SharedBasePtr> VofSBP;
 typedef VofSBP::const_iterator VofSBPIterator;
 #else
 class VofSBP;
 class VofSBPIterator;
 #endif
 
-/** Represents a vector of <code>gemfire::SharedBasePtr</code>
+/** Represents a vector of <code>apache::geode::client::SharedBasePtr</code>
 */
 class CPPCACHE_EXPORT VectorOfSharedBase {
  private:
@@ -163,6 +165,8 @@ class CPPCACHE_EXPORT VectorOfSharedBase {
   */
   void erase(int32_t index);
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/VectorT.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/VectorT.hpp b/src/cppcache/include/gfcpp/VectorT.hpp
index e2149ba..acdf05c 100644
--- a/src/cppcache/include/gfcpp/VectorT.hpp
+++ b/src/cppcache/include/gfcpp/VectorT.hpp
@@ -27,7 +27,9 @@
 /** @file
 */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /** Vector template type class */
 template <class PTR_TYPE>
@@ -250,6 +252,8 @@ class CPPCACHE_EXPORT VectorOfCacheableKey : public _VectorOfCacheableKey,
 
 typedef SharedPtr<VectorOfCacheable> VectorOfCacheablePtr;
 typedef SharedPtr<VectorOfCacheableKey> VectorOfCacheableKeyPtr;
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/WritablePdxInstance.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/WritablePdxInstance.hpp b/src/cppcache/include/gfcpp/WritablePdxInstance.hpp
index d86de2c..437054e 100644
--- a/src/cppcache/include/gfcpp/WritablePdxInstance.hpp
+++ b/src/cppcache/include/gfcpp/WritablePdxInstance.hpp
@@ -23,7 +23,9 @@
 
 #include "PdxInstance.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 /**
 * WritablePdxInstance is a {@link PdxInstance} that also supports field
@@ -529,6 +531,8 @@ class CPPCACHE_EXPORT WritablePdxInstance : public PdxInstance {
   WritablePdxInstance(const WritablePdxInstance& other);
   void operator=(const WritablePdxInstance& other);
 };
-}  // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #endif /* __WRITABLE_PDXINSTANCE_HPP_ */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/gf_base.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/gf_base.hpp b/src/cppcache/include/gfcpp/gf_base.hpp
index 0a69d17..ec51055 100644
--- a/src/cppcache/include/gfcpp/gf_base.hpp
+++ b/src/cppcache/include/gfcpp/gf_base.hpp
@@ -198,7 +198,8 @@ typedef uint64_t uint64; /**< unsigned 64 bit integer */
  * C++ statistics API classes.
  */
 
-/**@namespace gemfire::TypeHelper This namespace contains type traits helper
+/**@namespace apache::geode::client::TypeHelper This namespace contains type
+ * traits helper
  * structs/classes to determine type information at compile time
  * using typename. Useful for templates in particular.
  */
@@ -311,9 +312,13 @@ typedef enum {
 typedef void *(*pNew)(size_t);
 typedef void (*pDelete)(void *);
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 extern void setDefaultNewAndDelete();
-}
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 void *operator new(size_t size);
 void operator delete(void *p);
@@ -328,7 +333,7 @@ void operator delete[](void *p);
     try {                                                               \
       v = new stmt;                                                     \
     } catch (const std::bad_alloc &) {                                  \
-      throw gemfire::OutOfMemoryException(                              \
+      throw apache::geode::client::OutOfMemoryException(                \
           "Out of Memory while executing \"" #v " = new " #stmt ";\""); \
     }                                                                   \
   }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/gf_types.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/gf_types.hpp b/src/cppcache/include/gfcpp/gf_types.hpp
index 80e9ce4..255aa42 100644
--- a/src/cppcache/include/gfcpp/gf_types.hpp
+++ b/src/cppcache/include/gfcpp/gf_types.hpp
@@ -23,7 +23,9 @@
  * @file
  */
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 class CacheFactory;
 
@@ -99,6 +101,7 @@ _GF_PTR_DEF_(CacheableEnum, CacheableEnumPtr);
 _GF_PTR_DEF_(CqStatusListener, CqStatusListenerPtr);
 _GF_PTR_DEF_(InternalCacheTransactionManager2PC,
              InternalCacheTransactionManager2PCPtr);
-
-};      // namespace gemfire
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 #endif  // ifndef __GEMFIRE_GF_TYPEDEF_H__

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/gfcpp_globals.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/gfcpp_globals.hpp b/src/cppcache/include/gfcpp/gfcpp_globals.hpp
index 7f043cb..1f1cadf 100644
--- a/src/cppcache/include/gfcpp/gfcpp_globals.hpp
+++ b/src/cppcache/include/gfcpp/gfcpp_globals.hpp
@@ -96,14 +96,19 @@
 
 #include "gf_base.hpp"
 
-namespace gemfire {
+namespace apache {
+namespace geode {
+namespace client {
 
 extern void CPPCACHE_EXPORT millisleep(uint32_t millis);
 
 #ifdef _WIN32
 extern void CPPCACHE_EXPORT setNewAndDelete(pNew, pDelete);
 #endif
-}  // namespace gemfire
+
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
 
 #include "Log.hpp"
 #include "Assert.hpp"

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp b/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp
index da9ce1e..3e1dab8 100644
--- a/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp
+++ b/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp
@@ -20,7 +20,7 @@
 
 #include <gfcpp/gfcpp_globals.hpp>
 
-using namespace gemfire;
+using namespace apache::geode::client;
 
 /** @file
 */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/include/gfcpp/statistics/StatisticsType.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/statistics/StatisticsType.hpp b/src/cppcache/include/gfcpp/statistics/StatisticsType.hpp
index 2f2164e..ee32210 100644
--- a/src/cppcache/include/gfcpp/statistics/StatisticsType.hpp
+++ b/src/cppcache/include/gfcpp/statistics/StatisticsType.hpp
@@ -19,7 +19,7 @@
 #include <gfcpp/gfcpp_globals.hpp>
 #include <gfcpp/statistics/StatisticDescriptor.hpp>
 
-using namespace gemfire;
+using namespace apache::geode::client;
 
 /** @file
 */

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/integration-test/BBNamingContext.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/BBNamingContext.cpp b/src/cppcache/integration-test/BBNamingContext.cpp
index 7acab58..64d66ac 100644
--- a/src/cppcache/integration-test/BBNamingContext.cpp
+++ b/src/cppcache/integration-test/BBNamingContext.cpp
@@ -26,7 +26,7 @@
 
 #define ERR_MAX 10
 
-using namespace gemfire::testframework;
+using namespace apache::geode::client::testframework;
 
 static int hashcode(char* str) {
   if (str == NULL) {

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp b/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
index af07a7f..0d8ecc4 100644
--- a/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
+++ b/src/cppcache/integration-test/BuiltinCacheableWrappers.hpp
@@ -26,7 +26,7 @@ extern "C" {
 
 #include <ace/Date_Time.h>
 
-using namespace gemfire;
+using namespace apache::geode::client;
 
 namespace CacheableHelper {
 const uint32_t m_crc32Table[] = {
@@ -148,7 +148,7 @@ inline uint32_t crc32(const uint8_t* buffer, uint32_t bufLen) {
 template <typename TPRIM>
 inline uint32_t crc32(TPRIM value) {
   DataOutput output;
-  gemfire::serializer::writeObject(output, value);
+  apache::geode::client::serializer::writeObject(output, value);
   return crc32(output.getBuffer(), output.getBufferLength());
 }
 
@@ -156,7 +156,7 @@ template <typename TPRIM>
 inline uint32_t crc32Array(const TPRIM* arr, uint32_t len) {
   DataOutput output;
   for (uint32_t index = 0; index < len; index++) {
-    gemfire::serializer::writeObject(output, arr[index]);
+    apache::geode::client::serializer::writeObject(output, arr[index]);
   }
   return crc32(output.getBuffer(), output.getBufferLength());
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/integration-test/CacheHelper.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/CacheHelper.cpp b/src/cppcache/integration-test/CacheHelper.cpp
index 631bbe9..10f550f 100644
--- a/src/cppcache/integration-test/CacheHelper.cpp
+++ b/src/cppcache/integration-test/CacheHelper.cpp
@@ -56,7 +56,7 @@
 #define PATH_SEP "/"
 #endif
 
-using namespace gemfire;
+using namespace apache::geode::client;
 
 extern ClientCleanup gClientCleanup;
 

http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/cppcache/integration-test/CacheHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/CacheHelper.hpp b/src/cppcache/integration-test/CacheHelper.hpp
index 90395e3..eceb6a2 100644
--- a/src/cppcache/integration-test/CacheHelper.hpp
+++ b/src/cppcache/integration-test/CacheHelper.hpp
@@ -38,7 +38,7 @@
 #define ROOT_SCOPE LOCAL
 #endif
 
-using namespace gemfire;
+using namespace apache::geode::client;
 
 class CacheHelper {
  public:


Mime
View raw message