geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [04/18] geode git commit: GEODE-2365: Replace gemfire with geode in clicache.
Date Thu, 02 Feb 2017 22:27:54 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/ManagedTransactionListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionListener.cpp b/src/clicache/src/impl/ManagedTransactionListener.cpp
index 83ee192..857ba7b 100644
--- a/src/clicache/src/impl/ManagedTransactionListener.cpp
+++ b/src/clicache/src/impl/ManagedTransactionListener.cpp
@@ -37,15 +37,15 @@ namespace apache
     namespace client
     {
 
-      apache::geode::client::TransactionListener* ManagedTransactionListenerGeneric::create( const char* assemblyPath,
-        const char* factoryFunctionName )
+      apache::geode::client::TransactionListener* ManagedTransactionListenerGeneric::create(const char* assemblyPath,
+                                                                                            const char* factoryFunctionName)
       {
         try
         {
           String^ mg_assemblyPath =
-            Apache::Geode::Client::ManagedString::Get( assemblyPath );
+            Apache::Geode::Client::ManagedString::Get(assemblyPath);
           String^ mg_factoryFunctionName =
-            Apache::Geode::Client::ManagedString::Get( factoryFunctionName );
+            Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
           String^ mg_typeName = nullptr;
 
           String^ mg_genericKey = nullptr;
@@ -57,38 +57,38 @@ namespace apache
           int32_t commaIndx = -1;
 
           if (mg_factoryFunctionName == nullptr ||
-            ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 )
+              (dotIndx = mg_factoryFunctionName->LastIndexOf('.')) < 0)
           {
             std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain type name";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
-          if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 )
+          if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf('>')) < 0)
           {
             std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain any generic type parameters";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
-          if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 ||
-            genericsOpenIndx > genericsCloseIndx)
+          if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf('<')) < 0 ||
+              genericsOpenIndx > genericsCloseIndx)
           {
             std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain expected generic type parameters";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
-          if ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 ||
-            (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
+          if ((commaIndx = mg_factoryFunctionName->LastIndexOf(',')) < 0 ||
+              (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
           {
             std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain expected generic type parameter comma separator";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
           StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName->Substring(0, genericsOpenIndx));
@@ -97,10 +97,10 @@ namespace apache
           mg_genericKey = mg_genericKey->Trim();
           mg_genericVal = mg_factoryFunctionName->Substring(commaIndx + 1, genericsCloseIndx - commaIndx - 1);
           mg_genericVal = mg_genericVal->Trim();
-          mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx + 1 );
+          mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1);
 
           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);
+                                           mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
 
           typeBuilder->Append("`2");
           mg_typeName = typeBuilder->ToString();
@@ -108,7 +108,7 @@ namespace apache
           Assembly^ assmb = nullptr;
           try
           {
-            assmb = Assembly::Load( mg_assemblyPath );
+            assmb = Assembly::Load(mg_assemblyPath);
           }
           catch (System::Exception^)
           {
@@ -118,7 +118,7 @@ namespace apache
           {
             std::string ex_str = "ManagedTransactionListenerGeneric: Could not load assembly: ";
             ex_str += assemblyPath;
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
           Apache::Geode::Client::Log::Debug("Loading type: [{0}]", mg_typeName);
@@ -134,21 +134,21 @@ namespace apache
             if (types[0] == nullptr || types[1] == nullptr)
             {
               std::string ex_str = "ManagedTransactionListenerGeneric: Could not get both generic type argument instances";
-              throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+              throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
             }
 
             typeInst = typeInst->MakeGenericType(types);
             Apache::Geode::Client::Log::Info("Loading function: [{0}]", mg_factoryFunctionName);
 
-            MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName,
-              BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase );
+            MethodInfo^ mInfo = typeInst->GetMethod(mg_factoryFunctionName,
+                                                    BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase);
 
             if (mInfo != nullptr)
             {
               Object^ userptr = nullptr;
               try
               {
-                userptr = mInfo->Invoke( typeInst, nullptr );
+                userptr = mInfo->Invoke(typeInst, nullptr);
               }
               catch (System::Exception^ ex)
               {
@@ -162,9 +162,9 @@ namespace apache
                 ex_str += factoryFunctionName;
                 ex_str += "] in assembly: ";
                 ex_str += assemblyPath;
-                throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+                throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
               }
-              return new ManagedTransactionListenerGeneric( userptr );
+              return new ManagedTransactionListenerGeneric(userptr);
             }
             else
             {
@@ -173,17 +173,17 @@ namespace apache
               ex_str += factoryFunctionName;
               ex_str += "] in assembly: ";
               ex_str += assemblyPath;
-              throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+              throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
             }
           }
           else
           {
-            Apache::Geode::Client::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: ";
             ex_str += assemblyPath;
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
         }
         catch (const apache::geode::client::Exception&)
@@ -192,21 +192,21 @@ namespace apache
         }
         catch (System::Exception^ ex)
         {
-          Apache::Geode::Client::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;
-          throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+          throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
         }
         return NULL;
       }
-      void ManagedTransactionListenerGeneric::afterCommit(apache::geode::client::TransactionEventPtr& te )
+      void ManagedTransactionListenerGeneric::afterCommit(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in" );
-          Apache::Geode::Client::TransactionEvent  mevent( te.ptr() );
-          m_managedptr->AfterCommit( %mevent );
-          Apache::Geode::Client::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::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
 
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {
@@ -216,11 +216,11 @@ namespace apache
           Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
-      void ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr& te )
+      void ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::TransactionEvent mevent( te.ptr()  );
-          m_managedptr->AfterFailedCommit( %mevent );
+          Apache::Geode::Client::TransactionEvent mevent(te.ptr());
+          m_managedptr->AfterFailedCommit(%mevent);
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();
@@ -229,11 +229,11 @@ namespace apache
           Apache::Geode::Client::GemFireException::ThrowNative(ex);
         }
       }
-      void ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr& te )
+      void ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::TransactionEvent mevent( te.ptr()  );
-          m_managedptr->AfterRollback( %mevent );
+          Apache::Geode::Client::TransactionEvent mevent(te.ptr());
+          m_managedptr->AfterRollback(%mevent);
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/ManagedTransactionWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionWriter.cpp b/src/clicache/src/impl/ManagedTransactionWriter.cpp
index c3f09a9..19bdf8d 100644
--- a/src/clicache/src/impl/ManagedTransactionWriter.cpp
+++ b/src/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -38,15 +38,15 @@ namespace apache
     namespace client
     {
 
-      apache::geode::client::TransactionWriter* ManagedTransactionWriterGeneric::create( const char* assemblyPath,
-        const char* factoryFunctionName )
+      apache::geode::client::TransactionWriter* ManagedTransactionWriterGeneric::create(const char* assemblyPath,
+                                                                                        const char* factoryFunctionName)
       {
         try
         {
           String^ mg_assemblyPath =
-            Apache::Geode::Client::ManagedString::Get( assemblyPath );
+            Apache::Geode::Client::ManagedString::Get(assemblyPath);
           String^ mg_factoryFunctionName =
-            Apache::Geode::Client::ManagedString::Get( factoryFunctionName );
+            Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
           String^ mg_typeName = nullptr;
 
           String^ mg_genericKey = nullptr;
@@ -58,38 +58,38 @@ namespace apache
           int32_t commaIndx = -1;
 
           if (mg_factoryFunctionName == nullptr ||
-            ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 )
+              (dotIndx = mg_factoryFunctionName->LastIndexOf('.')) < 0)
           {
             std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain type name";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
-          if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 )
+          if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf('>')) < 0)
           {
             std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain any generic type parameters";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
-          if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 ||
-            genericsOpenIndx > genericsCloseIndx)
+          if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf('<')) < 0 ||
+              genericsOpenIndx > genericsCloseIndx)
           {
             std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain expected generic type parameters";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
-          if ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 ||
-            (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
+          if ((commaIndx = mg_factoryFunctionName->LastIndexOf(',')) < 0 ||
+              (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
           {
             std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
             ex_str += factoryFunctionName;
             ex_str += "' does not contain expected generic type parameter comma separator";
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
           StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName->Substring(0, genericsOpenIndx));
@@ -98,10 +98,10 @@ namespace apache
           mg_genericKey = mg_genericKey->Trim();
           mg_genericVal = mg_factoryFunctionName->Substring(commaIndx + 1, genericsCloseIndx - commaIndx - 1);
           mg_genericVal = mg_genericVal->Trim();
-          mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx + 1 );
+          mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1);
 
           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);
+                                           mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
 
           typeBuilder->Append("`2");
           mg_typeName = typeBuilder->ToString();
@@ -109,7 +109,7 @@ namespace apache
           Assembly^ assmb = nullptr;
           try
           {
-            assmb = Assembly::Load( mg_assemblyPath );
+            assmb = Assembly::Load(mg_assemblyPath);
           }
           catch (System::Exception^)
           {
@@ -119,7 +119,7 @@ namespace apache
           {
             std::string ex_str = "ManagedTransactionWriterGeneric: Could not load assembly: ";
             ex_str += assemblyPath;
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
 
           Apache::Geode::Client::Log::Debug("Loading type: [{0}]", mg_typeName);
@@ -135,21 +135,21 @@ namespace apache
             if (types[0] == nullptr || types[1] == nullptr)
             {
               std::string ex_str = "ManagedTransactionWriterGeneric: Could not get both generic type argument instances";
-              throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+              throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
             }
 
             typeInst = typeInst->MakeGenericType(types);
             Apache::Geode::Client::Log::Info("Loading function: [{0}]", mg_factoryFunctionName);
 
-            MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName,
-              BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase );
+            MethodInfo^ mInfo = typeInst->GetMethod(mg_factoryFunctionName,
+                                                    BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase);
 
             if (mInfo != nullptr)
             {
               Object^ userptr = nullptr;
               try
               {
-                userptr = mInfo->Invoke( typeInst, nullptr );
+                userptr = mInfo->Invoke(typeInst, nullptr);
               }
               catch (System::Exception^ ex)
               {
@@ -163,9 +163,9 @@ namespace apache
                 ex_str += factoryFunctionName;
                 ex_str += "] in assembly: ";
                 ex_str += assemblyPath;
-                throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+                throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
               }
-              return new ManagedTransactionWriterGeneric( userptr );
+              return new ManagedTransactionWriterGeneric(userptr);
             }
             else
             {
@@ -174,17 +174,17 @@ namespace apache
               ex_str += factoryFunctionName;
               ex_str += "] in assembly: ";
               ex_str += assemblyPath;
-              throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+              throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
             }
           }
           else
           {
-            Apache::Geode::Client::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: ";
             ex_str += assemblyPath;
-            throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+            throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
           }
         }
         catch (const apache::geode::client::Exception&)
@@ -193,19 +193,19 @@ namespace apache
         }
         catch (System::Exception^ ex)
         {
-          Apache::Geode::Client::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;
-          throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+          throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
         }
         return NULL;
       }
-      void ManagedTransactionWriterGeneric::beforeCommit(apache::geode::client::TransactionEventPtr& te )
+      void ManagedTransactionWriterGeneric::beforeCommit(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::TransactionEvent  mevent( te.ptr() );
-          m_managedptr->BeforeCommit( %mevent );
+          Apache::Geode::Client::TransactionEvent  mevent(te.ptr());
+          m_managedptr->BeforeCommit(%mevent);
         }
         catch (Apache::Geode::Client::GemFireException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/PdxFieldType.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxFieldType.cpp b/src/clicache/src/impl/PdxFieldType.cpp
index 083aa7a..04040e2 100644
--- a/src/clicache/src/impl/PdxFieldType.cpp
+++ b/src/clicache/src/impl/PdxFieldType.cpp
@@ -67,39 +67,39 @@ namespace Apache
 
         Int32 PdxFieldType::VarLenOffsetIndex::get()
         {
-          return m_vlOffsetIndex;    
+          return m_vlOffsetIndex;
         }
 
         void PdxFieldType::VarLenOffsetIndex::set(Int32 val)
         {
-          m_vlOffsetIndex = val;    
+          m_vlOffsetIndex = val;
         }
 
         Int32 PdxFieldType::RelativeOffset::get()
         {
-          return m_relativeOffset;    
+          return m_relativeOffset;
         }
 
         void PdxFieldType::RelativeOffset::set(Int32 val)
         {
-          m_relativeOffset = val;    
-        }          
+          m_relativeOffset = val;
+        }
 
-				//it compares fieldname and type-id
-        bool PdxFieldType::Equals(Object^ otherObj) 
+        //it compares fieldname and type-id
+        bool PdxFieldType::Equals(Object^ otherObj)
         {
-          if(otherObj == nullptr)
+          if (otherObj == nullptr)
             return false;
 
           PdxFieldType^ otherFieldType = dynamic_cast<PdxFieldType^>(otherObj);
 
-          if(otherFieldType == nullptr)
+          if (otherFieldType == nullptr)
             return false;
 
-          if(otherFieldType == this)
+          if (otherFieldType == this)
             return true;
 
-          if(otherFieldType->m_fieldName == m_fieldName && otherFieldType->m_typeId == m_typeId)
+          if (otherFieldType->m_fieldName == m_fieldName && otherFieldType->m_typeId == m_typeId)
             return true;
 
           return false;
@@ -108,35 +108,35 @@ namespace Apache
         Int32 PdxFieldType::GetHashCode()
         {
           int hash = m_cachedHashcode;
-          if(hash == 0)
+          if (hash == 0)
           {
-            if(m_fieldName != nullptr) 
+            if (m_fieldName != nullptr)
             {
-              hash = hash*31 + m_fieldName->GetHashCode();
+              hash = hash * 31 + m_fieldName->GetHashCode();
             }
 
             hash = hash * 31 + m_typeId;
-            if(hash == 0)
+            if (hash == 0)
               hash = 1;
             m_cachedHashcode = hash;
           }
-        
+
           return m_cachedHashcode;
         }
 
-        void PdxFieldType::ToData( DataOutput^ output )
+        void PdxFieldType::ToData(DataOutput^ output)
         {
           output->WriteString(m_fieldName);
           output->WriteInt32(m_sequenceId);
           output->WriteInt32(m_varLenFieldIdx);
           output->WriteByte(m_typeId);
-          
+
           output->WriteInt32(m_relativeOffset);
           output->WriteInt32(m_vlOffsetIndex);
           output->WriteBoolean(m_isIdentityField);
         }
-        
-        IGFSerializable^ PdxFieldType::FromData( DataInput^ input )
+
+        IGFSerializable^ PdxFieldType::FromData(DataInput^ input)
         {
           m_fieldName = input->ReadString();
           m_sequenceId = input->ReadInt32();
@@ -149,42 +149,42 @@ namespace Apache
 
           m_fixedSize = getFixedTypeSize();
 
-          if(m_fixedSize != -1)
-						m_isVariableLengthType = false;
+          if (m_fixedSize != -1)
+            m_isVariableLengthType = false;
           else
             m_isVariableLengthType = true;
-          
-					return this;
+
+          return this;
         }
 
         Int32 PdxFieldType::getFixedTypeSize()
         {
-           switch (m_typeId) 
-           {
-           case PdxTypes::BYTE:
-           case PdxTypes::BOOLEAN:
-              return GemFireClassIds::BOOLEAN_SIZE;
-  
-           case PdxTypes::SHORT:
-           case PdxTypes::CHAR:
+          switch (m_typeId)
+          {
+          case PdxTypes::BYTE:
+          case PdxTypes::BOOLEAN:
+            return GeodeClassIds::BOOLEAN_SIZE;
+
+          case PdxTypes::SHORT:
+          case PdxTypes::CHAR:
             //case apache::geode::client::GeodeTypeIds::CacheableChar: //TODO
-              return GemFireClassIds::CHAR_SIZE;
-  
-           case PdxTypes::INT:
-           case PdxTypes::FLOAT:
+            return GeodeClassIds::CHAR_SIZE;
+
+          case PdxTypes::INT:
+          case PdxTypes::FLOAT:
             //case DSCODE.ENUM:
-              return GemFireClassIds::INTEGER_SIZE;
-        
-           case PdxTypes::LONG:
-           case PdxTypes::DOUBLE:
-           case PdxTypes::DATE:
-              return GemFireClassIds::LONG_SIZE;
-        
+            return GeodeClassIds::INTEGER_SIZE;
+
+          case PdxTypes::LONG:
+          case PdxTypes::DOUBLE:
+          case PdxTypes::DATE:
+            return GeodeClassIds::LONG_SIZE;
+
           default:
             return -1;
-    }  // namespace Client
-  }  // namespace Geode
-}  // namespace Apache
+          }  // namespace Client
+        }  // namespace Geode
+      }  // namespace Apache
 
     }
   }

http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/PdxFieldType.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxFieldType.hpp b/src/clicache/src/impl/PdxFieldType.hpp
index ea88ca7..aa0bcfd 100644
--- a/src/clicache/src/impl/PdxFieldType.hpp
+++ b/src/clicache/src/impl/PdxFieldType.hpp
@@ -20,7 +20,7 @@
 using namespace System;
 #include "../DataOutput.hpp"
 #include "../DataInput.hpp"
-#include "../GemFireClassIds.hpp"
+#include "../GeodeClassIds.hpp"
 
 namespace Apache
 {
@@ -49,12 +49,12 @@ namespace Apache
           Int32 getFixedTypeSize();
         public:
           PdxFieldType(String^ fieldName,
-                        String^ className,
-                        Byte typeId,
-                        Int32 sequenceId,
-                        bool isVariableLengthType,
-                        Int32 fixedSize,
-                        Int32 varLenFieldIdx)
+                       String^ className,
+                       Byte typeId,
+                       Int32 sequenceId,
+                       bool isVariableLengthType,
+                       Int32 fixedSize,
+                       Int32 varLenFieldIdx)
           {
             m_cachedHashcode = 0;
             m_fieldName = fieldName;
@@ -99,8 +99,8 @@ namespace Apache
 
           property bool IdentityField
           {
-            bool get() {return m_isIdentityField;}
-            void set(bool value) {m_isIdentityField = value;}
+            bool get() { return m_isIdentityField; }
+            void set(bool value) { m_isIdentityField = value; }
           }
 
           property Int32 Size
@@ -125,26 +125,26 @@ namespace Apache
             void set(Int32 Value);
           }
 
-           virtual bool Equals(Object^ otherObj) override;
-           virtual Int32 GetHashCode() override;
-
-           virtual void ToData( DataOutput^ output );
-           virtual IGFSerializable^ FromData( DataInput^ input );
-           virtual property uint32_t ObjectSize
-           {
-             uint32_t get( ){return 0;}
-           }
-           virtual property uint32_t ClassId
-           {
-             uint32_t get( ){return m_typeId;}
-           }
-           virtual String^ ToString( ) override
-           {
-             return "PdxFieldName:" + m_fieldName + ", TypeId: " + m_typeId + ", VarLenFieldIdx:" + m_varLenFieldIdx + ", sequenceid:" + m_sequenceId;
-           }
+          virtual bool Equals(Object^ otherObj) override;
+          virtual Int32 GetHashCode() override;
+
+          virtual void ToData(DataOutput^ output);
+          virtual IGFSerializable^ FromData(DataInput^ input);
+          virtual property uint32_t ObjectSize
+          {
+            uint32_t get(){ return 0; }
+          }
+          virtual property uint32_t ClassId
+          {
+            uint32_t get(){ return m_typeId; }
+          }
+          virtual String^ ToString() override
+          {
+            return "PdxFieldName:" + m_fieldName + ", TypeId: " + m_typeId + ", VarLenFieldIdx:" + m_varLenFieldIdx + ", sequenceid:" + m_sequenceId;
+          }
         };
-    }  // namespace Client
-  }  // namespace Geode
-}  // namespace Apache
+      }  // namespace Client
+    }  // namespace Geode
+  }  // namespace Apache
 
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp b/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
index 640477f..8790c78 100644
--- a/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
+++ b/src/clicache/src/impl/PdxInstanceFactoryImpl.cpp
@@ -28,326 +28,326 @@ namespace Apache
     namespace Client
     {
 
-        namespace Internal
+      namespace Internal
+      {
+        PdxInstanceFactoryImpl::PdxInstanceFactoryImpl(String^ className)
         {
-          PdxInstanceFactoryImpl::PdxInstanceFactoryImpl(String^ className)
-          {
-            if(className == nullptr)
-             throw gcnew IllegalStateException(
-                "Classname should not be null.");
-            m_pdxType = gcnew PdxType(className, false);
-            m_FieldVsValues = gcnew Dictionary<String^, Object^>();
-            m_created = false;
-          }
+          if (className == nullptr)
+            throw gcnew IllegalStateException(
+            "Classname should not be null.");
+          m_pdxType = gcnew PdxType(className, false);
+          m_FieldVsValues = gcnew Dictionary<String^, Object^>();
+          m_created = false;
+        }
 
-          IPdxInstance^ PdxInstanceFactoryImpl::Create()
+        IPdxInstance^ PdxInstanceFactoryImpl::Create()
+        {
+          if (m_created)
           {
-            if(m_created)
-            {
-              throw gcnew IllegalStateException(
-                "The IPdxInstanceFactory.Create() method can only be called once.");
-            }
-            //need to get typeid;
-            IPdxInstance^ pi = gcnew PdxInstanceImpl(m_FieldVsValues, m_pdxType);
-            m_created = true;
-            return pi;
+            throw gcnew IllegalStateException(
+              "The IPdxInstanceFactory.Create() method can only be called once.");
           }
+          //need to get typeid;
+          IPdxInstance^ pi = gcnew PdxInstanceImpl(m_FieldVsValues, m_pdxType);
+          m_created = true;
+          return pi;
+        }
 
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteChar(String^ fieldName, Char value)
-          {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "char", PdxTypes::CHAR, GemFireClassIds::CHAR_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
-          }
-   
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteBoolean(String^ fieldName, Boolean value)
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteChar(String^ fieldName, Char value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "char", PdxTypes::CHAR, GeodeClassIds::CHAR_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteBoolean(String^ fieldName, Boolean value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "boolean", PdxTypes::BOOLEAN, GeodeClassIds::BOOLEAN_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteByte(String^ fieldName, SByte value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "byte", PdxTypes::BYTE, GeodeClassIds::BYTE_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteShort(String^ fieldName, Int16 value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "short", PdxTypes::SHORT, GeodeClassIds::SHORT_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteInt(String^ fieldName, Int32 value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "int", PdxTypes::INT, GeodeClassIds::INTEGER_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteLong(String^ fieldName, Int64 value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "long", PdxTypes::LONG, GeodeClassIds::LONG_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteFloat(String^ fieldName, float value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "float", PdxTypes::FLOAT, GeodeClassIds::FLOAT_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDouble(String^ fieldName, double value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "double", PdxTypes::DOUBLE, GeodeClassIds::DOUBLE_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDate(String^ fieldName, System::DateTime value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddFixedLengthTypeField(fieldName, "Date", PdxTypes::DATE, GeodeClassIds::DATE_SIZE);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteString(String^ fieldName, String^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "String", PdxTypes::STRING);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteObject(String^ fieldName, Object^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Object", PdxTypes::OBJECT);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteBooleanArray(String^ fieldName, array<Boolean>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "bool[]", PdxTypes::BOOLEAN_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteCharArray(String^ fieldName, array<Char>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "char[]", PdxTypes::CHAR_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteByteArray(String^ fieldName, array<Byte>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "byte[]", PdxTypes::BYTE_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteShortArray(String^ fieldName, array<Int16>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "short[]", PdxTypes::SHORT_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteIntArray(String^ fieldName, array<Int32>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "int[]", PdxTypes::INT_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteLongArray(String^ fieldName, array<Int64>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "long[]", PdxTypes::LONG_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteFloatArray(String^ fieldName, array<float>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "float[]", PdxTypes::FLOAT_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDoubleArray(String^ fieldName, array<double>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "double[]", PdxTypes::DOUBLE_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteStringArray(String^ fieldName, array<String^>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "String[]", PdxTypes::STRING_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteObjectArray(String^ fieldName, System::Collections::Generic::List<Object^>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "Object[]", PdxTypes::OBJECT_ARRAY);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteArrayOfByteArrays(String^ fieldName, array<array<Byte>^>^ value)
+        {
+          isFieldAdded(fieldName);
+          m_pdxType->AddVariableLengthTypeField(fieldName, "byte[][]", PdxTypes::ARRAY_OF_BYTE_ARRAYS);
+          m_FieldVsValues->Add(fieldName, value);
+          return this;
+        }
+
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteField(String^ fieldName, Object^ fieldValue, Type^ type)
+        {
+          isFieldAdded(fieldName);
+          if (type->Equals(DotNetTypes::IntType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "boolean", PdxTypes::BOOLEAN, GemFireClassIds::BOOLEAN_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteInt(fieldName, (int)fieldValue);
           }
-    
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteByte(String^ fieldName, SByte value)
+          else if (type->Equals(DotNetTypes::StringType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "byte", PdxTypes::BYTE, GemFireClassIds::BYTE_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteString(fieldName, (String^)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteShort(String^ fieldName, Int16 value)
+          else if (type->Equals(DotNetTypes::BooleanType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "short", PdxTypes::SHORT, GemFireClassIds::SHORT_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteBoolean(fieldName, (bool)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteInt(String^ fieldName, Int32 value)
+          else if (type->Equals(DotNetTypes::FloatType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "int", PdxTypes::INT, GemFireClassIds::INTEGER_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteFloat(fieldName, (float)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteLong(String^ fieldName, Int64 value)
+          else if (type->Equals(DotNetTypes::DoubleType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "long", PdxTypes::LONG, GemFireClassIds::LONG_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteDouble(fieldName, (double)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteFloat(String^ fieldName, float value)
+          else if (type->Equals(DotNetTypes::CharType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "float", PdxTypes::FLOAT, GemFireClassIds::FLOAT_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteChar(fieldName, (Char)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDouble(String^ fieldName, double value)
+          else if (type->Equals(DotNetTypes::SByteType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "double", PdxTypes::DOUBLE, GemFireClassIds::DOUBLE_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteByte(fieldName, (SByte)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDate(String^ fieldName, System::DateTime value)
+          else if (type->Equals(DotNetTypes::ShortType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddFixedLengthTypeField(fieldName, "Date", PdxTypes::DATE, GemFireClassIds::DATE_SIZE);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteShort(fieldName, (short)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteString(String^ fieldName, String^ value)
+          else if (type->Equals(DotNetTypes::LongType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "String", PdxTypes::STRING);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteLong(fieldName, (Int64)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteObject(String^ fieldName, Object^ value)
+          else if (type->Equals(DotNetTypes::ByteArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Object", PdxTypes::OBJECT);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteByteArray(fieldName, (array<Byte>^)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteBooleanArray(String^ fieldName, array<Boolean>^ value)
+          else if (type->Equals(DotNetTypes::DoubleArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "bool[]", PdxTypes::BOOLEAN_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteDoubleArray(fieldName, (array<double>^)fieldValue);
           }
-  
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteCharArray(String^ fieldName, array<Char>^ value)
+          else if (type->Equals(DotNetTypes::FloatArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "char[]", PdxTypes::CHAR_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteFloatArray(fieldName, (array<float>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteByteArray(String^ fieldName, array<Byte>^ value)
+          else if (type->Equals(DotNetTypes::ShortArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "byte[]", PdxTypes::BYTE_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteShortArray(fieldName, (array<Int16>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteShortArray(String^ fieldName, array<Int16>^ value)
+          else if (type->Equals(DotNetTypes::IntArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "short[]", PdxTypes::SHORT_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteIntArray(fieldName, (array<int32>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteIntArray(String^ fieldName, array<Int32>^ value)
+          else if (type->Equals(DotNetTypes::LongArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "int[]", PdxTypes::INT_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteLongArray(fieldName, (array<Int64>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteLongArray(String^ fieldName, array<Int64>^ value)
+          else if (type->Equals(DotNetTypes::BoolArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "long[]", PdxTypes::LONG_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteBooleanArray(fieldName, (array<bool>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteFloatArray(String^ fieldName, array<float>^ value)
+          else if (type->Equals(DotNetTypes::CharArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "float[]", PdxTypes::FLOAT_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteCharArray(fieldName, (array<Char>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteDoubleArray(String^ fieldName, array<double>^ value)
+          else if (type->Equals(DotNetTypes::StringArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "double[]", PdxTypes::DOUBLE_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteStringArray(fieldName, (array<String^>^)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteStringArray(String^ fieldName, array<String^>^ value)
+          else if (type->Equals(DotNetTypes::DateType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "String[]", PdxTypes::STRING_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteDate(fieldName, (DateTime)fieldValue);
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteObjectArray(String^ fieldName, System::Collections::Generic::List<Object^>^ value)
+          else if (type->Equals(DotNetTypes::ByteArrayOfArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "Object[]", PdxTypes::OBJECT_ARRAY);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteArrayOfByteArrays(fieldName, (array<array<Byte>^>^)fieldValue);
           }
-              
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteArrayOfByteArrays(String^ fieldName, array<array<Byte>^>^ value)
+          else if (type->Equals(DotNetTypes::ObjectArrayType))
           {
-            isFieldAdded(fieldName);
-            m_pdxType->AddVariableLengthTypeField(fieldName, "byte[][]", PdxTypes::ARRAY_OF_BYTE_ARRAYS);
-            m_FieldVsValues->Add(fieldName, value);
-            return this;
+            return this->WriteObjectArray(fieldName, safe_cast<System::Collections::Generic::List<Object^>^>(fieldValue));
           }
-        
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::WriteField(String^ fieldName, Object^ fieldValue, Type^ type)
+          else
           {
-            isFieldAdded(fieldName);
-            if(type->Equals(DotNetTypes::IntType))
-            {
-              return this->WriteInt(fieldName, (int)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::StringType))
-            {
-              return this->WriteString(fieldName, (String^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::BooleanType))
-            {
-              return this->WriteBoolean(fieldName, (bool)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::FloatType))
-            {
-              return this->WriteFloat(fieldName, (float)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::DoubleType))
-            {
-              return this->WriteDouble(fieldName, (double)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::CharType))
-            {
-              return this->WriteChar(fieldName, (Char)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::SByteType))
-            {
-              return this->WriteByte(fieldName, (SByte)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::ShortType))
-            {
-              return this->WriteShort(fieldName, (short)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::LongType))
-            {
-              return this->WriteLong(fieldName, (Int64)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::ByteArrayType))
-            {
-              return this->WriteByteArray(fieldName, (array<Byte>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::DoubleArrayType))
-            {
-              return this->WriteDoubleArray(fieldName, (array<double>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::FloatArrayType))
-            {
-              return this->WriteFloatArray(fieldName, (array<float>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::ShortArrayType))
-            {
-              return this->WriteShortArray(fieldName, (array<Int16>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::IntArrayType))
-            {
-              return this->WriteIntArray(fieldName, (array<int32>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::LongArrayType))
-            {
-              return this->WriteLongArray(fieldName, (array<Int64>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::BoolArrayType))
-            {
-              return this->WriteBooleanArray(fieldName, (array<bool>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::CharArrayType))
-            {
-              return this->WriteCharArray(fieldName, (array<Char>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::StringArrayType))
-            {
-              return this->WriteStringArray(fieldName, (array<String^>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::DateType))
-            {
-              return this->WriteDate(fieldName, (DateTime)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::ByteArrayOfArrayType))
-            {
-              return this->WriteArrayOfByteArrays(fieldName, (array<array<Byte>^>^)fieldValue);
-            }
-            else if(type->Equals(DotNetTypes::ObjectArrayType))
-            {
-              return this->WriteObjectArray(fieldName, safe_cast<System::Collections::Generic::List<Object^>^>(fieldValue));
-            }
-            else
-            {
-              return this->WriteObject(fieldName, fieldValue);
-              //throw gcnew IllegalStateException("WriteField unable to serialize  " 
-								//																	+ fieldName + " of " + type); 
-            }
-           // return this;
+            return this->WriteObject(fieldName, fieldValue);
+            //throw gcnew IllegalStateException("WriteField unable to serialize  " 
+            //																	+ fieldName + " of " + type); 
           }
-                
-          IPdxInstanceFactory^ PdxInstanceFactoryImpl::MarkIdentityField(String^ fieldName)
-          {
-            PdxFieldType^ pft = m_pdxType->GetPdxField(fieldName);
+          // return this;
+        }
 
-            if(pft == nullptr)
-            {
-              throw gcnew IllegalStateException(
-                "Field must be added before calling MarkIdentityField ");
-            }
+        IPdxInstanceFactory^ PdxInstanceFactoryImpl::MarkIdentityField(String^ fieldName)
+        {
+          PdxFieldType^ pft = m_pdxType->GetPdxField(fieldName);
 
-            pft->IdentityField = true;
-            return this;
+          if (pft == nullptr)
+          {
+            throw gcnew IllegalStateException(
+              "Field must be added before calling MarkIdentityField ");
           }
 
-          void PdxInstanceFactoryImpl::isFieldAdded(String^ fieldName)
+          pft->IdentityField = true;
+          return this;
+        }
+
+        void PdxInstanceFactoryImpl::isFieldAdded(String^ fieldName)
+        {
+          if (fieldName == nullptr || fieldName->Length == 0 || m_FieldVsValues->ContainsKey(fieldName))
           {
-            if(fieldName == nullptr || fieldName->Length == 0 || m_FieldVsValues->ContainsKey(fieldName))
-            {
-              throw gcnew IllegalStateException(
-                "Field: " + fieldName + " either already added into PdxInstanceFactory or it is null");
-    }  // namespace Client
-  }  // namespace Geode
-}  // namespace Apache
+            throw gcnew IllegalStateException(
+              "Field: " + fieldName + " either already added into PdxInstanceFactory or it is null");
+          }  // namespace Client
+        }  // namespace Geode
+      }  // namespace Apache
 
     }
   }


Mime
View raw message