geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aba...@apache.org
Subject [49/50] [abbrv] geode-native git commit: GEODE-2422: Switch remaining GemFire strings to Geode.
Date Thu, 09 Feb 2017 18:09:46 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedCqListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCqListener.cpp b/src/clicache/src/impl/ManagedCqListener.cpp
index 6cb9603..1d07294 100644
--- a/src/clicache/src/impl/ManagedCqListener.cpp
+++ b/src/clicache/src/impl/ManagedCqListener.cpp
@@ -148,7 +148,7 @@ namespace apache
           Apache::Geode::Client::CqEvent<Object^, Object^> mevent(&ev);
           m_managedptr->OnEvent(%mevent);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -171,7 +171,7 @@ namespace apache
         try {
           m_managedptr->Close();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedCqStatusListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCqStatusListener.cpp b/src/clicache/src/impl/ManagedCqStatusListener.cpp
index 9524de9..26fc920 100644
--- a/src/clicache/src/impl/ManagedCqStatusListener.cpp
+++ b/src/clicache/src/impl/ManagedCqStatusListener.cpp
@@ -146,7 +146,7 @@ namespace apache
           Apache::Geode::Client::CqEvent<Object^, Object^> mevent(&ev);
           m_managedptr->OnEvent(%mevent);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -169,7 +169,7 @@ namespace apache
         try {
           m_managedptr->Close();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -186,7 +186,7 @@ namespace apache
         try {
           m_managedptr->OnCqDisconnected();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -203,7 +203,7 @@ namespace apache
         try {
           m_managedptr->OnCqConnected();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp b/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
index 936e354..d0bf46c 100644
--- a/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
+++ b/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
@@ -219,11 +219,11 @@ namespace apache
         try {
           return m_managedptr->getRoutingObject(key);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULLPTR;
       }
@@ -233,11 +233,11 @@ namespace apache
         try {
           return m_managedptr->getName();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULL;
       }
@@ -247,11 +247,11 @@ namespace apache
         try {
           return m_managedptr->getPartitionName(opDetails);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULL;
       }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedPartitionResolver.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedPartitionResolver.cpp b/src/clicache/src/impl/ManagedPartitionResolver.cpp
index 921db75..f32005d 100644
--- a/src/clicache/src/impl/ManagedPartitionResolver.cpp
+++ b/src/clicache/src/impl/ManagedPartitionResolver.cpp
@@ -223,11 +223,11 @@ namespace apache
         try {
           return m_managedptr->getRoutingObject(key);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULLPTR;
       }
@@ -237,11 +237,11 @@ namespace apache
         try {
           return m_managedptr->getName();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULL;
       }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedResultCollector.cpp b/src/clicache/src/impl/ManagedResultCollector.cpp
index 27f50fb..84921ff 100644
--- a/src/clicache/src/impl/ManagedResultCollector.cpp
+++ b/src/clicache/src/impl/ManagedResultCollector.cpp
@@ -154,7 +154,7 @@ namespace apache
           m_managedptr->AddResult(rs);
           //m_managedptr->AddResult( SafeUMSerializableConvert( result.ptr( ) ) );
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -180,7 +180,7 @@ namespace apache
           //return rsptr;
           throw apache::geode::client::IllegalStateException("This should not be get callled.");
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -197,7 +197,7 @@ namespace apache
         try {
           m_managedptr->EndResults();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
@@ -213,7 +213,7 @@ namespace apache
         try {
           m_managedptr->ClearResults(/*false*/);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedTransactionListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionListener.cpp b/src/clicache/src/impl/ManagedTransactionListener.cpp
index 857ba7b..5763b37 100644
--- a/src/clicache/src/impl/ManagedTransactionListener.cpp
+++ b/src/clicache/src/impl/ManagedTransactionListener.cpp
@@ -209,11 +209,11 @@ namespace apache
           Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
 
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::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::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::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::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
       void ManagedTransactionListenerGeneric::close()
@@ -247,11 +247,11 @@ namespace apache
         try {
           m_managedptr->Close();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedTransactionWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionWriter.cpp b/src/clicache/src/impl/ManagedTransactionWriter.cpp
index 19bdf8d..a28bced 100644
--- a/src/clicache/src/impl/ManagedTransactionWriter.cpp
+++ b/src/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -207,11 +207,11 @@ namespace apache
           Apache::Geode::Client::TransactionEvent  mevent(te.ptr());
           m_managedptr->BeforeCommit(%mevent);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/ManagedVisitor.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedVisitor.cpp b/src/clicache/src/impl/ManagedVisitor.cpp
index c67cf1e..2d73c63 100644
--- a/src/clicache/src/impl/ManagedVisitor.cpp
+++ b/src/clicache/src/impl/ManagedVisitor.cpp
@@ -39,11 +39,11 @@ namespace apache
 
           m_visitor->Invoke(mg_key, (Apache::Geode::Client::IGFSerializable^)mg_value);
         }
-        catch (GemFireException^ ex) {
+        catch (GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          GemFireException::ThrowNative(ex);
+          GeodeException::ThrowNative(ex);
         }
       }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/PdxManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKey.cpp b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
index 0512b89..70fbb1f 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKey.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
@@ -46,11 +46,11 @@ namespace apache
           PdxManagedCacheableKey* tmp = const_cast<PdxManagedCacheableKey*>(this);
           tmp->m_objectSize = (int)(output.getBufferLength() - pos);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 
@@ -69,11 +69,11 @@ namespace apache
           m_objectSize = input.getBytesRead() - pos;
           // m_hashcode = m_managedptr->GetHashCode();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return this;
       }
@@ -83,11 +83,11 @@ namespace apache
         try {
           return m_objectSize;
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return 0;
       }
@@ -98,11 +98,11 @@ namespace apache
         try {
         classId = m_managedptr->ClassId;
         }
-        catch (Com::Vmware::Cache::GemFireException^ ex) {
+        catch (Com::Vmware::Cache::GeodeException^ ex) {
         ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-        Apache::Geode::Client::GemFireException::ThrowNative(ex);
+        Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }*/
         //return (m_classId >= 0x80000000 ? 0 : m_classId);
         return 0;
@@ -147,11 +147,11 @@ namespace apache
             m_managedptr->ToString(), cStr);
           return cStr;
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULLPTR;
       }
@@ -168,11 +168,11 @@ namespace apache
           }
           return false;
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return false;
       }
@@ -182,11 +182,11 @@ namespace apache
         try {
           return ((Apache::Geode::Client::IPdxSerializable^)m_managedptr)->Equals((other.ptr()));
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return false;
       }
@@ -202,11 +202,11 @@ namespace apache
             ->GetHashCode();
           return m_hashcode;
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return 0;
       }
@@ -221,11 +221,11 @@ namespace apache
             return snprintf(buffer, maxLength, "%s", mg_str.CharPtr);
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return 0;
       }
@@ -247,11 +247,11 @@ namespace apache
           //this will move the cursor in c++ layer
           mg_output.WriteBytesToUMDataOutput();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 
@@ -266,11 +266,11 @@ namespace apache
 
           m_hashcode = m_managedptr->GetHashCode();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 
@@ -289,11 +289,11 @@ namespace apache
             return Delta::clone();
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULLPTR;
       }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
index 112d92d..cfa6977 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
@@ -41,11 +41,11 @@ namespace apache
           //TODO: I think this should work as it is
           output.writeBytesOnly(m_bytes, m_size);
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 
@@ -74,11 +74,11 @@ namespace apache
           m_bytes = input.getBufferCopyFrom(objStartPos, m_size);
 
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return this;
       }
@@ -89,11 +89,11 @@ namespace apache
           //return m_managedptr->ObjectSize;
           return m_size;
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return 0;
       }
@@ -105,11 +105,11 @@ namespace apache
         //  //classId = m_managedptr->ClassId;
         //  classId = m_classId;
         //}
-        //catch (Apache::Geode::Client::GemFireException^ ex) {
+        //catch (Apache::Geode::Client::GeodeException^ ex) {
         //  ex->ThrowNative();
         //}
         //catch (System::Exception^ ex) {
-        //  Apache::Geode::Client::GemFireException::ThrowNative(ex);
+        //  Apache::Geode::Client::GeodeException::ThrowNative(ex);
         //}
         //return (classId >= 0x80000000 ? 0 : classId);
         return 0;
@@ -133,11 +133,11 @@ namespace apache
         //    return (int8_t)apache::geode::client::GeodeTypeIdsImpl::CacheableUserData4;
         //  }
         //}
-        //catch (Apache::Geode::Client::GemFireException^ ex) {
+        //catch (Apache::Geode::Client::GeodeException^ ex) {
         //  ex->ThrowNative();
         //}
         //catch (System::Exception^ ex) {
-        //  Apache::Geode::Client::GemFireException::ThrowNative(ex);
+        //  Apache::Geode::Client::GeodeException::ThrowNative(ex);
         //}
         return (int8_t)GeodeTypeIdsImpl::PDX;
       }
@@ -170,11 +170,11 @@ namespace apache
             return cStr;
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULLPTR;
       }
@@ -199,11 +199,11 @@ namespace apache
             return ret;
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         // Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal returns false");
         return false;
@@ -224,11 +224,11 @@ namespace apache
           return ret;
           //return obj->Equals(other.ptr());
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         //  Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal return false");
         return false;
@@ -253,11 +253,11 @@ namespace apache
             }
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return 0;
       }
@@ -295,11 +295,11 @@ namespace apache
           deltaObj->ToDelta(%mg_output);
           mg_output.WriteBytesToUMDataOutput();
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 
@@ -335,11 +335,11 @@ namespace apache
             m_hashCode = managedptr->GetHashCode();
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
       }
 
@@ -358,11 +358,11 @@ namespace apache
             return Delta::clone();
           }
         }
-        catch (Apache::Geode::Client::GemFireException^ ex) {
+        catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
         }
         catch (System::Exception^ ex) {
-          Apache::Geode::Client::GemFireException::ThrowNative(ex);
+          Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
         return NULLPTR;
       }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/com/gemstone/gemfire/plugins/sqlite/SqLiteImpl.cs
----------------------------------------------------------------------
diff --git a/src/com/gemstone/gemfire/plugins/sqlite/SqLiteImpl.cs b/src/com/gemstone/gemfire/plugins/sqlite/SqLiteImpl.cs
index ef971cb..1b9d9d7 100644
--- a/src/com/gemstone/gemfire/plugins/sqlite/SqLiteImpl.cs
+++ b/src/com/gemstone/gemfire/plugins/sqlite/SqLiteImpl.cs
@@ -154,7 +154,7 @@ namespace Apache.Geode.Plugins.SQLite
     public static readonly string PersistenceDir = "PersistenceDirectory";
     public static readonly string MaxPageCount = "max_page_count";
     public static readonly string PageSize = "page_size";
-    public static readonly string DefaultPersistenceDir = "GemFireRegionData";
+    public static readonly string DefaultPersistenceDir = "GeodeRegionData";
     public static readonly string DefaultMaxPageCount = "2147483646";
     public static readonly string DefaultPageSize = "65536";
     #endregion

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/Cache.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Cache.hpp b/src/cppcache/include/gfcpp/Cache.hpp
index 697750c..00ed79d 100644
--- a/src/cppcache/include/gfcpp/Cache.hpp
+++ b/src/cppcache/include/gfcpp/Cache.hpp
@@ -21,7 +21,7 @@
  */
 #include "gfcpp_globals.hpp"
 #include "gf_types.hpp"
-#include "GemFireCache.hpp"
+#include "GeodeCache.hpp"
 #include "gf_types.hpp"
 #include "Region.hpp"
 #include "DistributedSystem.hpp"
@@ -56,7 +56,7 @@ class Pool;
  * <p>A cache can have multiple root regions, each with a different name.
  *
  */
-class CPPCACHE_EXPORT Cache : public GemFireCache {
+class CPPCACHE_EXPORT Cache : public GeodeCache {
   /**
    * @brief public methods
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CacheFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheFactory.hpp b/src/cppcache/include/gfcpp/CacheFactory.hpp
index 59d4c1c..471692a 100644
--- a/src/cppcache/include/gfcpp/CacheFactory.hpp
+++ b/src/cppcache/include/gfcpp/CacheFactory.hpp
@@ -30,7 +30,7 @@
  * @file
  */
 
-#define DEFAULT_POOL_NAME "default_gemfireClientPool"
+#define DEFAULT_POOL_NAME "default_geodeClientPool"
 
 namespace apache {
 namespace geode {
@@ -39,7 +39,7 @@ namespace client {
 class CppCacheLibrary;
 /**
  * @class CacheFactory CacheFactory.hpp
- * Top level class for configuring and using GemFire on a client.This should be
+ * Top level class for configuring and using Geode on a client.This should be
  *called once to create {@link Cache}.
  *<p>
  * For the default values for the pool attributes see {@link PoolFactory}.
@@ -93,7 +93,7 @@ class CPPCACHE_EXPORT CacheFactory : public SharedBase {
   static CachePtr getAnyInstance();
 
   /** Returns the version of the cache implementation.
-   * For the 1.0 release of GemFire, the string returned is <code>1.0</code>.
+   * For the 1.0 release of Geode, the string returned is <code>1.0</code>.
    * @return the version of the cache implementation as a <code>String</code>
    */
   static const char* getVersion();
@@ -450,9 +450,9 @@ class CPPCACHE_EXPORT CacheFactory : public SharedBase {
   CacheFactoryPtr setPdxReadSerialized(bool pdxReadSerialized);
 
   /**
-   * Sets a gemfire property that will be used when creating the {link @Cache}.
-   * @param name the name of the gemfire property
-   * @param value the value of the gemfire property
+   * Sets a geode property that will be used when creating the {link @Cache}.
+   * @param name the name of the geode property
+   * @param value the value of the geode property
    * @return a reference to <code>this</code>
    * @since 3.5
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CacheListener.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheListener.hpp b/src/cppcache/include/gfcpp/CacheListener.hpp
index 95ebf28..dc76022 100644
--- a/src/cppcache/include/gfcpp/CacheListener.hpp
+++ b/src/cppcache/include/gfcpp/CacheListener.hpp
@@ -45,7 +45,7 @@ class RegionEvent;
  * of <code>CacheListener</code> methods.  If event A occurs before event B,
  * there is no guarantee that their corresponding <code>CacheListener</code>
  * method invocations will occur in the same order. Any exceptions thrown by
- * the listener are caught by GemFire and logged. If the exception is due to
+ * the listener are caught by Geode and logged. If the exception is due to
  * listener invocation on the same thread where a region operation has been
  * performed, then a <code>CacheListenerException</code> is thrown back to
  * the application. If the exception is for a notification received from
@@ -55,7 +55,7 @@ class RegionEvent;
  * There are two cases in which listeners are invoked. The first is when a
  * region modification operation (e.g. put, create, destroy, invalidate)
  * is performed. For this case it is important to ensure that minimal work is
- * done in the listener before returning control back to Gemfire since the
+ * done in the listener before returning control back to Geode since the
  * operation will block till the listener has not completed. For example,
  * a listener implementation may choose to hand off the event to a thread pool
  * that then processes the event on its thread rather than the listener thread.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CacheTransactionManager.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheTransactionManager.hpp b/src/cppcache/include/gfcpp/CacheTransactionManager.hpp
index 6ffe9e9..10b84d4 100644
--- a/src/cppcache/include/gfcpp/CacheTransactionManager.hpp
+++ b/src/cppcache/include/gfcpp/CacheTransactionManager.hpp
@@ -69,7 +69,7 @@ class CPPCACHE_EXPORT CacheTransactionManager
    * node. This can only happen if rebalancing/recovery happens during a
    * transaction that involves a PartitionedRegion.
    *
-   * @throws TransactionInDoubtException when GemFire cannot tell which nodes
+   * @throws TransactionInDoubtException when Geode cannot tell which nodes
    * have applied the transaction and which have not. This only occurs if nodes
    * fail mid-commit, and only then in very rare circumstances.
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CacheWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheWriter.hpp b/src/cppcache/include/gfcpp/CacheWriter.hpp
index 0a1a615..fc5e430 100644
--- a/src/cppcache/include/gfcpp/CacheWriter.hpp
+++ b/src/cppcache/include/gfcpp/CacheWriter.hpp
@@ -65,13 +65,13 @@ class RegionEvent;
  * application-specific behavior before the cache is modified.
  *
  * <p>Before the region is updated via a put, create, or destroy operation,
- * GemFire will call a <code>CacheWriter</code> that is installed anywhere in
+ * Geode will call a <code>CacheWriter</code> that is installed anywhere in
  * any
  * participating cache for that region, preferring a local
  * <code>CacheWriter</code>
  * if there is one. Usually there will be only one <code>CacheWriter</code> in
  * the distributed system. If there are multiple <code>CacheWriter</code>s
- * available in the distributed system, the GemFire
+ * available in the distributed system, the Geode
  * implementation always prefers one that is stored locally, or else picks one
  * arbitrarily. In any case, only one <code>CacheWriter</code> will be invoked.
  *

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CacheableBuiltins.hpp b/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
index d37ce48..d3dd75c 100644
--- a/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
+++ b/src/cppcache/include/gfcpp/CacheableBuiltins.hpp
@@ -447,12 +447,26 @@ class CacheableContainerType : public Cacheable, public TBase {
       return (value != NULL ? c##Ptr(new c(value, length, true)) : NULLPTR);   \
     }                                                                          \
     /**                                                                      \ \
+     * \                                                                       \
+     * \ \                                                                             \
      * Create a cacheable array taking ownership of the given array          \ \
+     * \                                                                       \
+     * \ \                                                                             \
      * without creating a copy.                                              \ \
+     * \                                                                       \
+     * \ \                                                                             \
      *                                                                       \ \
+     * \                                                                       \
+     * \ \                                                                             \
      * Note that the application has to ensure that the given array is       \ \
+     * \                                                                       \
+     * \ \                                                                             \
      * not deleted (apart from this class) and is allocated on the heap      \ \
+     * \                                                                       \
+     * \ \                                                                             \
      * using the "new" operator.                                             \ \
+     * \                                                                       \
+     * \ \                                                                             \
      */                                                                        \
     inline static c##Ptr createNoCopy(p* value, int32_t length) {              \
       return (value != NULL ? c##Ptr(new c(value, length)) : NULLPTR);         \

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CqOperation.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CqOperation.hpp b/src/cppcache/include/gfcpp/CqOperation.hpp
index b1b4a9a..b1976f2 100644
--- a/src/cppcache/include/gfcpp/CqOperation.hpp
+++ b/src/cppcache/include/gfcpp/CqOperation.hpp
@@ -36,7 +36,7 @@ namespace client {
 class CPPCACHE_EXPORT CqOperation {
   // public static methods
  public:
-  // types of operation CORESPONDING TO THE ONES in gemfire.cache.Operation
+  // types of operation CORESPONDING TO THE ONES in geode.cache.Operation
 
   typedef enum {
     OP_TYPE_INVALID = -1,

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/CqState.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/CqState.hpp b/src/cppcache/include/gfcpp/CqState.hpp
index d7dafcd..ed79b83 100644
--- a/src/cppcache/include/gfcpp/CqState.hpp
+++ b/src/cppcache/include/gfcpp/CqState.hpp
@@ -39,7 +39,7 @@ namespace client {
  */
 class CPPCACHE_EXPORT CqState {
  public:
-  // corresponding to gemfire.cache.query.internal.CqStateImpl
+  // corresponding to geode.cache.query.internal.CqStateImpl
   typedef enum {
     STOPPED = 0,
     RUNNING = 1,

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/Delta.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Delta.hpp b/src/cppcache/include/gfcpp/Delta.hpp
index ebbc7d5..2d6ee6f 100644
--- a/src/cppcache/include/gfcpp/Delta.hpp
+++ b/src/cppcache/include/gfcpp/Delta.hpp
@@ -38,7 +38,7 @@ namespace client {
  * Delta</code> as well as <code>class Cacheable</code> publicly.
  * The methods <code>hasDelta( ), toDelta( )</code> and <code>fromDelta(
  * )</code> must be implemented by the class, as these methods are used by
- * GemFire
+ * Geode
  * to detect the presence of delta in an object, to serialize the delta, and to
  * apply a serialized delta to an existing object
  * of the class.
@@ -47,7 +47,7 @@ namespace client {
 class Delta {
  public:
   /**
-   * <code>hasDelta( )</code> is invoked by GemFire during <code>Region::put(
+   * <code>hasDelta( )</code> is invoked by Geode during <code>Region::put(
    * CacheableKeyPtr, CacheablePtr )</code> to determine if the object contains
    * a delta.
    * If <code>hasDelta( )</code> returns true, the delta in the object is
@@ -59,7 +59,7 @@ class Delta {
 
   /**
    * Writes out delta information to out in a user-defined format. This is
-   * invoked on an application object after GemFire determines the presence
+   * invoked on an application object after Geode determines the presence
    * of delta in it by calling <code>hasDelta()</code> on the object.
    *
    * @throws IOException
@@ -68,7 +68,7 @@ class Delta {
 
   /**
    * Reads in delta information to this object in a user-defined format. This is
-   * invoked on an existing application object after GemFire determines the
+   * invoked on an existing application object after Geode determines the
    * presence of delta in <code>DataInput</code> instance.
    *
    * @throws IOException

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/DistributedSystem.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/DistributedSystem.hpp b/src/cppcache/include/gfcpp/DistributedSystem.hpp
index ad0c311..de8c870 100644
--- a/src/cppcache/include/gfcpp/DistributedSystem.hpp
+++ b/src/cppcache/include/gfcpp/DistributedSystem.hpp
@@ -36,8 +36,8 @@ namespace client {
 /**
  * @class DistributedSystem DistributedSystem.hpp
  * DistributedSystem encapsulates this applications "connection" into the
- * GemFire Java servers distributed system. In order to participate in the
- * GemFire Java servers distributed system, each application needs to connect to
+ * Geode Java servers distributed system. In order to participate in the
+ * Geode Java servers distributed system, each application needs to connect to
  * the DistributedSystem.
  * Each application can only be connected to one DistributedSystem.
  */
@@ -54,7 +54,7 @@ class CPPCACHE_EXPORT DistributedSystem : public SharedBase {
  public:
   /**
    * Initializes the Native Client system to be able to connect to the
-   * GemFire Java servers. If the name string is empty, then the default
+   * Geode Java servers. If the name string is empty, then the default
    * "NativeDS" is used as the name of distributed system.
    * @throws LicenseException if no valid license is found.
    * @throws IllegalStateException if GFCPP variable is not set and

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/ExceptionTypes.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/ExceptionTypes.hpp b/src/cppcache/include/gfcpp/ExceptionTypes.hpp
index f4e5485..1c3e9a7 100644
--- a/src/cppcache/include/gfcpp/ExceptionTypes.hpp
+++ b/src/cppcache/include/gfcpp/ExceptionTypes.hpp
@@ -65,7 +65,7 @@ namespace client {
  */
 
 /**
- *@brief A gemfire assertion exception.
+ *@brief A geode assertion exception.
  **/
 _GF_EXCEPTION_DEF(AssertionException);
 
@@ -184,12 +184,12 @@ _GF_EXCEPTION_DEF(EntryNotFoundException);
 /**
  *@brief Thrown when there is an input/output error.
  **/
-_GF_EXCEPTION_DEF(GemfireIOException);
+_GF_EXCEPTION_DEF(GeodeIOException);
 
 /**
- *@brief Thrown when gemfire configuration file is incorrect.
+ *@brief Thrown when geode configuration file is incorrect.
  **/
-_GF_EXCEPTION_DEF(GemfireConfigException);
+_GF_EXCEPTION_DEF(GeodeConfigException);
 
 /**
  *@brief Thrown when a null argument is provided to a method
@@ -240,7 +240,7 @@ _GF_EXCEPTION_DEF(BufferSizeExceededException);
 _GF_EXCEPTION_DEF(RegionCreationFailedException);
 
 /**
- *@brief Thrown when there is a fatal internal exception in gemfire.
+ *@brief Thrown when there is a fatal internal exception in geode.
   */
 _GF_EXCEPTION_DEF(FatalInternalException);
 
@@ -359,7 +359,7 @@ _GF_EXCEPTION_DEF(InvalidDeltaException);
 _GF_EXCEPTION_DEF(KeyNotFoundException);
 /**
 * @brief This is for all Exceptions that may be thrown
-* by a GemFire transaction.
+* by a Geode transaction.
 **/
 _GF_EXCEPTION_DEF(TransactionException);
 /**

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/Execution.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Execution.hpp b/src/cppcache/include/gfcpp/Execution.hpp
index a514fcb..f967e95 100644
--- a/src/cppcache/include/gfcpp/Execution.hpp
+++ b/src/cppcache/include/gfcpp/Execution.hpp
@@ -48,7 +48,7 @@ namespace client {
 class CPPCACHE_EXPORT Execution : public SharedBase {
  public:
   /**
-   * Specifies a data filter of routing objects for selecting the GemFire
+   * Specifies a data filter of routing objects for selecting the Geode
    * members
    * to execute the function.
    * <p>

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/FixedPartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/FixedPartitionResolver.hpp b/src/cppcache/include/gfcpp/FixedPartitionResolver.hpp
index 10057ae..e84a6f5 100644
--- a/src/cppcache/include/gfcpp/FixedPartitionResolver.hpp
+++ b/src/cppcache/include/gfcpp/FixedPartitionResolver.hpp
@@ -33,7 +33,7 @@ class EntryEvent;
  * Implementers of interface <code>FixedPartitionResolver</code> helps to
  * achieve explicit mapping of a "user defined" partition to a data member node.
  * <p>
- * GemFire uses the partition name returned by
+ * Geode uses the partition name returned by
  * {@link FixedPartitionResolver#getPartitionName(EntryEvent,
  * CacheableHashSetPtr)}
  * to determine on which member the data is being managed. Say, for example, you

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/FunctionService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/FunctionService.hpp b/src/cppcache/include/gfcpp/FunctionService.hpp
index d929e63..1243c56 100644
--- a/src/cppcache/include/gfcpp/FunctionService.hpp
+++ b/src/cppcache/include/gfcpp/FunctionService.hpp
@@ -54,10 +54,10 @@ class CPPCACHE_EXPORT FunctionService : public SharedBase {
   /**
    * Returns a {@link Execution} object that can be used to execute a data
    * dependent function on the specified Region.<br>
-   * When invoked from a GemFire client, the method returns an Execution
+   * When invoked from a Geode client, the method returns an Execution
    * instance that sends a message to one of the connected servers as specified
    * by the {@link Pool} for the region. Depending on the filters setup on the
-   * {@link Execution}, the function is executed on all GemFire members that
+   * {@link Execution}, the function is executed on all Geode members that
    * define the data region, or a subset of members.
    * {@link Execution::withFilter(filter)}).
    *

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/GemFireCache.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/GemFireCache.hpp b/src/cppcache/include/gfcpp/GemFireCache.hpp
deleted file mode 100644
index 506d0be..0000000
--- a/src/cppcache/include/gfcpp/GemFireCache.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#pragma once
-
-#ifndef GEODE_GFCPP_GEMFIRECACHE_H_
-#define GEODE_GFCPP_GEMFIRECACHE_H_
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "gfcpp_globals.hpp"
-#include "gf_types.hpp"
-#include "RegionService.hpp"
-
-/**
- * @file
- */
-
-namespace apache {
-namespace geode {
-namespace client {
-
-/**
- * GemFireCache represents the singleton cache that must be created
- * in order to connect to Gemfire server.
- * Users must create a {@link Cache}.
- * Instances of this interface are created using one of the following methods:
- * <ul>
- * <li> {@link ClientCacheFactory#create()} creates a client instance of {@link
- * Cache}.
- * </ul>
- *
- */
-
-class CPPCACHE_EXPORT GemFireCache : public RegionService {
-  /**
-   * @brief public methods
-   */
- public:
-  /** Returns the name of this cache.
-   * @return the string name of this cache
-   */
-  virtual const char* getName() const = 0;
-
-  /**
-   * Initializes the cache from an xml file
-   *
-   * @param cacheXml
-   *        Valid cache.xml file
-   */
-  virtual void initializeDeclarativeCache(const char* cacheXml) = 0;
-
-  /**
-  * Returns the distributed system that this cache was
-  * {@link CacheFactory::createCacheFactory created} with.
-  */
-  virtual DistributedSystemPtr getDistributedSystem() const = 0;
-
-  /**
-   * Returns whether Cache saves unread fields for Pdx types.
-   */
-  virtual bool getPdxIgnoreUnreadFields() = 0;
-
-  /**
-  * Returns whether { @link PdxInstance} is preferred for PDX types instead of
-  * C++ object.
-  */
-  virtual bool getPdxReadSerialized() = 0;
-};
-}  // namespace client
-}  // namespace geode
-}  // namespace apache
-
-#endif // GEODE_GFCPP_GEMFIRECACHE_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/GeodeCache.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/GeodeCache.hpp b/src/cppcache/include/gfcpp/GeodeCache.hpp
new file mode 100644
index 0000000..e603052
--- /dev/null
+++ b/src/cppcache/include/gfcpp/GeodeCache.hpp
@@ -0,0 +1,86 @@
+#pragma once
+
+#ifndef GEODE_GFCPP_GEMFIRECACHE_H_
+#define GEODE_GFCPP_GEMFIRECACHE_H_
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "gfcpp_globals.hpp"
+#include "gf_types.hpp"
+#include "RegionService.hpp"
+
+/**
+ * @file
+ */
+
+namespace apache {
+namespace geode {
+namespace client {
+
+/**
+ * GeodeCache represents the singleton cache that must be created
+ * in order to connect to Geode server.
+ * Users must create a {@link Cache}.
+ * Instances of this interface are created using one of the following methods:
+ * <ul>
+ * <li> {@link ClientCacheFactory#create()} creates a client instance of {@link
+ * Cache}.
+ * </ul>
+ *
+ */
+
+class CPPCACHE_EXPORT GeodeCache : public RegionService {
+  /**
+   * @brief public methods
+   */
+ public:
+  /** Returns the name of this cache.
+   * @return the string name of this cache
+   */
+  virtual const char* getName() const = 0;
+
+  /**
+   * Initializes the cache from an xml file
+   *
+   * @param cacheXml
+   *        Valid cache.xml file
+   */
+  virtual void initializeDeclarativeCache(const char* cacheXml) = 0;
+
+  /**
+  * Returns the distributed system that this cache was
+  * {@link CacheFactory::createCacheFactory created} with.
+  */
+  virtual DistributedSystemPtr getDistributedSystem() const = 0;
+
+  /**
+   * Returns whether Cache saves unread fields for Pdx types.
+   */
+  virtual bool getPdxIgnoreUnreadFields() = 0;
+
+  /**
+  * Returns whether { @link PdxInstance} is preferred for PDX types instead of
+  * C++ object.
+  */
+  virtual bool getPdxReadSerialized() = 0;
+};
+}  // namespace client
+}  // namespace geode
+}  // namespace apache
+
+#endif // GEODE_GFCPP_GEMFIRECACHE_H_

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/GeodeCppCache.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/GeodeCppCache.hpp b/src/cppcache/include/gfcpp/GeodeCppCache.hpp
index 66e8f11..98fefab 100644
--- a/src/cppcache/include/gfcpp/GeodeCppCache.hpp
+++ b/src/cppcache/include/gfcpp/GeodeCppCache.hpp
@@ -35,7 +35,7 @@
 #include "CacheableUndefined.hpp"
 #include "CacheFactory.hpp"
 #include "Cache.hpp"
-#include "GemFireCache.hpp"
+#include "GeodeCache.hpp"
 #include "CacheAttributes.hpp"
 #include "CacheStatistics.hpp"
 #include "CqAttributesFactory.hpp"

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/InternalCacheTransactionManager2PC.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/InternalCacheTransactionManager2PC.hpp b/src/cppcache/include/gfcpp/InternalCacheTransactionManager2PC.hpp
index a6c171d..ca7f705 100644
--- a/src/cppcache/include/gfcpp/InternalCacheTransactionManager2PC.hpp
+++ b/src/cppcache/include/gfcpp/InternalCacheTransactionManager2PC.hpp
@@ -31,7 +31,7 @@ namespace client {
  * Extension of the apache::geode::client::CacheTransactionManager that enables
  * client
  * application
- * to use Gemfire transaction as part of the global XA transaction.
+ * to use Geode transaction as part of the global XA transaction.
  *
  * The prepare method of this class corresponds to the prepare phases of the
  * 2 phase commit protocol driven by a global transaction manager.
@@ -43,7 +43,7 @@ namespace client {
  *
  * Methods of this class are expected to be called by a custom XA Resource
  * Manager
- * that is wrapping and adapting Gemfire client to XA specification
+ * that is wrapping and adapting Geode client to XA specification
  * requirements.
  *
  * @since 8.3
@@ -60,7 +60,7 @@ class CPPCACHE_EXPORT InternalCacheTransactionManager2PC
    * Calls to subsequent commit() or rollback() methods overridden by this class
    * are
    * expected to succeed after prepare() has returned successfully.
-   * Gemfire commits internal transaction irreversibly on commit() call.
+   * Geode commits internal transaction irreversibly on commit() call.
    *
    */
   virtual void prepare() = 0;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/Log.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Log.hpp b/src/cppcache/include/gfcpp/Log.hpp
index fd60422..4644451 100644
--- a/src/cppcache/include/gfcpp/Log.hpp
+++ b/src/cppcache/include/gfcpp/Log.hpp
@@ -32,16 +32,16 @@
 
 /******************************************************************************/
 
-#ifndef GEMFIRE_HIGHEST_LOG_LEVEL
-#define GEMFIRE_HIGHEST_LOG_LEVEL All
+#ifndef GEODE_HIGHEST_LOG_LEVEL
+#define GEODE_HIGHEST_LOG_LEVEL All
 #endif
 
-#ifndef GEMFIRE_MAX_LOG_FILE_LIMIT
-#define GEMFIRE_MAX_LOG_FILE_LIMIT (1024 * 1024 * 1024)
+#ifndef GEODE_MAX_LOG_FILE_LIMIT
+#define GEODE_MAX_LOG_FILE_LIMIT (1024 * 1024 * 1024)
 #endif
 
-#ifndef GEMFIRE_MAX_LOG_DISK_LIMIT
-#define GEMFIRE_MAX_LOG_DISK_LIMIT (1024ll * 1024ll * 1024ll * 1024ll)
+#ifndef GEODE_MAX_LOG_DISK_LIMIT
+#define GEODE_MAX_LOG_DISK_LIMIT (1024ll * 1024ll * 1024ll * 1024ll)
 #endif
 
 #define _GF_MSG_LIMIT 8192
@@ -68,7 +68,7 @@ class Exception;
     apache::geode::client::Log::log(level, expr)
 
 /** Defines methods available to clients that want to write a log message
-  * to their GemFire system's shared log file.
+  * to their Geode system's shared log file.
   * <p>
   * This class must be initialized prior to its use:
   * @ref Log::init
@@ -228,7 +228,7 @@ class CPPCACHE_EXPORT Log {
    * enough space left to hold the formatted log-line (around 70 chars).
    *
    * This is provided so that applications wishing to use the same format
-   * as GemFire log-lines can do so easily. A log-line starts with the prefix
+   * as Geode log-lines can do so easily. A log-line starts with the prefix
    * given below which is filled in by this method:
    * [<level> <date> <time> <timezone> <host>:<process ID> <thread ID>]
    *
@@ -245,7 +245,7 @@ class CPPCACHE_EXPORT Log {
    */
   static bool enabled(LogLevel level) {
     return (((s_doingDebug && level == Debug) ||
-             GEMFIRE_HIGHEST_LOG_LEVEL >= level) &&
+             GEODE_HIGHEST_LOG_LEVEL >= level) &&
             s_logLevel >= level);
   }
 
@@ -276,7 +276,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "error" log messages are enabled.
    */
   static bool errorEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Error && s_logLevel >= Error;
+    return GEODE_HIGHEST_LOG_LEVEL >= Error && s_logLevel >= Error;
   }
 
   /**
@@ -309,7 +309,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "warning" log messages are enabled.
    */
   static bool warningEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Warning && s_logLevel >= Warning;
+    return GEODE_HIGHEST_LOG_LEVEL >= Warning && s_logLevel >= Warning;
   }
 
   /**
@@ -342,7 +342,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "info" log messages are enabled.
    */
   static bool infoEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Info && s_logLevel >= Info;
+    return GEODE_HIGHEST_LOG_LEVEL >= Info && s_logLevel >= Info;
   }
 
   /**
@@ -375,7 +375,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "config" log messages are enabled.
    */
   static bool configEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Config && s_logLevel >= Config;
+    return GEODE_HIGHEST_LOG_LEVEL >= Config && s_logLevel >= Config;
   }
 
   /**
@@ -408,7 +408,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "fine" log messages are enabled.
    */
   static bool fineEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Fine && s_logLevel >= Fine;
+    return GEODE_HIGHEST_LOG_LEVEL >= Fine && s_logLevel >= Fine;
   }
 
   /**
@@ -441,7 +441,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "finer" log messages are enabled.
    */
   static bool finerEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Finer && s_logLevel >= Finer;
+    return GEODE_HIGHEST_LOG_LEVEL >= Finer && s_logLevel >= Finer;
   }
 
   /**
@@ -474,7 +474,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "finest" log messages are enabled.
    */
   static bool finestEnabled() {
-    return GEMFIRE_HIGHEST_LOG_LEVEL >= Finest && s_logLevel >= Finest;
+    return GEODE_HIGHEST_LOG_LEVEL >= Finest && s_logLevel >= Finest;
   }
 
   /**
@@ -507,7 +507,7 @@ class CPPCACHE_EXPORT Log {
    * Returns whether "debug" log messages are enabled.
    */
   static bool debugEnabled() {
-    return (s_doingDebug || GEMFIRE_HIGHEST_LOG_LEVEL >= Debug) &&
+    return (s_doingDebug || GEODE_HIGHEST_LOG_LEVEL >= Debug) &&
            s_logLevel >= Debug;
   }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PartitionResolver.hpp b/src/cppcache/include/gfcpp/PartitionResolver.hpp
index c1de6e3..81c4e4c 100644
--- a/src/cppcache/include/gfcpp/PartitionResolver.hpp
+++ b/src/cppcache/include/gfcpp/PartitionResolver.hpp
@@ -41,10 +41,10 @@ class EntryEvent;
 * class equals method so it properly verifies equality for the
 * PartitionResolver implementation. This might mean verifying that class names
 * are the same or that the returned routing objects are the same etc.. When you
-* initiate the partitioned region on multiple nodes, GemFire uses the equals
+* initiate the partitioned region on multiple nodes, Geode uses the equals
 * method to ensure you are using the same PartitionResolver implementation for
 * all of the nodes for the region.
-* GemFire uses the routing object's hashCode to determine where the data is
+* Geode uses the routing object's hashCode to determine where the data is
 * being managed. Say, for example, you want to colocate all Trades by month and
 * year.The key is implemented by TradeKey class which also implements the
 * PartitionResolver interface.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PdxInstance.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxInstance.hpp b/src/cppcache/include/gfcpp/PdxInstance.hpp
index 465ea28..60ac0d9 100644
--- a/src/cppcache/include/gfcpp/PdxInstance.hpp
+++ b/src/cppcache/include/gfcpp/PdxInstance.hpp
@@ -567,7 +567,7 @@ class CPPCACHE_EXPORT PdxInstance : public PdxSerializable {
 
   // From PdxSerializable
   /**
-   * @brief serialize this object in gemfire PDX format. This is an internal
+   * @brief serialize this object in geode PDX format. This is an internal
    * method.
    * @param PdxWriter to serialize the PDX object
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PdxSerializable.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxSerializable.hpp b/src/cppcache/include/gfcpp/PdxSerializable.hpp
index 8f83a0c..2c53d47 100644
--- a/src/cppcache/include/gfcpp/PdxSerializable.hpp
+++ b/src/cppcache/include/gfcpp/PdxSerializable.hpp
@@ -46,7 +46,7 @@ class CPPCACHE_EXPORT PdxSerializable : public CacheableKey {
   // using Serializable::fromData;
 
   /**
-   *@brief serialize this object in gemfire PDX format
+   *@brief serialize this object in geode PDX format
    *@param PdxWriter to serialize the PDX object
    **/
   virtual void toData(PdxWriterPtr output) /*const*/ = 0;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PdxSerializer.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxSerializer.hpp b/src/cppcache/include/gfcpp/PdxSerializer.hpp
index 064f289..5af4439 100644
--- a/src/cppcache/include/gfcpp/PdxSerializer.hpp
+++ b/src/cppcache/include/gfcpp/PdxSerializer.hpp
@@ -64,7 +64,7 @@ class CPPCACHE_EXPORT PdxSerializer : public SharedBase {
   virtual void* fromData(const char* className, PdxReaderPtr pr) = 0;
 
   /**
-   * Serializes this object in gemfire PDX format.
+   * Serializes this object in geode PDX format.
    * @param userObject the object which need to serialize
    * @param pw the PdxWriter object to use for serializing the object
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxUnreadFields.hpp b/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
index bc75400..bd5abd2 100644
--- a/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
+++ b/src/cppcache/include/gfcpp/PdxUnreadFields.hpp
@@ -28,7 +28,7 @@ namespace geode {
 namespace client {
 
 /**
- * Marker interface for an object that GemFire creates and returns
+ * Marker interface for an object that Geode creates and returns
  * from {@link PdxReader#readUnreadFields() readUnreadFields}.
  * If you call readUnreadFields then you must also call
  * {@link PdxWriter#writeUnreadFields(PdxUnreadFields) writeUnreadFields} when

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PdxWrapper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PdxWrapper.hpp b/src/cppcache/include/gfcpp/PdxWrapper.hpp
index 3351a0e..79d4a94 100644
--- a/src/cppcache/include/gfcpp/PdxWrapper.hpp
+++ b/src/cppcache/include/gfcpp/PdxWrapper.hpp
@@ -69,7 +69,7 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
   uint32_t hashcode() const;
 
   /**
-  *@brief serialize this object in gemfire PDX format
+  *@brief serialize this object in geode PDX format
   *@param PdxWriter to serialize the PDX object
   **/
   void toData(PdxWriterPtr output);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/Pool.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Pool.hpp b/src/cppcache/include/gfcpp/Pool.hpp
index 95259a9..88a34e1 100644
--- a/src/cppcache/include/gfcpp/Pool.hpp
+++ b/src/cppcache/include/gfcpp/Pool.hpp
@@ -37,7 +37,7 @@ class Cache;
 class CacheFactory;
 class PoolAttributes;
 /**
- * A pool of connections to connect from a client to a set of GemFire Cache
+ * A pool of connections to connect from a client to a set of Geode Cache
  * Servers.
  * <p>Instances of this interface are created using
  * {@link PoolFactory#create}.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/PoolFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/PoolFactory.hpp b/src/cppcache/include/gfcpp/PoolFactory.hpp
index 34d3b04..b472486 100644
--- a/src/cppcache/include/gfcpp/PoolFactory.hpp
+++ b/src/cppcache/include/gfcpp/PoolFactory.hpp
@@ -484,7 +484,7 @@ class CPPCACHE_EXPORT PoolFactory : public SharedBase {
   void reset();
 
   /**
-   * Creates a new Pool for connecting a client to a set of GemFire Cache
+   * Creates a new Pool for connecting a client to a set of Geode Cache
    * Servers.
    * using this factory's settings for attributes.
    *

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/Region.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/Region.hpp b/src/cppcache/include/gfcpp/Region.hpp
index 833f5d3..b043d71 100644
--- a/src/cppcache/include/gfcpp/Region.hpp
+++ b/src/cppcache/include/gfcpp/Region.hpp
@@ -181,7 +181,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws CacheServerException If an exception is received from the Java cache
   * server.
   *         Only for Native Client regions.
-  * @throws NotConnectedException if not connected to the gemfire system because
+  * @throws NotConnectedException if not connected to the geode system because
   * the client
   *         cannot establish usable connections to any of the servers given to
   * it.
@@ -580,7 +580,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * and provides a user-defined argument to the <code>CacheListener</code>.
   * Invalidate only removes the value from the entry, the key is kept intact.
   * To completely remove the entry, destroy should be used.
-  * The invalidate is not propogated to the Gemfire cache server to which it is
+  * The invalidate is not propogated to the Geode cache server to which it is
   * connected with.
   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
@@ -645,7 +645,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * Destroy removes
   * not only the value, but also the key and entry from this region.
   *
-  * The destroy is propogated to the Gemfire cache server to which it is
+  * The destroy is propogated to the Geode cache server to which it is
   * connected with. If the destroy fails due to an exception on server
   * throwing back <code>CacheServerException</code> or security exception,
   * then the local entry is still destroyed.
@@ -661,7 +661,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws IllegalArgumentException if key is NULLPTR
   * @throws CacheWriterException if CacheWriter aborts the operation
   * @throws CacheListenerException if CacheListener throws an exception
-  * @throws CacheServerException If an exception is received from the Gemfire
+  * @throws CacheServerException If an exception is received from the Geode
   * cache server.
   *         Only for Native Client regions.
   * @throws NotConnectedException if it is not connected to the cache because
@@ -734,7 +734,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * remove removes
   * not only the value, but also the key and entry from this region.
   *
-  * The remove is propogated to the Gemfire cache server to which it is
+  * The remove is propogated to the Geode cache server to which it is
   * connected with. If the destroy fails due to an exception on server
   * throwing back <code>CacheServerException</code> or security exception,
   * then the local entry is still removed.
@@ -751,7 +751,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws IllegalArgumentException if key is NULLPTR
   * @throws CacheWriterException if CacheWriter aborts the operation
   * @throws CacheListenerException if CacheListener throws an exception
-  * @throws CacheServerException If an exception is received from the Gemfire
+  * @throws CacheServerException If an exception is received from the Geode
   * cache server.
   *         Only for Native Client regions.
   * @throws NotConnectedException if it is not connected to the cache because
@@ -813,7 +813,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * remove removes
   * not only the value, but also the key and entry from this region.
   *
-  * The remove is propogated to the Gemfire cache server to which it is
+  * The remove is propogated to the Geode cache server to which it is
   * connected with. If the destroy fails due to an exception on server
   * throwing back <code>CacheServerException</code> or security exception,
   * then the local entry is still removed.
@@ -829,7 +829,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws IllegalArgumentException if key is NULLPTR
   * @throws CacheWriterException if CacheWriter aborts the operation
   * @throws CacheListenerException if CacheListener throws an exception
-  * @throws CacheServerException If an exception is received from the Gemfire
+  * @throws CacheServerException If an exception is received from the Geode
   * cache server.
   *         Only for Native Client regions.
   * @throws NotConnectedException if it is not connected to the cache because
@@ -962,7 +962,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * distributed system.
   * The vector v will contain only the server keys. Any prior contents in the
   * vector will be removed.
-  * @throws CacheServerException If an exception is received from the Gemfire
+  * @throws CacheServerException If an exception is received from the Geode
   * cache server.
   *         Only for Native Client regions.
   * @throws NotConnectedException if it is not connected to the cache because
@@ -1000,7 +1000,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
 
   /**
   * This operations checks for the value in the local cache .
-  * It is not propagated to the Gemfire cache server
+  * It is not propagated to the Geode cache server
   * to which it is connected.
   */
   virtual bool containsValueForKey(const CacheableKeyPtr& keyPtr) const = 0;
@@ -1008,7 +1008,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   /**
   * Convenience method allowing key to be a const char*
   * This operations checks for the value in the local cache .
-  * It is not propagated to the Gemfire cache server
+  * It is not propagated to the Geode cache server
   * to which it is connected.
   */
   template <class KEYTYPE>
@@ -1046,7 +1046,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   /**
   * Convenience method allowing key to be a const char*
   * This operations checks for the key in the local cache .
-  * It is not propagated to the Gemfire cache server
+  * It is not propagated to the Geode cache server
   * to which it is connected.
   */
   template <class KEYTYPE>

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/RegionService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/RegionService.hpp b/src/cppcache/include/gfcpp/RegionService.hpp
index 5b800d4..9fc3309 100644
--- a/src/cppcache/include/gfcpp/RegionService.hpp
+++ b/src/cppcache/include/gfcpp/RegionService.hpp
@@ -37,7 +37,7 @@ class QueryService;
 
 /**
  * A RegionService provides access to existing {@link Region regions} that exist
- * in a {@link GemFireCache GemFire cache}.
+ * in a {@link GeodeCache Geode cache}.
  * Regions can be obtained using {@link #getRegion}
  * and queried using {@link #getQueryService}.
  * The service should be {@link #close closed} to free up resources

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/ResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/ResultCollector.hpp b/src/cppcache/include/gfcpp/ResultCollector.hpp
index 7cdae0f..b0edf5c 100644
--- a/src/cppcache/include/gfcpp/ResultCollector.hpp
+++ b/src/cppcache/include/gfcpp/ResultCollector.hpp
@@ -37,7 +37,7 @@ namespace client {
  * @class ResultCollector ResultCollector.hpp
  * Defines the interface for a container that gathers results from function
  * execution.<br>
- * GemFire provides a default implementation for ResultCollector.
+ * Geode provides a default implementation for ResultCollector.
  * Applications can choose to implement their own custom ResultCollector.
  * A custom ResultCollector facilitates result sorting or aggregation.
  * Aggregation
@@ -70,7 +70,7 @@ class CPPCACHE_EXPORT ResultCollector : public SharedBase {
   /**
    * Returns the result of function execution, potentially blocking until all
    * the results are available.
-   * If gemfire sendException is called then {@link ResultCollector.getResult}
+   * If geode sendException is called then {@link ResultCollector.getResult}
    * will not
    * throw exception but will have exception {@link
    * UserFunctionExecutionException} as a part of results received.
@@ -90,13 +90,13 @@ class CPPCACHE_EXPORT ResultCollector : public SharedBase {
    */
   virtual void addResult(CacheablePtr& resultOfSingleExecution);
   /**
-   * GemFire will invoke this method when function execution has completed
+   * Geode will invoke this method when function execution has completed
    * and all results for the execution have been obtained and  added to the
    * ResultCollector}
    */
   virtual void endResults();
   /**
-   * GemFire will invoke this method before re-executing function (in case of
+   * Geode will invoke this method before re-executing function (in case of
    * Function Execution HA) This is to clear the previous execution results from
    * the result collector
    * @since 6.5

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/SystemProperties.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/SystemProperties.hpp b/src/cppcache/include/gfcpp/SystemProperties.hpp
index c24b8e4..aa8ba76 100644
--- a/src/cppcache/include/gfcpp/SystemProperties.hpp
+++ b/src/cppcache/include/gfcpp/SystemProperties.hpp
@@ -224,7 +224,7 @@ class CPPCACHE_EXPORT SystemProperties {
    * By default crash dumps are created in the current working directory.
    * If log-file has been specified then they are created in the same
    * directory as the log file, and having the same prefix as log file.
-   * The default prefix is "gemfire_cpp".
+   * The default prefix is "geode_cpp".
    * The actual dump file will have timestamp and process ID in the full name.
    */
   inline const bool crashDumpEnabled() const { return m_crashDumpEnabled; }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/TransactionId.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/TransactionId.hpp b/src/cppcache/include/gfcpp/TransactionId.hpp
index ba933fe..00d5bfe 100644
--- a/src/cppcache/include/gfcpp/TransactionId.hpp
+++ b/src/cppcache/include/gfcpp/TransactionId.hpp
@@ -34,7 +34,7 @@ namespace geode {
 namespace client {
 
 /** The TransactionId interface is a "marker" interface that
-* represents a unique GemFire transaction.
+* represents a unique Geode transaction.
 * @see Cache#getCacheTransactionManager
 * @see CacheTransactionManager#getTransactionId
 */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp b/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
index 7eb6176..418b800 100644
--- a/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
+++ b/src/cppcache/include/gfcpp/UserFunctionExecutionException.hpp
@@ -31,7 +31,7 @@ typedef SharedPtr<UserFunctionExecutionException>
     UserFunctionExecutionExceptionPtr;
 
 /**
-* @brief UserFunctionExecutionException class is used to encapsulate gemfire
+* @brief UserFunctionExecutionException class is used to encapsulate geode
 *sendException in case of Function execution.
 **/
 class UserFunctionExecutionException : public Serializable {
@@ -97,12 +97,12 @@ class UserFunctionExecutionException : public Serializable {
 
   /**
   *@brief return as CacheableStringPtr the Exception message returned from
-  *gemfire sendException api.
+  *geode sendException api.
   **/
   CacheableStringPtr getMessage() { return m_message; }
 
   /**
-  *@brief return as CacheableStringPtr the Exception name returned from gemfire
+  *@brief return as CacheableStringPtr the Exception name returned from geode
   *sendException api.
   **/
   CacheableStringPtr getName() {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/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 9e70eca..ae1df5a 100644
--- a/src/cppcache/include/gfcpp/gf_base.hpp
+++ b/src/cppcache/include/gfcpp/gf_base.hpp
@@ -40,14 +40,14 @@
 #define LIBEXPORT(type) type
 #endif
 
-/** Defines a GemFire C extern */
+/** Defines a Geode C extern */
 #ifdef BUILD_GEMFIRE
 #define GFCEXTERN(type) LIBEXP type LIBCALL
 #else
 #define GFCEXTERN(type) LIBIMP type LIBCALL
 #endif /* BUILD_GEMFIRE    */
 
-/** Defines a GemFire CPPCACHE export */
+/** Defines a Geode CPPCACHE export */
 #if defined(_WIN32)
 #ifdef BUILD_CPPCACHE
 #define CPPCACHE_EXPORT LIBEXP
@@ -193,11 +193,11 @@ typedef uint64_t uint64; /**< unsigned 64 bit integer */
 #endif
 #endif /* _WIN32*/
 
-/**@namespace gemfire This namespace contains all the GemFire
+/**@namespace geode This namespace contains all the Geode
  * C++ API classes, enumerations and globals.
  */
 
-/**@namespace gemfire_statistics This namespace contains all the GemFire
+/**@namespace geode_statistics This namespace contains all the Geode
  * C++ statistics API classes.
  */
 
@@ -210,7 +210,7 @@ typedef uint64_t uint64; /**< unsigned 64 bit integer */
 /**
  * @file
  *
- *  Definitions of types and functions supported in the GemFire C++ interface
+ *  Definitions of types and functions supported in the Geode C++ interface
  */
 
 /** default timeout for query response */
@@ -218,7 +218,7 @@ typedef uint64_t uint64; /**< unsigned 64 bit integer */
 
 /**
  * @enum GfErrType
- *Error codes returned by GemFire C++ interface functions
+ *Error codes returned by Geode C++ interface functions
  */
 typedef enum {
   GF_NOERR = 0,           /**< success - no error               */
@@ -231,7 +231,7 @@ typedef enum {
   GF_ERANGE = 7,          /**< index out of range               */
   GF_ETYPE = 8,           /**< type mismatch                    */
   GF_NOTOBJ = 9,          /**< invalid object reference         */
-  GF_NOTCON = 10,         /**< not connected to GemFire         */
+  GF_NOTCON = 10,         /**< not connected to Geode         */
   GF_NOTOWN = 11,         /**< lock not owned by process/thread */
   GF_NOTSUP = 12,         /**< operation not supported          */
   GF_SCPGBL = 13,         /**< attempt to exit global scope     */
@@ -239,7 +239,7 @@ typedef enum {
   GF_TIMOUT = 15,         /**< operation timed out              */
   GF_OVRFLW = 16,         /**< arithmetic overflow              */
   GF_IOERR = 17,          /**< paging file I/O error            */
-  GF_EINTR = 18,          /**< interrupted GemFire call         */
+  GF_EINTR = 18,          /**< interrupted Geode call         */
   GF_MSG = 19,            /**< message could not be handled     */
   GF_DISKFULL = 20,       /**< disk full                        */
   GF_NOSERVER_FOUND = 21, /** NoServer found */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/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 6e1a16a..9bc035c 100644
--- a/src/cppcache/include/gfcpp/gf_types.hpp
+++ b/src/cppcache/include/gfcpp/gf_types.hpp
@@ -39,7 +39,7 @@ class CacheFactory;
 _GF_PTR_DEF_(DistributedSystem, DistributedSystemPtr);
 _GF_PTR_DEF_(CacheFactory, CacheFactoryPtr);
 _GF_PTR_DEF_(RegionService, RegionServicePtr);
-_GF_PTR_DEF_(GemFireCache, GemFireCachePtr);
+_GF_PTR_DEF_(GeodeCache, GeodeCachePtr);
 _GF_PTR_DEF_(Cache, CachePtr);
 _GF_PTR_DEF_(RegionFactory, RegionFactoryPtr);
 _GF_PTR_DEF_(AttributesFactory, AttributesFactoryPtr);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/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 72f720e..07e535e 100644
--- a/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp
+++ b/src/cppcache/include/gfcpp/statistics/StatisticDescriptor.hpp
@@ -33,7 +33,7 @@ namespace statistics {
 
 /**
  * Describes an individual statistic whose value is updated by an
- * application and may be archived by GemFire.  These descriptions are
+ * application and may be archived by Geode.  These descriptions are
  * gathered together in a {@link StatisticsType}.
  *
  * <P>

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/include/gfcpp/statistics/StatisticsFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/gfcpp/statistics/StatisticsFactory.hpp b/src/cppcache/include/gfcpp/statistics/StatisticsFactory.hpp
index d0549ef..fa0c44a 100644
--- a/src/cppcache/include/gfcpp/statistics/StatisticsFactory.hpp
+++ b/src/cppcache/include/gfcpp/statistics/StatisticsFactory.hpp
@@ -45,7 +45,7 @@ namespace statistics {
  * statistic (<code>StatisticDescriptor</code>) can either be a
  * <I>gauge</I> meaning that its value can increase and decrease or a
  * <I>counter</I> meaning that its value is strictly increasing.
- * Marking a statistic as a counter allows the GemFire Manager Console
+ * Marking a statistic as a counter allows the Geode Manager Console
  * to properly display a statistics whose value "wraps around" (that
  * is, exceeds its maximum value).
  *

http://git-wip-us.apache.org/repos/asf/geode-native/blob/04c53479/src/cppcache/integration-test/CacheHelper.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/integration-test/CacheHelper.cpp b/src/cppcache/integration-test/CacheHelper.cpp
index 9c22916..2e8890e 100644
--- a/src/cppcache/integration-test/CacheHelper.cpp
+++ b/src/cppcache/integration-test/CacheHelper.cpp
@@ -151,7 +151,7 @@ CacheHelper::CacheHelper(const bool isThinclient,
     cachePtr = CacheFactory::createCacheFactory(pp)->create();
     m_doDisconnect = false;
   } catch (const Exception& excp) {
-    LOG("GemFire exception while creating cache, logged in following line");
+    LOG("Geode exception while creating cache, logged in following line");
     LOG(excp.getMessage());
   } catch (...) {
     LOG("Throwing exception while creating cache....");
@@ -174,7 +174,7 @@ CacheHelper::CacheHelper(const bool isThinclient, bool pdxIgnoreUnreadFields,
     cachePtr = cfPtr->create();
     m_doDisconnect = false;
   } catch (const Exception& excp) {
-    LOG("GemFire exception while creating cache, logged in following line");
+    LOG("Geode exception while creating cache, logged in following line");
     LOG(excp.getMessage());
   } catch (...) {
     LOG("Throwing exception while creating cache....");
@@ -222,7 +222,7 @@ CacheHelper::CacheHelper(const bool isthinClient, const char* poolName,
 
     cachePtr = cacheFac->create();
   } catch (const Exception& excp) {
-    LOG("GemFire exception while creating cache, logged in following line");
+    LOG("Geode exception while creating cache, logged in following line");
     LOG(excp.getMessage());
   } catch (...) {
     LOG("Throwing exception while creating cache....");
@@ -1281,7 +1281,7 @@ void CacheHelper::initServer(int instance, const char* xml,
   printf("  creating dir = %s \n", sname.c_str());
   ACE_OS::mkdir(sname.c_str());
 
-  //    sprintf( cmd, "/bin/cp %s/../test.gemfire.properties
+  //    sprintf( cmd, "/bin/cp %s/../test.geode.properties
   //    %s/",currDir.c_str(),
   // currDir.c_str()  );
   // LOG( cmd );
@@ -1308,7 +1308,7 @@ void CacheHelper::initServer(int instance, const char* xml,
   }
 
   if (locHostport != NULL) {  // check number of locator host port.
-    std::string gemfireProperties = generateGemfireProperties(currDir, ssl);
+    std::string geodeProperties = generateGeodeProperties(currDir, ssl);
 
     sprintf(
         cmd,
@@ -1319,7 +1319,7 @@ void CacheHelper::initServer(int instance, const char* xml,
         "--J=-Dgemfire.tombstone-gc-hreshold=%ld "
         "--J=-Dgemfire.security-log-level=%s --J=-Xmx1024m --J=-Xms128m 2>&1",
         gfjavaenv, GFSH, classpath, sname.c_str(), xmlFile.c_str(),
-        currDir.c_str(), portNum, gfLogLevel, gemfireProperties.c_str(),
+        currDir.c_str(), portNum, gfLogLevel, geodeProperties.c_str(),
         authParam, deltaProperty.c_str(),
         testServerGC ? userTombstone_timeout : defaultTombstone_timeout,
         testServerGC ? userTombstone_gc_threshold
@@ -1514,7 +1514,7 @@ void CacheHelper::closeLocator(int instance, bool ssl) {
   terminate_process_file(currDir + "/vf.gf.locator.pid",
                          std::chrono::seconds(10));
 
-  sprintf(cmd, "%s .%stest.gemfire.properties", DELETE_COMMAND, PATH_SEP);
+  sprintf(cmd, "%s .%stest.geode.properties", DELETE_COMMAND, PATH_SEP);
   LOG(cmd);
   ACE_OS::system(cmd);
 
@@ -1651,11 +1651,11 @@ void CacheHelper::initLocator(int instance, bool ssl, bool multiDS, int dsId,
 
   ACE_OS::mkdir(locDirname.c_str());
 
-  std::string gemfireFile =
-      generateGemfireProperties(currDir, ssl, dsId, remoteLocator);
+  std::string geodeFile =
+      generateGeodeProperties(currDir, ssl, dsId, remoteLocator);
 
   sprintf(cmd, "%s/bin/%s stop locator --dir=%s --properties-file=%s ",
-          gfjavaenv, GFSH, currDir.c_str(), gemfireFile.c_str());
+          gfjavaenv, GFSH, currDir.c_str(), geodeFile.c_str());
 
   LOG(cmd);
   ACE_OS::system(cmd);
@@ -1664,7 +1664,7 @@ void CacheHelper::initLocator(int instance, bool ssl, bool multiDS, int dsId,
           "%s/bin/%s start locator --name=%s --port=%d --dir=%s "
           "--properties-file=%s ",
           gfjavaenv, GFSH, locDirname.c_str(), portnum, currDir.c_str(),
-          gemfireFile.c_str());
+          geodeFile.c_str());
 
   LOG(cmd);
   ACE_OS::system(cmd);
@@ -1769,21 +1769,20 @@ int CacheHelper::getNumLocatorListUpdates(const char* s) {
   return numMatched;
 }
 
-std::string CacheHelper::generateGemfireProperties(const std::string& path,
-                                                   const bool ssl,
-                                                   const int dsId,
-                                                   const int remoteLocator) {
+std::string CacheHelper::generateGeodeProperties(const std::string& path,
+                                                 const bool ssl, const int dsId,
+                                                 const int remoteLocator) {
   char cmd[2048];
   std::string keystore = std::string(ACE_OS::getenv("TESTSRC")) + "/keystore";
 
-  std::string gemfireFile = path;
-  gemfireFile += "/test.gemfire.properties";
-  sprintf(cmd, "%s %s%stest.gemfire.properties", DELETE_COMMAND, path.c_str(),
+  std::string geodeFile = path;
+  geodeFile += "/test.geode.properties";
+  sprintf(cmd, "%s %s%stest.geode.properties", DELETE_COMMAND, path.c_str(),
           PATH_SEP);
   LOG(cmd);
   ACE_OS::system(cmd);
   FILE* urandom = /*ACE_OS::*/
-      fopen(gemfireFile.c_str(), "w");
+      fopen(geodeFile.c_str(), "w");
   char gemStr[258];
   sprintf(gemStr, "locators=localhost[%d],localhost[%d],localhost[%d]\n",
           CacheHelper::staticLocatorHostPort1,
@@ -1822,6 +1821,6 @@ std::string CacheHelper::generateGemfireProperties(const std::string& path,
   fflush(urandom);
   /*ACE_OS::*/
   fclose(urandom);
-  LOG(gemfireFile.c_str());
-  return gemfireFile;
+  LOG(geodeFile.c_str());
+  return geodeFile;
 }


Mime
View raw message