http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/ManagedResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedResultCollector.cpp 
b/src/clicache/src/impl/ManagedResultCollector.cpp
index a1fda0a..d01c38b 100644
--- a/src/clicache/src/impl/ManagedResultCollector.cpp
+++ b/src/clicache/src/impl/ManagedResultCollector.cpp
@@ -45,9 +45,9 @@ namespace apache
         try
         {
           String^ mg_assemblyPath =
-            Apache::Geode::Client::Generic::ManagedString::Get(assemblyPath);
+            Apache::Geode::Client::ManagedString::Get(assemblyPath);
           String^ mg_factoryFunctionName =
-            
Apache::Geode::Client::Generic::ManagedString::Get(factoryFunctionName);
+            Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
           String^ mg_typeName = nullptr;
           Int32 dotIndx = -1;
 
@@ -85,18 +85,18 @@ namespace apache
               BindingFlags::Public | BindingFlags::Static | 
BindingFlags::IgnoreCase);
             if (mInfo != nullptr)
             {
-              //Apache::Geode::Client::Generic::ResultCollector<Object^>^ 
managedptr = nullptr;
+              //Apache::Geode::Client::ResultCollector<Object^>^ managedptr = 
nullptr;
               Object^ userptr = nullptr;
               try
               {
                 throw 
apache::geode::client::UnsupportedOperationException("Not supported");
-                /*managedptr = 
dynamic_cast<Apache::Geode::Client::Generic::ResultCollector<Object^>^>(
+                /*managedptr = 
dynamic_cast<Apache::Geode::Client::ResultCollector<Object^>^>(
                   mInfo->Invoke( typeInst, nullptr ) );*/
                 userptr = mInfo->Invoke(typeInst, nullptr);
               }
               catch (System::Exception^ ex)
               {
-                Apache::Geode::Client::Generic::Log::Debug("{0}: {1}", 
ex->GetType()->Name, ex->Message);
+                Apache::Geode::Client::Log::Debug("{0}: {1}", 
ex->GetType()->Name, ex->Message);
                 userptr = nullptr;
               }
               if (userptr == nullptr)
@@ -109,7 +109,7 @@ namespace apache
                 throw 
apache::geode::client::IllegalArgumentException(ex_str.c_str());
               }
               //TODO::need to pass proper pointer here
-              return new 
ManagedResultCollectorGeneric(/*(Apache::Geode::Client::Generic::ResultCollector<Object^>^)
 managedptr*/nullptr);
+              return new 
ManagedResultCollectorGeneric(/*(Apache::Geode::Client::ResultCollector<Object^>^)
 managedptr*/nullptr);
             }
             else
             {
@@ -123,7 +123,7 @@ namespace apache
           }
           else
           {
-            Apache::Geode::Client::Generic::ManagedString 
typeName(mg_typeName);
+            Apache::Geode::Client::ManagedString typeName(mg_typeName);
             std::string ex_str = "ManagedResultCollector: Could not load type 
[";
             ex_str += typeName.CharPtr;
             ex_str += "] in assembly: ";
@@ -137,7 +137,7 @@ namespace apache
         }
         catch (System::Exception^ ex)
         {
-          Apache::Geode::Client::Generic::ManagedString 
mg_exStr(ex->ToString());
+          Apache::Geode::Client::ManagedString mg_exStr(ex->ToString());
           std::string ex_str = "ManagedResultCollector: Got an exception while 
"
             "loading managed library: ";
           ex_str += mg_exStr.CharPtr;
@@ -150,15 +150,15 @@ namespace apache
       {
         try {
           //Apache::Geode::Client::IGFSerializable^ res = 
SafeUMSerializableConvertGeneric(result.ptr());
-          Object^ rs = 
Apache::Geode::Client::Generic::Serializable::GetManagedValueGeneric<Object^>(result);
+          Object^ rs = 
Apache::Geode::Client::Serializable::GetManagedValueGeneric<Object^>(result);
           m_managedptr->AddResult(rs);
           //m_managedptr->AddResult( SafeUMSerializableConvert( result.ptr( ) 
) );
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::ManagedString 
mg_exStr(ex->ToString());
+          Apache::Geode::Client::ManagedString mg_exStr(ex->ToString());
           std::string ex_str = "ManagedResultCollector: Got an exception in"
             "addResult: ";
           ex_str += mg_exStr.CharPtr;
@@ -173,18 +173,18 @@ namespace apache
           //apache::geode::client::CacheableVectorPtr rsptr = 
apache::geode::client::CacheableVector::create();
           //for( int index = 0; index < rs->Length; index++ )
           //{
-          //  //apache::geode::client::CacheablePtr 
valueptr(Apache::Geode::Client::Generic::Serializable::GetUnmanagedValueGeneric<IGFSerializable^>(rs[
 index]));
+          //  //apache::geode::client::CacheablePtr 
valueptr(Apache::Geode::Client::Serializable::GetUnmanagedValueGeneric<IGFSerializable^>(rs[
 index]));
           //  apache::geode::client::CacheablePtr valueptr 
(SafeMSerializableConvert(rs[ index]));
           //  rsptr->push_back(valueptr);
           //}
           //return rsptr;
           throw apache::geode::client::IllegalStateException("This should not 
be get callled.");
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::ManagedString 
mg_exStr(ex->ToString());
+          Apache::Geode::Client::ManagedString mg_exStr(ex->ToString());
           std::string ex_str = "ManagedResultCollector: Got an exception in"
             "getResult: ";
           ex_str += mg_exStr.CharPtr;
@@ -197,11 +197,11 @@ namespace apache
         try {
           m_managedptr->EndResults();
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::ManagedString 
mg_exStr(ex->ToString());
+          Apache::Geode::Client::ManagedString mg_exStr(ex->ToString());
           std::string ex_str = "ManagedResultCollector: Got an exception in"
             "endResults: ";
           ex_str += mg_exStr.CharPtr;
@@ -213,11 +213,11 @@ namespace apache
         try {
           m_managedptr->ClearResults(/*false*/);
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::ManagedString 
mg_exStr(ex->ToString());
+          Apache::Geode::Client::ManagedString mg_exStr(ex->ToString());
           std::string ex_str = "ManagedResultCollector: Got an exception in"
             "clearResults: ";
           ex_str += mg_exStr.CharPtr;

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/ManagedResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedResultCollector.hpp 
b/src/clicache/src/impl/ManagedResultCollector.hpp
index 50633cc..7e7b375 100644
--- a/src/clicache/src/impl/ManagedResultCollector.hpp
+++ b/src/clicache/src/impl/ManagedResultCollector.hpp
@@ -47,7 +47,7 @@ namespace apache {
         /// <param name="userptr">
         /// The managed object.
         /// </param>
-        inline 
ManagedResultCollectorGeneric(Apache::Geode::Client::Generic::ResultCollectorG^ 
userptr)
+        inline 
ManagedResultCollectorGeneric(Apache::Geode::Client::ResultCollectorG^ userptr)
           : m_managedptr(userptr) { }
 
         /// <summary>
@@ -82,7 +82,7 @@ namespace apache {
         /// <summary>
         /// Returns the wrapped managed object reference.
         /// </summary>
-        inline Apache::Geode::Client::Generic::ResultCollectorG^ ptr() const
+        inline Apache::Geode::Client::ResultCollectorG^ ptr() const
         {
           return m_managedptr;
         }
@@ -97,7 +97,7 @@ namespace apache {
         /// to be called which is not what is desired when this object is 
destroyed. Normally this
         /// managed object may be created by the user and will be handled 
automatically by the GC.
         /// </summary>
-        gcroot<Apache::Geode::Client::Generic::ResultCollectorG^> m_managedptr;
+        gcroot<Apache::Geode::Client::ResultCollectorG^> m_managedptr;
         //Apache::Geode::Client::IResultCollector^ m_managedptr;
         //gcroot<Object^> m_userptr;
       };

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/ManagedString.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedString.hpp 
b/src/clicache/src/impl/ManagedString.hpp
index 8bab75d..b52b7e9 100644
--- a/src/clicache/src/impl/ManagedString.hpp
+++ b/src/clicache/src/impl/ManagedString.hpp
@@ -34,7 +34,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic{
 
     ref class ManagedString sealed
     {
@@ -98,6 +97,7 @@ namespace Generic{
         }
       }
     };
-       }}
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/ManagedTransactionListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionListener.cpp 
b/src/clicache/src/impl/ManagedTransactionListener.cpp
index ca156c5..83ee192 100644
--- a/src/clicache/src/impl/ManagedTransactionListener.cpp
+++ b/src/clicache/src/impl/ManagedTransactionListener.cpp
@@ -43,9 +43,9 @@ namespace apache
         try
         {
           String^ mg_assemblyPath =
-            Apache::Geode::Client::Generic::ManagedString::Get( assemblyPath );
+            Apache::Geode::Client::ManagedString::Get( assemblyPath );
           String^ mg_factoryFunctionName =
-            Apache::Geode::Client::Generic::ManagedString::Get( 
factoryFunctionName );
+            Apache::Geode::Client::ManagedString::Get( factoryFunctionName );
           String^ mg_typeName = nullptr;
 
           String^ mg_genericKey = nullptr;
@@ -99,7 +99,7 @@ namespace apache
           mg_genericVal = mg_genericVal->Trim();
           mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx 
+ 1 );
 
-          Apache::Geode::Client::Generic::Log::Fine("Attempting to instantiate 
a [{0}<{1}, {2}>] via the [{3}] factory method.",
+          Apache::Geode::Client::Log::Fine("Attempting to instantiate a 
[{0}<{1}, {2}>] via the [{3}] factory method.",
             mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
 
           typeBuilder->Append("`2");
@@ -121,7 +121,7 @@ namespace apache
             throw apache::geode::client::IllegalArgumentException( 
ex_str.c_str( ) );
           }
 
-          Apache::Geode::Client::Generic::Log::Debug("Loading type: [{0}]", 
mg_typeName);
+          Apache::Geode::Client::Log::Debug("Loading type: [{0}]", 
mg_typeName);
 
           Type^ typeInst = assmb->GetType(mg_typeName, false, true);
 
@@ -138,7 +138,7 @@ namespace apache
             }
 
             typeInst = typeInst->MakeGenericType(types);
-            Apache::Geode::Client::Generic::Log::Info("Loading function: 
[{0}]", mg_factoryFunctionName);
+            Apache::Geode::Client::Log::Info("Loading function: [{0}]", 
mg_factoryFunctionName);
 
             MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName,
               BindingFlags::Public | BindingFlags::Static | 
BindingFlags::IgnoreCase );
@@ -152,7 +152,7 @@ namespace apache
               }
               catch (System::Exception^ ex)
               {
-                Apache::Geode::Client::Generic::Log::Debug("{0}: {1}", 
ex->GetType()->Name, ex->Message);
+                Apache::Geode::Client::Log::Debug("{0}: {1}", 
ex->GetType()->Name, ex->Message);
                 userptr = nullptr;
               }
               if (userptr == nullptr)
@@ -178,7 +178,7 @@ namespace apache
           }
           else
           {
-            Apache::Geode::Client::Generic::ManagedString typeName( 
mg_typeName );
+            Apache::Geode::Client::ManagedString typeName( mg_typeName );
             std::string ex_str = "ManagedTransactionListenerGeneric: Could not 
load type [";
             ex_str += typeName.CharPtr;
             ex_str += "] in assembly: ";
@@ -192,7 +192,7 @@ namespace apache
         }
         catch (System::Exception^ ex)
         {
-          Apache::Geode::Client::Generic::ManagedString mg_exStr( 
ex->ToString( ) );
+          Apache::Geode::Client::ManagedString mg_exStr( ex->ToString( ) );
           std::string ex_str = "ManagedTransactionListenerGeneric: Got an 
exception while "
             "loading managed library: ";
           ex_str += mg_exStr.CharPtr;
@@ -203,17 +203,17 @@ namespace apache
       void 
ManagedTransactionListenerGeneric::afterCommit(apache::geode::client::TransactionEventPtr&
 te )
       {
         try {
-          
Apache::Geode::Client::Generic::Log::Error("ManagedTransactionListenerGeneric::afterCommit
 in" );
+          
Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit
 in" );
           Apache::Geode::Client::TransactionEvent  mevent( te.ptr() );
           m_managedptr->AfterCommit( %mevent );
-          
Apache::Geode::Client::Generic::Log::Error("ManagedTransactionListenerGeneric::afterCommit
 in" );
+          
Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit
 in" );
 
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
       void 
ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr&
 te )
@@ -222,11 +222,11 @@ namespace apache
           Apache::Geode::Client::TransactionEvent mevent( te.ptr()  );
           m_managedptr->AfterFailedCommit( %mevent );
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
       void 
ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr&
 te )
@@ -235,11 +235,11 @@ namespace apache
           Apache::Geode::Client::TransactionEvent mevent( te.ptr()  );
           m_managedptr->AfterRollback( %mevent );
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
       void ManagedTransactionListenerGeneric::close()
@@ -247,11 +247,11 @@ namespace apache
         try {
           m_managedptr->Close();
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/ManagedTransactionWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionWriter.cpp 
b/src/clicache/src/impl/ManagedTransactionWriter.cpp
index 47ab619..c3f09a9 100644
--- a/src/clicache/src/impl/ManagedTransactionWriter.cpp
+++ b/src/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -29,7 +29,7 @@ using namespace System;
 using namespace System::Text;
 using namespace System::Reflection;
 
-//using namespace Apache::Geode::Client::Generic;
+//using namespace Apache::Geode::Client;
 
 namespace apache
 {
@@ -44,9 +44,9 @@ namespace apache
         try
         {
           String^ mg_assemblyPath =
-            Apache::Geode::Client::Generic::ManagedString::Get( assemblyPath );
+            Apache::Geode::Client::ManagedString::Get( assemblyPath );
           String^ mg_factoryFunctionName =
-            Apache::Geode::Client::Generic::ManagedString::Get( 
factoryFunctionName );
+            Apache::Geode::Client::ManagedString::Get( factoryFunctionName );
           String^ mg_typeName = nullptr;
 
           String^ mg_genericKey = nullptr;
@@ -100,7 +100,7 @@ namespace apache
           mg_genericVal = mg_genericVal->Trim();
           mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx 
+ 1 );
 
-          Apache::Geode::Client::Generic::Log::Fine("Attempting to instantiate 
a [{0}<{1}, {2}>] via the [{3}] factory method.",
+          Apache::Geode::Client::Log::Fine("Attempting to instantiate a 
[{0}<{1}, {2}>] via the [{3}] factory method.",
             mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
 
           typeBuilder->Append("`2");
@@ -122,7 +122,7 @@ namespace apache
             throw apache::geode::client::IllegalArgumentException( 
ex_str.c_str( ) );
           }
 
-          Apache::Geode::Client::Generic::Log::Debug("Loading type: [{0}]", 
mg_typeName);
+          Apache::Geode::Client::Log::Debug("Loading type: [{0}]", 
mg_typeName);
 
           Type^ typeInst = assmb->GetType(mg_typeName, false, true);
 
@@ -139,7 +139,7 @@ namespace apache
             }
 
             typeInst = typeInst->MakeGenericType(types);
-            Apache::Geode::Client::Generic::Log::Info("Loading function: 
[{0}]", mg_factoryFunctionName);
+            Apache::Geode::Client::Log::Info("Loading function: [{0}]", 
mg_factoryFunctionName);
 
             MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName,
               BindingFlags::Public | BindingFlags::Static | 
BindingFlags::IgnoreCase );
@@ -153,7 +153,7 @@ namespace apache
               }
               catch (System::Exception^ ex)
               {
-                Apache::Geode::Client::Generic::Log::Debug("{0}: {1}", 
ex->GetType()->Name, ex->Message);
+                Apache::Geode::Client::Log::Debug("{0}: {1}", 
ex->GetType()->Name, ex->Message);
                 userptr = nullptr;
               }
               if (userptr == nullptr)
@@ -179,7 +179,7 @@ namespace apache
           }
           else
           {
-            Apache::Geode::Client::Generic::ManagedString typeName( 
mg_typeName );
+            Apache::Geode::Client::ManagedString typeName( mg_typeName );
             std::string ex_str = "ManagedTransactionWriterGeneric: Could not 
load type [";
             ex_str += typeName.CharPtr;
             ex_str += "] in assembly: ";
@@ -193,7 +193,7 @@ namespace apache
         }
         catch (System::Exception^ ex)
         {
-          Apache::Geode::Client::Generic::ManagedString mg_exStr( 
ex->ToString( ) );
+          Apache::Geode::Client::ManagedString mg_exStr( ex->ToString( ) );
           std::string ex_str = "ManagedTransactionWriterGeneric: Got an 
exception while "
             "loading managed library: ";
           ex_str += mg_exStr.CharPtr;
@@ -207,11 +207,11 @@ namespace apache
           Apache::Geode::Client::TransactionEvent  mevent( te.ptr() );
           m_managedptr->BeforeCommit( %mevent );
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/ManagedVisitor.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedVisitor.cpp 
b/src/clicache/src/impl/ManagedVisitor.cpp
index 79f8c1f..c67cf1e 100644
--- a/src/clicache/src/impl/ManagedVisitor.cpp
+++ b/src/clicache/src/impl/ManagedVisitor.cpp
@@ -32,12 +32,12 @@ namespace apache
 
       void ManagedVisitorGeneric::visit(CacheableKeyPtr& key, CacheablePtr& 
value)
       {
-        using namespace Apache::Geode::Client::Generic;
+        using namespace Apache::Geode::Client;
         try {
           ICacheableKey^ 
mg_key(SafeGenericUMKeyConvert<ICacheableKey^>(key.ptr()));
           IGFSerializable^ 
mg_value(SafeUMSerializableConvertGeneric(value.ptr()));
 
-          m_visitor->Invoke(mg_key, 
(Apache::Geode::Client::Generic::IGFSerializable^)mg_value);
+          m_visitor->Invoke(mg_key, 
(Apache::Geode::Client::IGFSerializable^)mg_value);
         }
         catch (GemFireException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/MemoryPressureHandler.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/MemoryPressureHandler.cpp 
b/src/clicache/src/impl/MemoryPressureHandler.cpp
index ae4bc2a..52d192f 100644
--- a/src/clicache/src/impl/MemoryPressureHandler.cpp
+++ b/src/clicache/src/impl/MemoryPressureHandler.cpp
@@ -27,8 +27,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       int64_t g_prevUnmanagedSize = 0;
 
       int MemoryPressureHandler::handle_timeout( const ACE_Time_Value&
@@ -70,8 +69,8 @@ namespace Generic
           ACE_Reactor_Mask close_mask )
       {
         return 0;
-      }
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
  } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/MemoryPressureHandler.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/MemoryPressureHandler.hpp 
b/src/clicache/src/impl/MemoryPressureHandler.hpp
index 3276133..b270fe6 100644
--- a/src/clicache/src/impl/MemoryPressureHandler.hpp
+++ b/src/clicache/src/impl/MemoryPressureHandler.hpp
@@ -26,7 +26,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic {
 
       class MemoryPressureHandler
         : public ACE_Event_Handler
@@ -37,7 +36,7 @@ namespace Generic {
 
           int handle_close( ACE_HANDLE handle, ACE_Reactor_Mask close_mask );
       };
-    }
-  }
-}
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/NativeWrapper.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/NativeWrapper.hpp 
b/src/clicache/src/impl/NativeWrapper.hpp
index b9cc757..92632f6 100644
--- a/src/clicache/src/impl/NativeWrapper.hpp
+++ b/src/clicache/src/impl/NativeWrapper.hpp
@@ -29,8 +29,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       namespace Internal
       {
 
@@ -521,9 +520,9 @@ namespace Generic
           NTYPE* m_nativeptr;
           bool m_own;
         };
-      }
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
 

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PartitionResolver.hpp 
b/src/clicache/src/impl/PartitionResolver.hpp
index f18ac05..21f7fd5 100644
--- a/src/clicache/src/impl/PartitionResolver.hpp
+++ b/src/clicache/src/impl/PartitionResolver.hpp
@@ -33,8 +33,6 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
 
       public interface class IPartitionResolverProxy
       {
@@ -70,7 +68,7 @@ namespace Generic
             return mg_name.CharPtr;
           }
       };
-    }
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxFieldType.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxFieldType.cpp 
b/src/clicache/src/impl/PdxFieldType.cpp
index 57b3380..c47577d 100644
--- a/src/clicache/src/impl/PdxFieldType.cpp
+++ b/src/clicache/src/impl/PdxFieldType.cpp
@@ -27,8 +27,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         Int32 PdxFieldType::SequenceId::get()
@@ -183,10 +182,10 @@ namespace Generic
         
           default:
             return -1;
-           }
-        }
-      }
-                       }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
     }
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxFieldType.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxFieldType.hpp 
b/src/clicache/src/impl/PdxFieldType.hpp
index 5f2f22d..ea88ca7 100644
--- a/src/clicache/src/impl/PdxFieldType.hpp
+++ b/src/clicache/src/impl/PdxFieldType.hpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         public ref class PdxFieldType : IGFSerializable
@@ -144,8 +143,8 @@ namespace Generic
              return "PdxFieldName:" + m_fieldName + ", TypeId: " + m_typeId + 
", VarLenFieldIdx:" + m_varLenFieldIdx + ", sequenceid:" + m_sequenceId;
            }
         };
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxHelper.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxHelper.cpp 
b/src/clicache/src/impl/PdxHelper.cpp
index 0f23393..fd157de 100644
--- a/src/clicache/src/impl/PdxHelper.cpp
+++ b/src/clicache/src/impl/PdxHelper.cpp
@@ -38,8 +38,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
 
@@ -460,9 +459,9 @@ namespace Generic
             return ReadInt32(offsetPosition);
           }
           throw gcnew System::ArgumentException("Size should be 1,2 or 4 in 
PdxHelper::ReadInt.");
-        }
-                       }
-      }
-    }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxHelper.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxHelper.hpp 
b/src/clicache/src/impl/PdxHelper.hpp
index 819b780..c01438d 100644
--- a/src/clicache/src/impl/PdxHelper.hpp
+++ b/src/clicache/src/impl/PdxHelper.hpp
@@ -27,8 +27,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
                                ref class DataOutput;
       ref class DataInput;
       namespace Internal
@@ -69,8 +68,8 @@ namespace Generic
         private:
           static void CreateMergedType(PdxType^ localType, PdxType^ 
remoteType, DataInput^ dataInput);
         };
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp 
b/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
index 922ddc5..640477f 100644
--- a/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
+++ b/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
@@ -27,8 +27,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-                       { 
+
         namespace Internal
         {
           PdxInstanceFactoryImpl::PdxInstanceFactoryImpl(String^ className)
@@ -346,10 +345,10 @@ namespace Generic
             {
               throw gcnew IllegalStateException(
                 "Field: " + fieldName + " either already added into 
PdxInstanceFactory or it is null");
-            }
-          }
-        }       
-                       }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
     }
   }
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxInstanceFactoryImpl.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceFactoryImpl.hpp 
b/src/clicache/src/impl/PdxInstanceFactoryImpl.hpp
index 242fcf2..91b38d1 100644
--- a/src/clicache/src/impl/PdxInstanceFactoryImpl.hpp
+++ b/src/clicache/src/impl/PdxInstanceFactoryImpl.hpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-                       {     
+
         namespace Internal
         {
         ref class PdxInstanceFactoryImpl : IPdxInstanceFactory
@@ -387,8 +386,8 @@ namespace Generic
    
 
                                };
-        }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxInstanceImpl.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.cpp 
b/src/clicache/src/impl/PdxInstanceImpl.cpp
index 4b3dc0a..869f343 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.cpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.cpp
@@ -36,8 +36,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-                       { 
+
         namespace Internal
         {
           //this is for PdxInstanceFactory
@@ -57,8 +56,8 @@ namespace Generic
             
             try
             {
-              Apache::Geode::Client::Generic::DataOutput mg_output( 
&(*output), true );
-              
Apache::Geode::Client::Generic::Internal::PdxHelper::SerializePdx(%mg_output, 
this);
+              Apache::Geode::Client::DataOutput mg_output( &(*output), true );
+              
Apache::Geode::Client::Internal::PdxHelper::SerializePdx(%mg_output, this);
             }
             finally
             {
@@ -1432,11 +1431,10 @@ namespace Generic
               writer->WriteObject(fieldName, value);
                //throw gcnew IllegalStateException("ReadField unable to 
de-serialize  " 
                                                                //              
                                                                                
                                        + fieldName + " of " + type); 
-            }
-          }
-          }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-        }
                        }
     }
   }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxInstanceImpl.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.hpp 
b/src/clicache/src/impl/PdxInstanceImpl.hpp
index 51ccfef..2d4152e 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.hpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.hpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-                       {     
+
         namespace Internal
         {
         ref class PdxType;
@@ -285,8 +284,8 @@ namespace Generic
           virtual void FromData( IPdxReader^ reader );          
 
                                };
-        }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxLocalReader.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxLocalReader.cpp 
b/src/clicache/src/impl/PdxLocalReader.cpp
index 86670ba..c563b95 100644
--- a/src/clicache/src/impl/PdxLocalReader.cpp
+++ b/src/clicache/src/impl/PdxLocalReader.cpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         void PdxLocalReader::initialize()
@@ -414,11 +413,10 @@ namespace Generic
               return this->ReadObject(fieldName);
                //throw gcnew IllegalStateException("ReadField unable to 
de-serialize  " 
                                                                //              
                                                                                
                                        + fieldName + " of " + type); 
-            }
-          }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-                               }
-      }
     }
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxLocalReader.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxLocalReader.hpp 
b/src/clicache/src/impl/PdxLocalReader.hpp
index 4adf330..b8c10e8 100644
--- a/src/clicache/src/impl/PdxLocalReader.hpp
+++ b/src/clicache/src/impl/PdxLocalReader.hpp
@@ -32,8 +32,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       ref class DataInput;
       namespace Internal
       {
@@ -305,8 +304,8 @@ namespace Generic
           /// </summary>
           virtual Object^ ReadField(String^ fieldName, Type^ type);
         };
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxLocalWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxLocalWriter.cpp 
b/src/clicache/src/impl/PdxLocalWriter.cpp
index dff9c56..eba6bc7 100644
--- a/src/clicache/src/impl/PdxLocalWriter.cpp
+++ b/src/clicache/src/impl/PdxLocalWriter.cpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         
@@ -482,10 +481,10 @@ namespace Generic
               return this->WriteObject(fieldName, fieldValue);
               //throw gcnew IllegalStateException("WriteField unable to 
serialize  " 
                                                                //              
                                                                                
                                        + fieldName + " of " + type); 
-            }
-          }
-                         }
-      }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
     }
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxLocalWriter.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxLocalWriter.hpp 
b/src/clicache/src/impl/PdxLocalWriter.hpp
index 6fd3f24..e98755b 100644
--- a/src/clicache/src/impl/PdxLocalWriter.hpp
+++ b/src/clicache/src/impl/PdxLocalWriter.hpp
@@ -30,8 +30,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       ref class DataOutput;
       namespace Internal
       {
@@ -363,8 +362,8 @@ namespace Generic
 
           virtual void WriteByte(Byte byte);//for internal purpose
         };      
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKey.cpp 
b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
index 48db481..4774647 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKey.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
@@ -38,19 +38,19 @@ namespace apache
       {
         try {
           uint32 pos = (int)output.getBufferLength();
-          Apache::Geode::Client::Generic::DataOutput mg_output(&output, true);
-          
Apache::Geode::Client::Generic::Internal::PdxHelper::SerializePdx(%mg_output, 
m_managedptr);
+          Apache::Geode::Client::DataOutput mg_output(&output, true);
+          Apache::Geode::Client::Internal::PdxHelper::SerializePdx(%mg_output, 
m_managedptr);
           //m_managedptr->ToData( %mg_output );
           //this will move the cursor in c++ layer
           mg_output.WriteBytesToUMDataOutput();
           PdxManagedCacheableKey* tmp = 
const_cast<PdxManagedCacheableKey*>(this);
           tmp->m_objectSize = (int)(output.getBufferLength() - pos);
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 
@@ -58,22 +58,22 @@ namespace apache
       {
         try {
           int pos = input.getBytesRead();
-          Apache::Geode::Client::Generic::DataInput mg_input(&input, true);
+          Apache::Geode::Client::DataInput mg_input(&input, true);
           //m_managedptr = m_managedptr->FromData( %mg_input );
-          Apache::Geode::Client::Generic::IPdxSerializable^ tmp = 
Apache::Geode::Client::Generic::Internal::PdxHelper::DeserializePdx(%mg_input, 
false);
+          Apache::Geode::Client::IPdxSerializable^ tmp = 
Apache::Geode::Client::Internal::PdxHelper::DeserializePdx(%mg_input, false);
           m_managedptr = tmp;
-          m_managedDeltaptr = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(tmp);
+          m_managedDeltaptr = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(tmp);
 
           //this will move the cursor in c++ layer
           input.advanceCursor(mg_input.BytesReadInternally);
           m_objectSize = input.getBytesRead() - pos;
           // m_hashcode = m_managedptr->GetHashCode();
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return this;
       }
@@ -83,11 +83,11 @@ namespace apache
         try {
           return m_objectSize;
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return 0;
       }
@@ -143,15 +143,15 @@ namespace apache
       {
         try {
           apache::geode::client::CacheableStringPtr cStr;
-          Apache::Geode::Client::Generic::CacheableString::GetCacheableString(
+          Apache::Geode::Client::CacheableString::GetCacheableString(
             m_managedptr->ToString(), cStr);
           return cStr;
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return NULLPTR;
       }
@@ -164,15 +164,15 @@ namespace apache
           const PdxManagedCacheableKey* p_other =
             dynamic_cast<const PdxManagedCacheableKey*>(&other);
           if (p_other != NULL) {
-            return 
((Apache::Geode::Client::Generic::IPdxSerializable^)m_managedptr)->Equals((p_other->ptr()));
+            return 
((Apache::Geode::Client::IPdxSerializable^)m_managedptr)->Equals((p_other->ptr()));
           }
           return false;
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return false;
       }
@@ -180,13 +180,13 @@ namespace apache
       bool PdxManagedCacheableKey::operator ==(const PdxManagedCacheableKey& 
other) const
       {
         try {
-          return 
((Apache::Geode::Client::Generic::IPdxSerializable^)m_managedptr)->Equals((other.ptr()));
+          return 
((Apache::Geode::Client::IPdxSerializable^)m_managedptr)->Equals((other.ptr()));
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return false;
       }
@@ -198,15 +198,15 @@ namespace apache
         try {
           PdxManagedCacheableKey* tmp = 
const_cast<PdxManagedCacheableKey*>(this);
           tmp->m_hashcode = (
-            
(Apache::Geode::Client::Generic::IPdxSerializable^)tmp->m_managedptr)
+            (Apache::Geode::Client::IPdxSerializable^)tmp->m_managedptr)
             ->GetHashCode();
           return m_hashcode;
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return 0;
       }
@@ -217,15 +217,15 @@ namespace apache
           if (maxLength > 0) {
             String^ logstr = m_managedptr->GetType()->Name + '(' +
               m_managedptr->ToString() + ')';
-            Apache::Geode::Client::Generic::ManagedString mg_str(logstr);
+            Apache::Geode::Client::ManagedString mg_str(logstr);
             return snprintf(buffer, maxLength, "%s", mg_str.CharPtr);
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return 0;
       }
@@ -242,23 +242,23 @@ namespace apache
       void PdxManagedCacheableKey::toDelta(DataOutput& output) const
       {
         try {
-          Apache::Geode::Client::Generic::DataOutput mg_output(&output, true);
+          Apache::Geode::Client::DataOutput mg_output(&output, true);
           m_managedDeltaptr->ToDelta(%mg_output);
           //this will move the cursor in c++ layer
           mg_output.WriteBytesToUMDataOutput();
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 
       void PdxManagedCacheableKey::fromDelta(DataInput& input)
       {
         try {
-          Apache::Geode::Client::Generic::DataInput mg_input(&input, true);
+          Apache::Geode::Client::DataInput mg_input(&input, true);
           m_managedDeltaptr->FromDelta(%mg_input);
 
           //this will move the cursor in c++ layer
@@ -266,11 +266,11 @@ namespace apache
 
           m_hashcode = m_managedptr->GetHashCode();
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 
@@ -278,10 +278,10 @@ namespace apache
       {
         try {
           ICloneable^ cloneable = dynamic_cast<ICloneable^>((
-            Apache::Geode::Client::Generic::IGFDelta^) m_managedDeltaptr);
+            Apache::Geode::Client::IGFDelta^) m_managedDeltaptr);
           if (cloneable) {
-            Apache::Geode::Client::Generic::IPdxSerializable^ Mclone =
-              
dynamic_cast<Apache::Geode::Client::Generic::IPdxSerializable^>(cloneable->Clone());
+            Apache::Geode::Client::IPdxSerializable^ Mclone =
+              
dynamic_cast<Apache::Geode::Client::IPdxSerializable^>(cloneable->Clone());
             return DeltaPtr(static_cast<PdxManagedCacheableKey*>(
               SafeGenericM2UMConvert(Mclone)));
           }
@@ -289,11 +289,11 @@ namespace apache
             return Delta::clone();
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return NULLPTR;
       }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxManagedCacheableKey.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKey.hpp 
b/src/clicache/src/impl/PdxManagedCacheableKey.hpp
index 0632436..457fb2e 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKey.hpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKey.hpp
@@ -32,13 +32,12 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
                                interface class IPdxSerializable;
-                       }
-    }
-  }
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 
 namespace apache
 {
@@ -65,10 +64,10 @@ namespace apache
         }
 
         inline PdxManagedCacheableKey(
-          Apache::Geode::Client::Generic::IPdxSerializable^ managedptr, int 
hashcode)
+          Apache::Geode::Client::IPdxSerializable^ managedptr, int hashcode)
           : m_managedptr(managedptr), m_objectSize(0) {
           m_hashcode = hashcode;
-          m_managedDeltaptr = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(managedptr);
+          m_managedDeltaptr = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(managedptr);
         }
         /// <summary>
         /// Constructor to initialize with the provided managed object.
@@ -77,10 +76,10 @@ namespace apache
         /// The managed object.
         /// </param>
         inline PdxManagedCacheableKey(
-          Apache::Geode::Client::Generic::IPdxSerializable^ managedptr)
+          Apache::Geode::Client::IPdxSerializable^ managedptr)
           : m_managedptr(managedptr), m_objectSize(0) {
           m_hashcode = 0;//it can be zero while initializing the object
-          m_managedDeltaptr = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(managedptr);
+          m_managedDeltaptr = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(managedptr);
         }
 
         /// <summary>
@@ -163,7 +162,7 @@ namespace apache
         /// <summary>
         /// Returns the wrapped managed object reference.
         /// </summary>
-        inline Apache::Geode::Client::Generic::IPdxSerializable^ ptr() const
+        inline Apache::Geode::Client::IPdxSerializable^ ptr() const
         {
           return m_managedptr;
         }
@@ -181,8 +180,8 @@ namespace apache
         /// to be called which is not what is desired when this object is 
destroyed. Normally this
         /// managed object may be created by the user and will be handled 
automatically by the GC.
         /// </summary>
-        gcroot<Apache::Geode::Client::Generic::IPdxSerializable^> m_managedptr;
-        gcroot<Apache::Geode::Client::Generic::IGFDelta^> m_managedDeltaptr;
+        gcroot<Apache::Geode::Client::IPdxSerializable^> m_managedptr;
+        gcroot<Apache::Geode::Client::IGFDelta^> m_managedDeltaptr;
 
         // Disable the copy and assignment constructors
         PdxManagedCacheableKey(const PdxManagedCacheableKey&);

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp 
b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
index 68fb3d1..1702327 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
@@ -36,16 +36,16 @@ namespace apache
     {
       void 
PdxManagedCacheableKeyBytes::toData(apache::geode::client::DataOutput& output) 
const
       {
-        // 
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::toData:
 current domain ID: " + System::Threading::Thread::GetDomainID() + " for 
object: " + System::Convert::ToString((int)this) + " with its domain ID: " + 
m_domainId );
+        // 
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::toData: current 
domain ID: " + System::Threading::Thread::GetDomainID() + " for object: " + 
System::Convert::ToString((int)this) + " with its domain ID: " + m_domainId );
         try {
           //TODO: I think this should work as it is
           output.writeBytesOnly(m_bytes, m_size);
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 
@@ -53,13 +53,13 @@ namespace apache
       {
         try {
 
-          
//Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::fromData:
 classid " + m_classId);
-          Apache::Geode::Client::Generic::DataInput mg_input(&input, true);
+          
//Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::fromData: 
classid " + m_classId);
+          Apache::Geode::Client::DataInput mg_input(&input, true);
           const uint8_t* objStartPos = input.currentBufferPosition();
 
-          Apache::Geode::Client::Generic::IPdxSerializable^ obj = 
Apache::Geode::Client::Generic::Internal::PdxHelper::DeserializePdx(%mg_input, 
false);
+          Apache::Geode::Client::IPdxSerializable^ obj = 
Apache::Geode::Client::Internal::PdxHelper::DeserializePdx(%mg_input, false);
 
-          //Apache::Geode::Client::Generic::IGFSerializable^ obj = 
Apache::Geode::Client::Generic::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
+          //Apache::Geode::Client::IGFSerializable^ obj = 
Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
           //obj->FromData(%mg_input);
 
           input.advanceCursor(mg_input.BytesReadInternally);
@@ -70,15 +70,15 @@ namespace apache
 
           //m_size = mg_input.BytesRead;
           m_size = (uint32_t)(objEndPos - objStartPos);
-          // 
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::fromData:
 objectSize = " + m_size + " m_hashCode = " + m_hashCode);
+          // 
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::fromData: 
objectSize = " + m_size + " m_hashCode = " + m_hashCode);
           m_bytes = input.getBufferCopyFrom(objStartPos, m_size);
 
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return this;
       }
@@ -89,11 +89,11 @@ namespace apache
           //return m_managedptr->ObjectSize;
           return m_size;
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return 0;
       }
@@ -105,11 +105,11 @@ namespace apache
         //  //classId = m_managedptr->ClassId;
         //  classId = m_classId;
         //}
-        //catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        //catch (Apache::Geode::Client::GemFireException^ ex) {
         //  ex->ThrowNative();
         //}
         //catch (System::Exception^ ex) {
-        //  Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+        //  Apache::Geode::Client::GemFireException::ThrowNative(ex);
         //}
         //return (classId >= 0x80000000 ? 0 : classId);
         return 0;
@@ -133,11 +133,11 @@ namespace apache
         //    return 
(int8_t)apache::geode::client::GemfireTypeIdsImpl::CacheableUserData4;
         //  }
         //}
-        //catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        //catch (Apache::Geode::Client::GemFireException^ ex) {
         //  ex->ThrowNative();
         //}
         //catch (System::Exception^ ex) {
-        //  Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+        //  Apache::Geode::Client::GemFireException::ThrowNative(ex);
         //}
         return (int8_t)GemfireTypeIdsImpl::PDX;
       }
@@ -161,20 +161,20 @@ namespace apache
       apache::geode::client::CacheableStringPtr 
PdxManagedCacheableKeyBytes::toString() const
       {
         try {
-          Apache::Geode::Client::Generic::IPdxSerializable^ manageObject = 
getManagedObject();
+          Apache::Geode::Client::IPdxSerializable^ manageObject = 
getManagedObject();
           if (manageObject != nullptr)
           {
             apache::geode::client::CacheableStringPtr cStr;
-            
Apache::Geode::Client::Generic::CacheableString::GetCacheableString(
+            Apache::Geode::Client::CacheableString::GetCacheableString(
               manageObject->ToString(), cStr);
             return cStr;
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return NULLPTR;
       }
@@ -182,55 +182,55 @@ namespace apache
       bool PdxManagedCacheableKeyBytes::operator ==(const 
apache::geode::client::CacheableKey& other) const
       {
         try {
-          //  
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::equal");
+          //  
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal");
           // now checking classId(), typeId(), DSFID() etc. will be much more
           // expensive than just a dynamic_cast
           const PdxManagedCacheableKeyBytes* p_other =
             dynamic_cast<const PdxManagedCacheableKeyBytes*>(&other);
           if (p_other != NULL) {
             apache::geode::client::DataInput di(m_bytes, m_size);
-            Apache::Geode::Client::Generic::DataInput mg_input(&di, true);
-            /* Apache::Geode::Client::Generic::IGFSerializable^ obj =
-               
Apache::Geode::Client::Generic::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
+            Apache::Geode::Client::DataInput mg_input(&di, true);
+            /* Apache::Geode::Client::IGFSerializable^ obj =
+               
Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
                obj->FromData(%mg_input);*/
-            Apache::Geode::Client::Generic::IPdxSerializable^ obj = 
getManagedObject();
+            Apache::Geode::Client::IPdxSerializable^ obj = getManagedObject();
             bool ret = obj->Equals(p_other->ptr());
-            // 
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::equal 
return VAL = " + ret);
+            // 
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal return 
VAL = " + ret);
             return ret;
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
-        // 
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::equal 
returns false");
+        // 
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal returns 
false");
         return false;
       }
 
       bool PdxManagedCacheableKeyBytes::operator ==(const 
PdxManagedCacheableKeyBytes& other) const
       {
         try {
-          
//Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::equal.
 ");
+          
//Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal. ");
           apache::geode::client::DataInput di(m_bytes, m_size);
-          Apache::Geode::Client::Generic::DataInput mg_input(&di, true);
-          /*Apache::Geode::Client::Generic::IGFSerializable^ obj =
-            
Apache::Geode::Client::Generic::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
+          Apache::Geode::Client::DataInput mg_input(&di, true);
+          /*Apache::Geode::Client::IGFSerializable^ obj =
+            
Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
             obj->FromData(%mg_input);*/
-          Apache::Geode::Client::Generic::IPdxSerializable^ obj = 
getManagedObject();
+          Apache::Geode::Client::IPdxSerializable^ obj = getManagedObject();
           bool ret = obj->Equals(other.ptr());
-          // 
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::equal 
return VAL = " + ret);
+          // 
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal return 
VAL = " + ret);
           return ret;
           //return obj->Equals(other.ptr());
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
-        //  
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::equal 
return false");
+        //  
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal return 
false");
         return false;
       }
 
@@ -242,44 +242,44 @@ namespace apache
       size_t PdxManagedCacheableKeyBytes::logString(char* buffer, size_t 
maxLength) const
       {
         try {
-          Apache::Geode::Client::Generic::IPdxSerializable^ manageObject = 
getManagedObject();
+          Apache::Geode::Client::IPdxSerializable^ manageObject = 
getManagedObject();
           if (manageObject != nullptr)
           {
             if (maxLength > 0) {
               String^ logstr = manageObject->GetType()->Name + '(' +
                 manageObject->ToString() + ')';
-              Apache::Geode::Client::Generic::ManagedString mg_str(logstr);
+              Apache::Geode::Client::ManagedString mg_str(logstr);
               return snprintf(buffer, maxLength, "%s", mg_str.CharPtr);
             }
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return 0;
       }
 
-      Apache::Geode::Client::Generic::IPdxSerializable^
+      Apache::Geode::Client::IPdxSerializable^
         PdxManagedCacheableKeyBytes::getManagedObject() const
       {
 
-        // 
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::getManagedObject
 " + m_size);
+        // 
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::getManagedObject
 " + m_size);
 
         apache::geode::client::DataInput dinp(m_bytes, m_size);
-        Apache::Geode::Client::Generic::DataInput mg_dinp(&dinp, true);
+        Apache::Geode::Client::DataInput mg_dinp(&dinp, true);
         /*TypeFactoryMethodGeneric^ creationMethod =
-          
Apache::Geode::Client::Generic::Serializable::GetTypeFactoryMethodGeneric(m_classId);
-          Apache::Geode::Client::Generic::IGFSerializable^ newObj = 
creationMethod();
+          
Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId);
+          Apache::Geode::Client::IGFSerializable^ newObj = creationMethod();
           return newObj->FromData(%mg_dinp);*/
-        return  
Apache::Geode::Client::Generic::Internal::PdxHelper::DeserializePdx(%mg_dinp, 
false);
+        return  
Apache::Geode::Client::Internal::PdxHelper::DeserializePdx(%mg_dinp, false);
       }
 
       bool PdxManagedCacheableKeyBytes::hasDelta()
       {
-        /* Apache::Geode::Client::Generic::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(this->getManagedObject());
+        /* Apache::Geode::Client::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(this->getManagedObject());
 
          if(deltaObj)
          return deltaObj->HasDelta();*/
@@ -289,38 +289,38 @@ namespace apache
       void PdxManagedCacheableKeyBytes::toDelta(DataOutput& output) const
       {
         try {
-          
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::toDelta:
 current domain ID: " + System::Threading::Thread::GetDomainID() + " for 
object: " + System::Convert::ToString((int)this) + " with its domain ID: " + 
m_domainId);
-          Apache::Geode::Client::Generic::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(this->getManagedObject());
-          Apache::Geode::Client::Generic::DataOutput mg_output(&output, true);
+          
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::toDelta: 
current domain ID: " + System::Threading::Thread::GetDomainID() + " for object: 
" + System::Convert::ToString((int)this) + " with its domain ID: " + 
m_domainId);
+          Apache::Geode::Client::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(this->getManagedObject());
+          Apache::Geode::Client::DataOutput mg_output(&output, true);
           deltaObj->ToDelta(%mg_output);
           mg_output.WriteBytesToUMDataOutput();
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 
       void PdxManagedCacheableKeyBytes::fromDelta(DataInput& input)
       {
         try {
-          
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta:");
-          Apache::Geode::Client::Generic::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(this->getManagedObject());
-          Apache::Geode::Client::Generic::DataInput mg_input(&input, true);
+          
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta:");
+          Apache::Geode::Client::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(this->getManagedObject());
+          Apache::Geode::Client::DataInput mg_input(&input, true);
           deltaObj->FromDelta(%mg_input);
 
-          Apache::Geode::Client::Generic::IPdxSerializable^ managedptr =
-            dynamic_cast <Apache::Geode::Client::Generic::IPdxSerializable^> 
(deltaObj);
+          Apache::Geode::Client::IPdxSerializable^ managedptr =
+            dynamic_cast <Apache::Geode::Client::IPdxSerializable^> (deltaObj);
           // if(managedptr != nullptr)
           {
-            
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta:
 current domain ID: " + System::Threading::Thread::GetDomainID() + " for 
object: " + System::Convert::ToString((int)this) + " with its domain ID: " + 
m_domainId);
-            
//Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta:
 classid " + managedptr->ClassId + " : " + managedptr->ToString());
+            
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta: 
current domain ID: " + System::Threading::Thread::GetDomainID() + " for object: 
" + System::Convert::ToString((int)this) + " with its domain ID: " + 
m_domainId);
+            
//Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta: 
classid " + managedptr->ClassId + " : " + managedptr->ToString());
             apache::geode::client::DataOutput dataOut;
-            Apache::Geode::Client::Generic::DataOutput mg_output(&dataOut, 
true);
+            Apache::Geode::Client::DataOutput mg_output(&dataOut, true);
             //managedptr->ToData( %mg_output );
-            
Apache::Geode::Client::Generic::Internal::PdxHelper::SerializePdx(%mg_output, 
managedptr);
+            
Apache::Geode::Client::Internal::PdxHelper::SerializePdx(%mg_output, 
managedptr);
             //m_managedptr->ToData( %mg_output );
             //this will move the cursor in c++ layer
             mg_output.WriteBytesToUMDataOutput();
@@ -331,26 +331,26 @@ namespace apache
             GF_SAFE_DELETE(m_bytes);
             m_bytes = dataOut.getBufferCopy();
             m_size = dataOut.getBufferLength();
-            
Apache::Geode::Client::Generic::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta
 objectSize = " + m_size + " m_hashCode = " + m_hashCode);
+            
Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::fromDelta 
objectSize = " + m_size + " m_hashCode = " + m_hashCode);
             m_hashCode = managedptr->GetHashCode();
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
 
       DeltaPtr PdxManagedCacheableKeyBytes::clone()
       {
         try {
-          Apache::Geode::Client::Generic::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(this->getManagedObject());
-          ICloneable^ cloneable = 
dynamic_cast<ICloneable^>((Apache::Geode::Client::Generic::IGFDelta^) deltaObj);
+          Apache::Geode::Client::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(this->getManagedObject());
+          ICloneable^ cloneable = 
dynamic_cast<ICloneable^>((Apache::Geode::Client::IGFDelta^) deltaObj);
           if (cloneable) {
-            Apache::Geode::Client::Generic::IPdxSerializable^ Mclone =
-              
dynamic_cast<Apache::Geode::Client::Generic::IPdxSerializable^>(cloneable->Clone());
+            Apache::Geode::Client::IPdxSerializable^ Mclone =
+              
dynamic_cast<Apache::Geode::Client::IPdxSerializable^>(cloneable->Clone());
             return DeltaPtr(static_cast<PdxManagedCacheableKeyBytes*>(
               SafeGenericM2UMConvert(Mclone)));
           }
@@ -358,11 +358,11 @@ namespace apache
             return Delta::clone();
           }
         }
-        catch (Apache::Geode::Client::Generic::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::Generic::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
         return NULLPTR;
       }

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxManagedCacheableKeyBytes.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.hpp 
b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.hpp
index 73a9c82..7c19944 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.hpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.hpp
@@ -33,13 +33,12 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-    {
+
       interface class IPdxSerializable;
-    }
-  }
-}
-}
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 
 namespace apache
 {
@@ -64,7 +63,7 @@ namespace apache
     /// The managed object.
     /// </param>
     inline PdxManagedCacheableKeyBytes(
-      Apache::Geode::Client::Generic::IPdxSerializable^ managedptr, bool 
storeBytes )
+      Apache::Geode::Client::IPdxSerializable^ managedptr, bool storeBytes )
       : m_domainId(System::Threading::Thread::GetDomainID()),
         m_bytes(NULL),
         m_size(0),
@@ -73,7 +72,7 @@ namespace apache
       m_hasDelta = false;
       if(storeBytes)
       {
-        Apache::Geode::Client::Generic::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::Generic::IGFDelta^>(managedptr);
+        Apache::Geode::Client::IGFDelta^ deltaObj = 
dynamic_cast<Apache::Geode::Client::IGFDelta^>(managedptr);
 
         if(deltaObj != nullptr)
           m_hasDelta = deltaObj->HasDelta();
@@ -83,8 +82,8 @@ namespace apache
         if(storeBytes)//if value is from app 
         {
           apache::geode::client::DataOutput dataOut;
-          Apache::Geode::Client::Generic::DataOutput mg_output( &dataOut, 
true);
-                                        
Apache::Geode::Client::Generic::Internal::PdxHelper::SerializePdx(%mg_output, 
managedptr);
+          Apache::Geode::Client::DataOutput mg_output( &dataOut, true);
+                                        
Apache::Geode::Client::Internal::PdxHelper::SerializePdx(%mg_output, 
managedptr);
         //  managedptr->ToData( %mg_output );
           
           //move cursor
@@ -95,7 +94,7 @@ namespace apache
           m_size = dataOut.getBufferLength();
           
           m_hashCode = managedptr->GetHashCode(); 
-          Apache::Geode::Client::Generic::Log::Fine(
+          Apache::Geode::Client::Log::Fine(
            "PdxManagedCacheableKeyBytes::Constructor objectSize = " + m_size + 
" m_hashCode = " + m_hashCode);
         }
       }
@@ -190,7 +189,7 @@ namespace apache
     /// <summary>
     /// Returns the wrapped managed object reference.
     /// </summary>
-    inline Apache::Geode::Client::Generic::IPdxSerializable^ ptr( ) const
+    inline Apache::Geode::Client::IPdxSerializable^ ptr( ) const
     {
       return getManagedObject();
     }
@@ -202,7 +201,7 @@ namespace apache
 
     inline ~PdxManagedCacheableKeyBytes()
     {
-      Apache::Geode::Client::Generic::Log::Fine(
+      Apache::Geode::Client::Log::Fine(
         "ManagedCacheableKeyBytes::Destructor current AppDomain ID: " +
         System::Threading::Thread::GetDomainID() + " for object: " +
         System::Convert::ToString((int)this) + " with its AppDomain ID: " + 
m_domainId);
@@ -211,7 +210,7 @@ namespace apache
 
   private:
 
-    Apache::Geode::Client::Generic::IPdxSerializable^ getManagedObject() const;
+    Apache::Geode::Client::IPdxSerializable^ getManagedObject() const;
     
     /// <summary>
     /// Using gcroot to hold the managed delegate pointer (since it cannot be 
stored directly).

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp 
b/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
index fb70dc7..a1bfe13 100644
--- a/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
+++ b/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
@@ -26,8 +26,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
                                void PdxReaderWithTypeCollector::checkType( 
String^ fieldName, Byte typeId, String^ fieldType)
@@ -540,10 +539,8 @@ namespace Generic
         //TODO:
         //void WriteEnum(String^ fieldName, Enum e) ;
         //void WriteInetAddress(String^ fieldName, InetAddress address);
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-        
-      }
-                       }
-    }
-  }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxReaderWithTypeCollector.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxReaderWithTypeCollector.hpp 
b/src/clicache/src/impl/PdxReaderWithTypeCollector.hpp
index a3ff9a0..4faabaa 100644
--- a/src/clicache/src/impl/PdxReaderWithTypeCollector.hpp
+++ b/src/clicache/src/impl/PdxReaderWithTypeCollector.hpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       ref class DataInput;
       namespace Internal
       {
@@ -262,8 +261,8 @@ namespace Generic
 
         
         };
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxRemotePreservedData.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxRemotePreservedData.hpp 
b/src/clicache/src/impl/PdxRemotePreservedData.hpp
index d965ceb..dc979be 100644
--- a/src/clicache/src/impl/PdxRemotePreservedData.hpp
+++ b/src/clicache/src/impl/PdxRemotePreservedData.hpp
@@ -26,8 +26,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         public ref class PdxRemotePreservedData : public IPdxUnreadFields
@@ -113,8 +112,8 @@ namespace Generic
             return 0;
           }
         };
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxRemoteReader.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxRemoteReader.cpp 
b/src/clicache/src/impl/PdxRemoteReader.cpp
index 0df184f..488137c 100644
--- a/src/clicache/src/impl/PdxRemoteReader.cpp
+++ b/src/clicache/src/impl/PdxRemoteReader.cpp
@@ -25,8 +25,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         void PdxRemoteReader::setNextOffsetToRead()
@@ -841,10 +840,8 @@ namespace Generic
         //TODO:
         //void WriteEnum(String^ fieldName, Enum e) ;
         //void WriteInetAddress(String^ fieldName, InetAddress address);
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
 
-        
-      }
-                       }
-    }
-  }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/649e4a87/src/clicache/src/impl/PdxRemoteReader.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxRemoteReader.hpp 
b/src/clicache/src/impl/PdxRemoteReader.hpp
index 305dd50..03a1655 100644
--- a/src/clicache/src/impl/PdxRemoteReader.hpp
+++ b/src/clicache/src/impl/PdxRemoteReader.hpp
@@ -28,8 +28,7 @@ namespace Apache
   {
     namespace Client
     {
-namespace Generic
-      {
+
       namespace Internal
       {
         ref class PdxRemoteReader: public PdxLocalReader
@@ -259,8 +258,8 @@ namespace Generic
 
         
         };
-      }
-                       }
-    }
-  }
+    }  // namespace Client
+  }  // namespace Geode
+}  // namespace Apache
+
 }
\ No newline at end of file

Reply via email to