geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [02/18] geode git commit: GEODE-2365: Replace gemfire with geode in clicache.
Date Thu, 02 Feb 2017 22:27:52 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/PdxInstanceImpl.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.hpp b/src/clicache/src/impl/PdxInstanceImpl.hpp
index 41b71be..3095ccc 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.hpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.hpp
@@ -29,48 +29,48 @@ namespace Apache
     namespace Client
     {
 
-        namespace Internal
-        {
+      namespace Internal
+      {
         ref class PdxType;
-				/// <summary>
-				/// Serialize the data in gemfire Portable Data eXchange(Pdx) Format.
-				/// This format provides class versioning(forward and backward compability of types) in cache.
-				/// This provides ability to query .NET domian objects.
-				/// </summary>
+        /// <summary>
+        /// Serialize the data in geode Portable Data eXchange(Pdx) Format.
+        /// This format provides class versioning(forward and backward compability of types) in cache.
+        /// This provides ability to query .NET domian objects.
+        /// </summary>
         ref class PdxInstanceImpl : IWritablePdxInstance, IPdxInstance, IPdxSerializable
-				{
+        {
         private:
-         static array<SByte>^ Boolean_DefaultBytes = gcnew array<SByte>{0};
-         static array<SByte>^ Byte_DefaultBytes = gcnew array<SByte>{0};
-         static array<SByte>^ Char_DefaultBytes = gcnew array<SByte>{0, 0};
-         static array<SByte>^ Short_DefaultBytes = gcnew array<SByte>{0, 0};
-         static array<SByte>^ Int_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
-         static array<SByte>^ Long_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
-         static array<SByte>^ Float_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
-         static array<SByte>^ Double_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
-         static array<SByte>^ Date_DefaultBytes = gcnew array<SByte>{-1, -1, -1, -1, -1, -1, -1, -1};
-         static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::CacheableNullString};
-         static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::NullObj};
-         static array<SByte>^ NULL_ARRAY_DefaultBytes = gcnew array<SByte>{-1};
-
-         static PdxFieldType^ Default_PdxFieldType = gcnew PdxFieldType("default", "default", -1,
-																										-1/*field index*/, 
-																										false, 1, -1/*var len field idx*/);
-
-         bool hasDefaultBytes(PdxFieldType^ pField, DataInput^ dataInput, int start, int end);
-         bool compareDefaulBytes(DataInput^ dataInput, int start, int end, array<SByte>^ defaultBytes);
-
-         void cleanup();
-
-       
+          static array<SByte>^ Boolean_DefaultBytes = gcnew array<SByte>{0};
+          static array<SByte>^ Byte_DefaultBytes = gcnew array<SByte>{0};
+          static array<SByte>^ Char_DefaultBytes = gcnew array<SByte>{0, 0};
+          static array<SByte>^ Short_DefaultBytes = gcnew array<SByte>{0, 0};
+          static array<SByte>^ Int_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
+          static array<SByte>^ Long_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
+          static array<SByte>^ Float_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
+          static array<SByte>^ Double_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
+          static array<SByte>^ Date_DefaultBytes = gcnew array<SByte>{-1, -1, -1, -1, -1, -1, -1, -1};
+          static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::CacheableNullString};
+          static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{apache::geode::client::GeodeTypeIds::NullObj};
+          static array<SByte>^ NULL_ARRAY_DefaultBytes = gcnew array<SByte>{-1};
+
+          static PdxFieldType^ Default_PdxFieldType = gcnew PdxFieldType("default", "default", -1,
+                                                                         -1/*field index*/,
+                                                                         false, 1, -1/*var len field idx*/);
+
+          bool hasDefaultBytes(PdxFieldType^ pField, DataInput^ dataInput, int start, int end);
+          bool compareDefaulBytes(DataInput^ dataInput, int start, int end, array<SByte>^ defaultBytes);
+
+          void cleanup();
+
+
           //DataInput^ m_dataInput;
           uint8_t* m_buffer;
           int m_bufferLength;
           int m_typeId;
           bool m_own;
           PdxType^ m_pdxType;
-         internal:
-          Dictionary<String^, Object^>^ m_updatedFields;                  
+        internal:
+          Dictionary<String^, Object^>^ m_updatedFields;
 
           Object^ readField(DataInput^ dataInput, String^ fieldName, int typeId);
 
@@ -95,8 +95,8 @@ namespace Apache
           static int deepArrayHashCode(Object^ obj);
 
           generic <class T>where T:System::Collections::ICollection, System::Collections::IList, System::Collections::IEnumerable
-          static int primitiveArrayHashCode(T objArray) ;
-          
+          static int primitiveArrayHashCode(T objArray);
+
           static int enumerableHashCode(System::Collections::IEnumerable^ enumObj);
 
           static int enumerateDictionary(System::Collections::IDictionary^ iDict);
@@ -108,7 +108,7 @@ namespace Apache
           void equatePdxFields(IList<PdxFieldType^>^ my, IList<PdxFieldType^>^ other);
 
           //bool compareRawBytes(PdxInstanceImpl^ other, PdxType^ myPT,  PdxFieldType^ myF, PdxType^ otherPT,  PdxFieldType^ otherF);
-          bool compareRawBytes(PdxInstanceImpl^ other, PdxType^ myPT,  PdxFieldType^ myF,DataInput^ myDataInput, PdxType^ otherPT,  PdxFieldType^ otherF, DataInput^ otherDataInput);
+          bool compareRawBytes(PdxInstanceImpl^ other, PdxType^ myPT, PdxFieldType^ myF, DataInput^ myDataInput, PdxType^ otherPT, PdxFieldType^ otherF, DataInput^ otherDataInput);
 
           static bool enumerateDictionaryForEqual(System::Collections::IDictionary^ iDict, System::Collections::IDictionary^ otherIDict);
 
@@ -119,7 +119,7 @@ namespace Apache
           void updatePdxStream(uint8_t* newPdxStream, int len);
 
         public:
-          PdxInstanceImpl (uint8_t* buffer, int length, int typeId, bool own)
+          PdxInstanceImpl(uint8_t* buffer, int length, int typeId, bool own)
           {
             //m_dataInput = dataInput;
             m_buffer = buffer;
@@ -131,9 +131,9 @@ namespace Apache
           }
 
           //for pdxInstance factory
-          PdxInstanceImpl(Dictionary<String^, Object^>^ fieldVsValue, PdxType^ pdxType);          
+          PdxInstanceImpl(Dictionary<String^, Object^>^ fieldVsValue, PdxType^ pdxType);
 
-          ~PdxInstanceImpl( ) 
+          ~PdxInstanceImpl()
           {
             cleanup();
           }
@@ -141,130 +141,130 @@ namespace Apache
           {
             cleanup();
           }
-          
+
           PdxType^ getPdxType();
 
           void setPdxId(Int32 typeId);
 
           virtual String^ GetClassName();
 
-           /// <summary> 
-           ///Deserializes and returns the domain object that this instance represents.
-           ///
-           ///@return the deserialized domain object.
-           ///@throws PdxSerializationException if the instance could not be deserialized
-           /// </summary>
+          /// <summary> 
+          ///Deserializes and returns the domain object that this instance represents.
+          ///
+          ///@return the deserialized domain object.
+          ///@throws PdxSerializationException if the instance could not be deserialized
+          /// </summary>
           virtual Object^ GetObject();
 
-           /// <summary>
-           ///Checks if the named field exists and returns the result.
-           ///This can be useful when writing code that handles more than one version of
-           ///a PDX class.
-           ///@param fieldName the name of the field to check
-           ///@return <code>true</code> if the named field exists; otherwise <code>false</code>
-           /// </summary>
+          /// <summary>
+          ///Checks if the named field exists and returns the result.
+          ///This can be useful when writing code that handles more than one version of
+          ///a PDX class.
+          ///@param fieldName the name of the field to check
+          ///@return <code>true</code> if the named field exists; otherwise <code>false</code>
+          /// </summary>
           virtual bool HasField(String^ fieldName);
-          
-            /// <summary>
-            ///Return an unmodifiable list of the field names on this PdxInstance.
-            ///@return an unmodifiable list of the field names on this PdxInstance
-            /// </summary>
+
+          /// <summary>
+          ///Return an unmodifiable list of the field names on this PdxInstance.
+          ///@return an unmodifiable list of the field names on this PdxInstance
+          /// </summary>
           virtual IList<String^>^ GetFieldNames();
-          
-           /// <summary>
-           ///Checks if the named field was {@link PdxWriter#markIdentityField(String) marked} as an identity field.
-           ///Note that if no fields have been marked then all the fields are used as identity fields even though
-           ///this method will return <code>false</code> since none of them have been <em>marked</em>.
-           ///@param fieldName the name of the field to check
-           ///@return <code>true</code> if the named field exists and was marked as an identify field; otherwise <code>false</code>
-           /// </summary>
+
+          /// <summary>
+          ///Checks if the named field was {@link PdxWriter#markIdentityField(String) marked} as an identity field.
+          ///Note that if no fields have been marked then all the fields are used as identity fields even though
+          ///this method will return <code>false</code> since none of them have been <em>marked</em>.
+          ///@param fieldName the name of the field to check
+          ///@return <code>true</code> if the named field exists and was marked as an identify field; otherwise <code>false</code>
+          /// </summary>
           virtual bool IsIdentityField(String^ fieldName);
 
-           /// <summary>
-           ///Reads the named field and returns its value. If the field does
-           ///not exist <code>null</code> is returned.
-           ///A <code>null</code> result indicates that the field does not exist
-           ///or that it exists and its value is currently <code>null</code>.
-           ///The {@link #hasField(String) hasField} method can be used to figure out
-           ///which if these two cases is true.
-           ///If an Object[] is deserialized by this call then that array's component
-           ///type will be <code>Object.class</code> instead of the original class that
-           ///the array had when it was serialized. This is done so that PdxInstance objects
-           ///can be added to the array.
-           /// 
-           ///@param fieldName
-           ///         name of the field to read
-           ///
-           ///@return If this instance has the named field then the field's value is returned,
-           ///otherwise <code>null</code> is returned.
-           ///@throws PdxSerializationException if the field could not be deserialized
-           /// </summary>
-           virtual  Object^ GetField(String^ fieldName);
-
-           /// <summary>
-           ///Returns true if the given object is equals to this instance.
-           ///If <code>other</code> is not a PdxInstance then it is not equal to this instance.
-           ///NOTE: Even if <code>other</code> is the result of calling {@link #getObject()} it will not
-           ///be equal to this instance.
-           ///Otherwise equality of two PdxInstances is determined as follows:
-           ///<ol>
-           ///<li>The domain class name must be equal for both PdxInstances</li>
-           ///<li>Each identity field must be equal.</li>
-           ///</ol>
-           ///If one of the instances does not have a field that the other one does then equals will assume it
-           ///has the field with a default value.
-           ///If a PdxInstance has marked identity fields using {@link PdxWriter#markIdentityField(String) markIdentityField}
-           ///then only the marked identity fields are its identity fields.
-           ///Otherwise all its fields are identity fields.
-           ///An identity field is equal if all the following are true:
-           ///<ol>
-           ///<li>The field name is equal.</li>
-           ///<li>The field type is equal.</li>
-           ///<li>The field value is equal.</li>
-           ///</ol>
-           ///If a field's type is <code>OBJECT</code> then its value must be deserialized to determine if it is equals. If the deserialized object is an array then {@link java.util.Arrays#deepEquals(Object[], Object[]) deepEquals} is used to determine equality. Otherwise {@link Object#equals(Object) equals} is used.
-           ///If a field's type is <code>OBJECT[]</code> then its value must be deserialized and {@link java.util.Arrays#deepEquals(Object[], Object[]) deepEquals} is used to determine equality.
-           ///For all other field types then the value does not need to be deserialized. Instead the serialized raw bytes are compared and used to determine equality.
-           ///Note that any fields that have objects that do not override {@link Object#equals(Object) equals} will cause equals to return false when you might have expected it to return true.
-           ///The only exceptions to this are those that call {@link java.util.Arrays#deepEquals(Object[], Object[]) deepEquals} as noted above. You should either override equals and hashCode in these cases
-           ///or mark other fields as your identity fields.  
-           ///@param other the other instance to compare to this.
-           ///@return <code>true</code> if this instance is equal to <code>other</code>.
-           /// </summary>
-           virtual bool Equals(Object^ other) override;
-
-           /// <summary>
-           ///Generates a hashCode based on the identity fields of
-           ///this PdxInstance. 
-           ///If a PdxInstance has marked identity fields using {@link PdxWriter#markIdentityField(String) markIdentityField}
-           ///then only the marked identity fields are its identity fields.
-           ///Otherwise all its fields are identity fields.
-           ///
-           ///If an identity field is of type <code>OBJECT</code> then it is deserialized. If the deserialized object is an array then {@link java.util.Arrays#deepHashCode(Object[]) deepHashCode} is used. Otherwise {@link Object#hashCode() hashCode} is used.
-           ///If an identity field is of type <code>OBJECT[]</code> this it is deserialized and {@link java.util.Arrays#deepHashCode(Object[]) deepHashCode} is used.
-           ///Otherwise the field is not deserialized and the raw bytes of its value are used to compute the hash code.
-           /// </summary>
-           virtual int GetHashCode()  override;
-
-           /// <summary>
-           ///Prints out all of the identity fields of this PdxInstance.
-           ///If a PdxInstance has marked identity fields using {@link PdxWriter#markIdentityField(String) markIdentityField}
-           ///then only the marked identity fields are its identity fields.
-           ///Otherwise all its fields are identity fields.
-           /// </summary>
-           virtual String^ ToString()  override;
-          
-           /// <summary>
-           ///Creates and returns a {@link WritablePdxInstance} whose initial
-           ///values are those of this PdxInstance.
-           ///This call returns a copy of the current field values so modifications
-           ///made to the returned value will not modify this PdxInstance.
-           ///
-           ///@return a {@link WritablePdxInstance}
-           /// </summary>
-           virtual IWritablePdxInstance^ CreateWriter();
-
-            /// <summary>
+          /// <summary>
+          ///Reads the named field and returns its value. If the field does
+          ///not exist <code>null</code> is returned.
+          ///A <code>null</code> result indicates that the field does not exist
+          ///or that it exists and its value is currently <code>null</code>.
+          ///The {@link #hasField(String) hasField} method can be used to figure out
+          ///which if these two cases is true.
+          ///If an Object[] is deserialized by this call then that array's component
+          ///type will be <code>Object.class</code> instead of the original class that
+          ///the array had when it was serialized. This is done so that PdxInstance objects
+          ///can be added to the array.
+          /// 
+          ///@param fieldName
+          ///         name of the field to read
+          ///
+          ///@return If this instance has the named field then the field's value is returned,
+          ///otherwise <code>null</code> is returned.
+          ///@throws PdxSerializationException if the field could not be deserialized
+          /// </summary>
+          virtual  Object^ GetField(String^ fieldName);
+
+          /// <summary>
+          ///Returns true if the given object is equals to this instance.
+          ///If <code>other</code> is not a PdxInstance then it is not equal to this instance.
+          ///NOTE: Even if <code>other</code> is the result of calling {@link #getObject()} it will not
+          ///be equal to this instance.
+          ///Otherwise equality of two PdxInstances is determined as follows:
+          ///<ol>
+          ///<li>The domain class name must be equal for both PdxInstances</li>
+          ///<li>Each identity field must be equal.</li>
+          ///</ol>
+          ///If one of the instances does not have a field that the other one does then equals will assume it
+          ///has the field with a default value.
+          ///If a PdxInstance has marked identity fields using {@link PdxWriter#markIdentityField(String) markIdentityField}
+          ///then only the marked identity fields are its identity fields.
+          ///Otherwise all its fields are identity fields.
+          ///An identity field is equal if all the following are true:
+          ///<ol>
+          ///<li>The field name is equal.</li>
+          ///<li>The field type is equal.</li>
+          ///<li>The field value is equal.</li>
+          ///</ol>
+          ///If a field's type is <code>OBJECT</code> then its value must be deserialized to determine if it is equals. If the deserialized object is an array then {@link java.util.Arrays#deepEquals(Object[], Object[]) deepEquals} is used to determine equality. Otherwise {@link Object#equals(Object) equals} is used.
+          ///If a field's type is <code>OBJECT[]</code> then its value must be deserialized and {@link java.util.Arrays#deepEquals(Object[], Object[]) deepEquals} is used to determine equality.
+          ///For all other field types then the value does not need to be deserialized. Instead the serialized raw bytes are compared and used to determine equality.
+          ///Note that any fields that have objects that do not override {@link Object#equals(Object) equals} will cause equals to return false when you might have expected it to return true.
+          ///The only exceptions to this are those that call {@link java.util.Arrays#deepEquals(Object[], Object[]) deepEquals} as noted above. You should either override equals and hashCode in these cases
+          ///or mark other fields as your identity fields.  
+          ///@param other the other instance to compare to this.
+          ///@return <code>true</code> if this instance is equal to <code>other</code>.
+          /// </summary>
+          virtual bool Equals(Object^ other) override;
+
+          /// <summary>
+          ///Generates a hashCode based on the identity fields of
+          ///this PdxInstance. 
+          ///If a PdxInstance has marked identity fields using {@link PdxWriter#markIdentityField(String) markIdentityField}
+          ///then only the marked identity fields are its identity fields.
+          ///Otherwise all its fields are identity fields.
+          ///
+          ///If an identity field is of type <code>OBJECT</code> then it is deserialized. If the deserialized object is an array then {@link java.util.Arrays#deepHashCode(Object[]) deepHashCode} is used. Otherwise {@link Object#hashCode() hashCode} is used.
+          ///If an identity field is of type <code>OBJECT[]</code> this it is deserialized and {@link java.util.Arrays#deepHashCode(Object[]) deepHashCode} is used.
+          ///Otherwise the field is not deserialized and the raw bytes of its value are used to compute the hash code.
+          /// </summary>
+          virtual int GetHashCode()  override;
+
+          /// <summary>
+          ///Prints out all of the identity fields of this PdxInstance.
+          ///If a PdxInstance has marked identity fields using {@link PdxWriter#markIdentityField(String) markIdentityField}
+          ///then only the marked identity fields are its identity fields.
+          ///Otherwise all its fields are identity fields.
+          /// </summary>
+          virtual String^ ToString()  override;
+
+          /// <summary>
+          ///Creates and returns a {@link WritablePdxInstance} whose initial
+          ///values are those of this PdxInstance.
+          ///This call returns a copy of the current field values so modifications
+          ///made to the returned value will not modify this PdxInstance.
+          ///
+          ///@return a {@link WritablePdxInstance}
+          /// </summary>
+          virtual IWritablePdxInstance^ CreateWriter();
+
+          /// <summary>
           ///Set the existing named field to the given value.
           ///The setField method has copy-on-write semantics.
           /// So for the modifications to be stored in the cache the WritablePdxInstance 
@@ -279,13 +279,13 @@ namespace Apache
           /// </summary>
           virtual void SetField(String^ fieldName, Object^ value);
 
-          virtual void ToData( IPdxWriter^ writer );
-          
-          virtual void FromData( IPdxReader^ reader );          
+          virtual void ToData(IPdxWriter^ writer);
+
+          virtual void FromData(IPdxReader^ reader);
 
-				};
-    }  // 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/PdxLocalWriter.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxLocalWriter.hpp b/src/clicache/src/impl/PdxLocalWriter.hpp
index e98755b..445a101 100644
--- a/src/clicache/src/impl/PdxLocalWriter.hpp
+++ b/src/clicache/src/impl/PdxLocalWriter.hpp
@@ -20,7 +20,7 @@
 #include "../gf_defs.hpp"
 #include "../IPdxWriter.hpp"
 #include "PdxType.hpp"
-#include "../GemFireClassIds.hpp"
+#include "../GeodeClassIds.hpp"
 #include "PdxRemotePreservedData.hpp"
 using namespace System;
 
@@ -36,17 +36,17 @@ namespace Apache
       {
         ref class PdxLocalWriter : public IPdxWriter
         {
-        protected:            
-            PdxType^      m_pdxType;
-            DataOutput^   m_dataOutput;
-            uint8_t*      m_startPosition;
-            Int32         m_startPositionOffset;
-            String^         m_domainClassName;
-            array<int>^   m_offsets;
-            Int32         m_currentOffsetIndex;            
-            PdxRemotePreservedData^ m_preserveData;
-            //Type^       m_pdxDomainType;
-            String^       m_pdxClassName;
+        protected:
+          PdxType^      m_pdxType;
+          DataOutput^   m_dataOutput;
+          uint8_t*      m_startPosition;
+          Int32         m_startPositionOffset;
+          String^         m_domainClassName;
+          array<int>^   m_offsets;
+          Int32         m_currentOffsetIndex;
+          PdxRemotePreservedData^ m_preserveData;
+          //Type^       m_pdxDomainType;
+          String^       m_pdxClassName;
 
         public:
 
@@ -56,7 +56,7 @@ namespace Apache
             m_pdxType = pdxType;
             m_currentOffsetIndex = 0;
             m_preserveData = nullptr;
-            if(pdxType != nullptr)
+            if (pdxType != nullptr)
               m_pdxClassName = pdxType->PdxClassName;
             //m_pdxDomainType = nullptr;
             initialize();
@@ -68,16 +68,16 @@ namespace Apache
             m_pdxType = pdxType;
             m_currentOffsetIndex = 0;
             m_preserveData = nullptr;
-           // m_pdxDomainType = pdxDomainType;
+            // m_pdxDomainType = pdxDomainType;
             m_pdxClassName = pdxClassName;
             initialize();
           }
 
-          void initialize();          
+          void initialize();
 
-          virtual void AddOffset();          
+          virtual void AddOffset();
 
-          virtual void EndObjectWriting(); 
+          virtual void EndObjectWriting();
 
           //this is used to get pdx stream when WriteablePdxStream udpadates the field
           //It should be called after pdx stream has been written to output
@@ -95,83 +95,83 @@ namespace Apache
           {
             return m_startPositionOffset;
           }
-          
+
           /// <summary>
           /// Write a byte to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The byte to write.</param>
-          virtual IPdxWriter^ WriteByte( String^ fieldName, SByte value );
+          virtual IPdxWriter^ WriteByte(String^ fieldName, SByte value);
 
           /// <summary>
           /// Write a signed byte to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The signed byte to write.</param>
-          virtual IPdxWriter^ WriteSByte( String^ fieldName, SByte value );
+          virtual IPdxWriter^ WriteSByte(String^ fieldName, SByte value);
 
           /// <summary>
           /// Write a boolean value to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The boolean value to write.</param>
-					virtual IPdxWriter^ WriteBoolean( String^ fieldName, Boolean value );
+          virtual IPdxWriter^ WriteBoolean(String^ fieldName, Boolean value);
 
           /// <summary>
           /// Write a char value to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The char value to write.</param>
-          virtual IPdxWriter^ WriteChar( String^ fieldName, Char value );
-                       
+          virtual IPdxWriter^ WriteChar(String^ fieldName, Char value);
+
           /// <summary>
           /// Write an unsigned short integer (int16_t) to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The unsigned 16-bit integer to write.</param>
-          virtual IPdxWriter^ WriteUInt16( String^ fieldName, uint16_t value );
+          virtual IPdxWriter^ WriteUInt16(String^ fieldName, uint16_t value);
 
           /// <summary>
           /// Write an unsigned 32-bit integer to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The unsigned 32-bit integer to write.</param>
-          virtual IPdxWriter^ WriteUInt32( String^ fieldName, uint32_t value );
+          virtual IPdxWriter^ WriteUInt32(String^ fieldName, uint32_t value);
 
           /// <summary>
           /// Write an unsigned 64-bit integer to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The unsigned 64-bit integer to write.</param>
-          virtual IPdxWriter^ WriteUInt64( String^ fieldName, uint64_t value );
+          virtual IPdxWriter^ WriteUInt64(String^ fieldName, uint64_t value);
 
           /// <summary>
           /// Write a 16-bit integer to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The 16-bit integer to write.</param>
-          virtual IPdxWriter^ WriteShort( String^ fieldName, short value );
+          virtual IPdxWriter^ WriteShort(String^ fieldName, short value);
 
           /// <summary>
           /// Write a 32-bit integer to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The 32-bit integer to write.</param>
-					virtual IPdxWriter^ WriteInt( String^ fieldName, Int32 value );
+          virtual IPdxWriter^ WriteInt(String^ fieldName, Int32 value);
 
           /// <summary>
           /// Write a 64-bit integer to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The 64-bit integer to write.</param>
-          virtual IPdxWriter^ WriteLong( String^ fieldName, Int64 value );
+          virtual IPdxWriter^ WriteLong(String^ fieldName, Int64 value);
 
           /// <summary>
           /// Write a float to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The float value to write.</param>
-          virtual IPdxWriter^ WriteFloat( String^ fieldName, float value );
+          virtual IPdxWriter^ WriteFloat(String^ fieldName, float value);
 
           /// <summary>
           /// Write a double precision real number to the <c>IPdxWriter</c>.
@@ -180,7 +180,7 @@ namespace Apache
           /// <param name="value">
           /// The double precision real number to write.
           /// </param>
-          virtual IPdxWriter^ WriteDouble( String^ fieldName, double value );
+          virtual IPdxWriter^ WriteDouble(String^ fieldName, double value);
 
           /// <summary>
           /// Write a string using java-modified UTF-8 encoding to
@@ -190,7 +190,7 @@ namespace Apache
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The UTF encoded string to write.</param>
-          virtual IPdxWriter^ WriteString( String^ fieldName, String^ value );
+          virtual IPdxWriter^ WriteString(String^ fieldName, String^ value);
 
           /// <summary>
           /// Write a string using java-modified UTF-8 encoding to
@@ -199,7 +199,7 @@ namespace Apache
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The UTF encoded string to write.</param>
-          virtual IPdxWriter^ WriteUTFHuge( String^ fieldName, String^ value );
+          virtual IPdxWriter^ WriteUTFHuge(String^ fieldName, String^ value);
 
           /// <summary>
           /// Write a string(only ASCII char) to
@@ -208,14 +208,14 @@ namespace Apache
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="value">The UTF encoded string to write.</param>
-          virtual IPdxWriter^ WriteASCIIHuge( String^ fieldName, String^ value );
+          virtual IPdxWriter^ WriteASCIIHuge(String^ fieldName, String^ value);
 
           /// <summary>
           /// Write an <c>Object</c> object to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="obj">The object to write.</param>
-          virtual IPdxWriter^ WriteObject( String^ fieldName, Object^ obj );
+          virtual IPdxWriter^ WriteObject(String^ fieldName, Object^ obj);
 
           //TODO:
           //virtual IPdxWriter^ WriteMap( String^ fieldName, System::Collections::IDictionary^ map );
@@ -225,15 +225,15 @@ namespace Apache
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="collection">The collection to write.</param>
-          virtual IPdxWriter^ WriteCollection( String^ fieldName, System::Collections::IList^ collection);
+          virtual IPdxWriter^ WriteCollection(String^ fieldName, System::Collections::IList^ collection);
 
           /// <summary>
           /// Write an collection to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="date">The date to write.</param>
-          virtual IPdxWriter^ WriteDate( String^ fieldName, System::DateTime date);
-          
+          virtual IPdxWriter^ WriteDate(String^ fieldName, System::DateTime date);
+
           //TODO:
           //virtual IPdxWriter^ writeFile(String fieldName, File file) ;
 
@@ -242,21 +242,21 @@ namespace Apache
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="boolArray">The boolArray to write.</param>
-					virtual IPdxWriter^ WriteBooleanArray( String^ fieldName, array<Boolean>^ boolArray);
+          virtual IPdxWriter^ WriteBooleanArray(String^ fieldName, array<Boolean>^ boolArray);
 
           /// <summary>
           /// Write an collection to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="charArray">The charArray to write.</param>
-          virtual IPdxWriter^ WriteCharArray(String^ fieldName, array<Char>^ charArray) ;
+          virtual IPdxWriter^ WriteCharArray(String^ fieldName, array<Char>^ charArray);
 
           /// <summary>
           /// Write an collection to the <c>IPdxWriter</c>.
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="byteArray">The byteArray to write.</param>
-					virtual IPdxWriter^ WriteByteArray(String^ fieldName, array<Byte>^ byteArray) ;
+          virtual IPdxWriter^ WriteByteArray(String^ fieldName, array<Byte>^ byteArray);
 
           /// <summary>
           /// Write an collection to the <c>IPdxWriter</c>.
@@ -298,7 +298,7 @@ namespace Apache
           /// </summary>
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="longArray">The longArray to write.</param>
-					virtual IPdxWriter^ WriteLongArray(String^ fieldName, array<Int64>^ longArray);
+          virtual IPdxWriter^ WriteLongArray(String^ fieldName, array<Int64>^ longArray);
 
           /// <summary>
           /// Write an collection to the <c>IPdxWriter</c>.
@@ -341,29 +341,29 @@ namespace Apache
           /// <param name="fieldName">The name of the field associated with the value.</param>
           /// <param name="byteArrays">The byteArrays to write.</param>
           virtual IPdxWriter^ WriteArrayOfByteArrays(String^ fieldName, array<array<Byte>^>^ byteArrays);
-          
+
           //TODO:
           //virtual IPdxWriter^ WriteEnum(String^ fieldName, Enum e) ;
           //virtual IPdxWriter^ WriteInetAddress(String^ fieldName, InetAddress address);
 
-          
+
           virtual IPdxWriter^ MarkIdentityField(String^ fieldName);
 
           virtual IPdxWriter^ WriteUnreadFields(IPdxUnreadFields^ unread);
 
-           /// <summary>
-					/// Writes the named field with the given value and type to the serialized form.
+          /// <summary>
+          /// Writes the named field with the given value and type to the serialized form.
           /// This method uses the <code>fieldType</code> to determine which WriteXXX method it should call.
           /// If it can not find a specific match to a writeXXX method it will call <see cref="WriteObject(String^, Object^)">.
-					/// 
-					/// </summary>
-					/// <returns>this PdxWriter</returns>
+          /// 
+          /// </summary>
+          /// <returns>this PdxWriter</returns>
           virtual IPdxWriter^ WriteField(String^ fieldName, Object^ fieldValue, Type^ type);
 
           virtual void WriteByte(Byte byte);//for internal purpose
-        };      
-    }  // 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/PdxReaderWithTypeCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp b/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
index d8e541a..eb38933 100644
--- a/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
+++ b/src/clicache/src/impl/PdxReaderWithTypeCollector.cpp
@@ -17,7 +17,7 @@
 
 #include "PdxReaderWithTypeCollector.hpp"
 #include <gfcpp/GeodeTypeIds.hpp>
-#include "../GemFireClassIds.hpp"
+#include "../GeodeClassIds.hpp"
 using namespace System;
 
 namespace Apache
@@ -29,25 +29,25 @@ namespace Apache
 
       namespace Internal
       {
-				void PdxReaderWithTypeCollector::checkType( String^ fieldName, Byte typeId, String^ fieldType)
-				{
-					PdxFieldType^ pft = m_pdxType->GetPdxField(fieldName);
+        void PdxReaderWithTypeCollector::checkType(String^ fieldName, Byte typeId, String^ fieldType)
+        {
+          PdxFieldType^ pft = m_pdxType->GetPdxField(fieldName);
 
-					if(pft != nullptr)
-					{
-						if(typeId != pft->TypeId)
-						{
-							throw gcnew IllegalStateException("Expected " + fieldType + " field but found field of type " + pft);
-						}
-					}
-				}
+          if (pft != nullptr)
+          {
+            if (typeId != pft->TypeId)
+            {
+              throw gcnew IllegalStateException("Expected " + fieldType + " field but found field of type " + pft);
+            }
+          }
+        }
 
-        SByte PdxReaderWithTypeCollector::ReadByte( String^ fieldName )
+        SByte PdxReaderWithTypeCollector::ReadByte(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::BYTE, "byte");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "byte", PdxTypes::BYTE, GemFireClassIds::BYTE_SIZE);
+          checkType(fieldName, PdxTypes::BYTE, "byte");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "byte", PdxTypes::BYTE, GeodeClassIds::BYTE_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             SByte retVal = PdxLocalReader::ReadByte(fieldName);
@@ -58,12 +58,12 @@ namespace Apache
           return 0;
         }
 
-        SByte PdxReaderWithTypeCollector::ReadSByte( String^ fieldName )
+        SByte PdxReaderWithTypeCollector::ReadSByte(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::BYTE, "byte");
-          m_newPdxType->AddFixedLengthTypeField( fieldName, "byte", PdxTypes::BYTE, GemFireClassIds::BYTE_SIZE);
+          checkType(fieldName, PdxTypes::BYTE, "byte");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "byte", PdxTypes::BYTE, GeodeClassIds::BYTE_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             SByte retVal = PdxLocalReader::ReadSByte(fieldName);
@@ -73,10 +73,10 @@ namespace Apache
           return 0;
         }
 
-				Boolean PdxReaderWithTypeCollector::ReadBoolean( String^ fieldName )
+        Boolean PdxReaderWithTypeCollector::ReadBoolean(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::BOOLEAN, "boolean");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "boolean", PdxTypes::BOOLEAN, GemFireClassIds::BOOLEAN_SIZE);
+          checkType(fieldName, PdxTypes::BOOLEAN, "boolean");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "boolean", PdxTypes::BOOLEAN, GeodeClassIds::BOOLEAN_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
           m_dataInput->AdvanceCursorPdx(position);
           bool retVal = PdxLocalReader::ReadBoolean(fieldName);
@@ -84,23 +84,23 @@ namespace Apache
           return retVal;
         }
 
-        Char PdxReaderWithTypeCollector::ReadChar( String^ fieldName )
+        Char PdxReaderWithTypeCollector::ReadChar(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::CHAR, "char");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "char", PdxTypes::CHAR, GemFireClassIds::CHAR_SIZE);
+          checkType(fieldName, PdxTypes::CHAR, "char");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "char", PdxTypes::CHAR, GeodeClassIds::CHAR_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
           m_dataInput->AdvanceCursorPdx(position);
           Char retVal = PdxLocalReader::ReadChar(fieldName);
           m_dataInput->RewindCursorPdx(position);
           return retVal;
         }
-        
-        uint16_t PdxReaderWithTypeCollector::ReadUInt16( String^ fieldName )
+
+        uint16_t PdxReaderWithTypeCollector::ReadUInt16(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::SHORT, "short");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "short", PdxTypes::SHORT, GemFireClassIds::SHORT_SIZE);
+          checkType(fieldName, PdxTypes::SHORT, "short");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "short", PdxTypes::SHORT, GeodeClassIds::SHORT_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             UInt16 retVal = PdxLocalReader::ReadUInt16(fieldName);
@@ -110,12 +110,12 @@ namespace Apache
           return 0;
         }
 
-        uint32_t PdxReaderWithTypeCollector::ReadUInt32( String^ fieldName )
+        uint32_t PdxReaderWithTypeCollector::ReadUInt32(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::INT, "int");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "int", PdxTypes::INT, GemFireClassIds::INTEGER_SIZE);
+          checkType(fieldName, PdxTypes::INT, "int");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "int", PdxTypes::INT, GeodeClassIds::INTEGER_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             UInt32 retVal = PdxLocalReader::ReadUInt32(fieldName);
@@ -124,13 +124,13 @@ namespace Apache
           }
           return 0;
         }
-        
-        uint64_t PdxReaderWithTypeCollector::ReadUInt64( String^ fieldName )
+
+        uint64_t PdxReaderWithTypeCollector::ReadUInt64(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::LONG, "long");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "long", PdxTypes::LONG, GemFireClassIds::LONG_SIZE);
+          checkType(fieldName, PdxTypes::LONG, "long");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "long", PdxTypes::LONG, GeodeClassIds::LONG_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             UInt64 retVal = PdxLocalReader::ReadUInt64(fieldName);
@@ -140,12 +140,12 @@ namespace Apache
           return 0;
         }
 
-        short PdxReaderWithTypeCollector::ReadShort( String^ fieldName )
+        short PdxReaderWithTypeCollector::ReadShort(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::SHORT, "short");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "short", PdxTypes::SHORT, GemFireClassIds::SHORT_SIZE);
+          checkType(fieldName, PdxTypes::SHORT, "short");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "short", PdxTypes::SHORT, GeodeClassIds::SHORT_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             Int16 retVal = PdxLocalReader::ReadShort(fieldName);
@@ -155,12 +155,12 @@ namespace Apache
           return 0;
         }
 
-				Int32 PdxReaderWithTypeCollector::ReadInt( String^ fieldName )
+        Int32 PdxReaderWithTypeCollector::ReadInt(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::INT, "int");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "int", PdxTypes::INT, GemFireClassIds::INTEGER_SIZE);
+          checkType(fieldName, PdxTypes::INT, "int");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "int", PdxTypes::INT, GeodeClassIds::INTEGER_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             Int32 retVal = PdxLocalReader::ReadInt(fieldName);
@@ -170,12 +170,12 @@ namespace Apache
           return 0;
         }
 
-        Int64 PdxReaderWithTypeCollector::ReadLong( String^ fieldName )
+        Int64 PdxReaderWithTypeCollector::ReadLong(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::LONG, "long");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "long", PdxTypes::LONG, GemFireClassIds::LONG_SIZE);
+          checkType(fieldName, PdxTypes::LONG, "long");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "long", PdxTypes::LONG, GeodeClassIds::LONG_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             Int64 retVal = PdxLocalReader::ReadLong(fieldName);
@@ -185,12 +185,12 @@ namespace Apache
           return 0;
         }
 
-        float PdxReaderWithTypeCollector::ReadFloat( String^ fieldName )
+        float PdxReaderWithTypeCollector::ReadFloat(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::FLOAT, "float");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "float", PdxTypes::FLOAT, GemFireClassIds::FLOAT_SIZE);
+          checkType(fieldName, PdxTypes::FLOAT, "float");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "float", PdxTypes::FLOAT, GeodeClassIds::FLOAT_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             float retVal = PdxLocalReader::ReadFloat(fieldName);
@@ -200,12 +200,12 @@ namespace Apache
           return 0.0;
         }
 
-        double PdxReaderWithTypeCollector::ReadDouble( String^ fieldName )
+        double PdxReaderWithTypeCollector::ReadDouble(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::DOUBLE, "double");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "double", PdxTypes::DOUBLE, GemFireClassIds::DOUBLE_SIZE);
+          checkType(fieldName, PdxTypes::DOUBLE, "double");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "double", PdxTypes::DOUBLE, GeodeClassIds::DOUBLE_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             Double retVal = PdxLocalReader::ReadDouble(fieldName);
@@ -215,12 +215,12 @@ namespace Apache
           return 0.0;
         }
 
-        String^ PdxReaderWithTypeCollector::ReadString( String^ fieldName )
+        String^ PdxReaderWithTypeCollector::ReadString(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::STRING, "String");
+          checkType(fieldName, PdxTypes::STRING, "String");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "String", PdxTypes::STRING);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             String^ retVal = PdxLocalReader::ReadString(fieldName);
@@ -230,12 +230,12 @@ namespace Apache
           return nullptr;
         }
 
-        String^ PdxReaderWithTypeCollector::ReadUTFHuge( String^ fieldName )
+        String^ PdxReaderWithTypeCollector::ReadUTFHuge(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::STRING, "String");
+          checkType(fieldName, PdxTypes::STRING, "String");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "String", PdxTypes::STRING);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             String^ retVal = PdxLocalReader::ReadUTFHuge(fieldName);
@@ -245,12 +245,12 @@ namespace Apache
           return nullptr;
         }
 
-        String^ PdxReaderWithTypeCollector::ReadASCIIHuge( String^ fieldName )
+        String^ PdxReaderWithTypeCollector::ReadASCIIHuge(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::STRING, "String");
+          checkType(fieldName, PdxTypes::STRING, "String");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "String", PdxTypes::STRING);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             String^ retVal = PdxLocalReader::ReadASCIIHuge(fieldName);
@@ -260,32 +260,32 @@ namespace Apache
           return nullptr;
         }
 
-        Object^ PdxReaderWithTypeCollector::ReadObject( String^ fieldName )
+        Object^ PdxReaderWithTypeCollector::ReadObject(String^ fieldName)
         {
-					//field is collected after reading
-					checkType(fieldName, PdxTypes::OBJECT, "Object");
+          //field is collected after reading
+          checkType(fieldName, PdxTypes::OBJECT, "Object");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "Object"/*retVal->GetType()->FullName*/, PdxTypes::OBJECT);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
-            Object^ retVal = PdxLocalReader::ReadObject(fieldName);            
+            Object^ retVal = PdxLocalReader::ReadObject(fieldName);
             m_dataInput->ResetPdx(m_startPosition);//force native as well
             m_dataInput->RewindCursorPdx(position);
             return retVal;
           }
           return nullptr;
         }
-        
+
         //TODO:
         //void WriteMap( String^ fieldName, System::Collections::IDictionary^ map );
 
-        void PdxReaderWithTypeCollector::ReadCollection( String^ fieldName, System::Collections::IList^ obj)
+        void PdxReaderWithTypeCollector::ReadCollection(String^ fieldName, System::Collections::IList^ obj)
         {
-					checkType(fieldName, apache::geode::client::GeodeTypeIds::CacheableArrayList, "Collection");
+          checkType(fieldName, apache::geode::client::GeodeTypeIds::CacheableArrayList, "Collection");
           m_newPdxType->AddVariableLengthTypeField(fieldName, /*obj->GetType()->FullName*/"Collection", apache::geode::client::GeodeTypeIds::CacheableArrayList);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             PdxLocalReader::ReadCollection(fieldName, obj);
@@ -293,12 +293,12 @@ namespace Apache
           }
         }
 
-        System::DateTime PdxReaderWithTypeCollector::ReadDate( String^ fieldName)
+        System::DateTime PdxReaderWithTypeCollector::ReadDate(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::DATE, "Date");
-          m_newPdxType->AddFixedLengthTypeField(fieldName, "Date", PdxTypes::DATE, GemFireClassIds::DATE_SIZE);
+          checkType(fieldName, PdxTypes::DATE, "Date");
+          m_newPdxType->AddFixedLengthTypeField(fieldName, "Date", PdxTypes::DATE, GeodeClassIds::DATE_SIZE);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             System::DateTime retVal = PdxLocalReader::ReadDate(fieldName);
@@ -310,12 +310,12 @@ namespace Apache
         }
         //void writeFile(String fieldName, File file) ;
 
-        array<bool>^ PdxReaderWithTypeCollector::ReadBooleanArray( String^ fieldName )
+        array<bool>^ PdxReaderWithTypeCollector::ReadBooleanArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::BOOLEAN_ARRAY, "boolean[]");
+          checkType(fieldName, PdxTypes::BOOLEAN_ARRAY, "boolean[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "boolean[]", PdxTypes::BOOLEAN_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<bool>^ retVal = PdxLocalReader::ReadBooleanArray(fieldName);
@@ -325,12 +325,12 @@ namespace Apache
           return nullptr;
         }
 
-        array<Char>^ PdxReaderWithTypeCollector::ReadCharArray(String^ fieldName )
+        array<Char>^ PdxReaderWithTypeCollector::ReadCharArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::CHAR_ARRAY, "char[]");
+          checkType(fieldName, PdxTypes::CHAR_ARRAY, "char[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "char[]", PdxTypes::CHAR_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<Char>^ retVal = PdxLocalReader::ReadCharArray(fieldName);
@@ -342,10 +342,10 @@ namespace Apache
 
         array<Byte>^ PdxReaderWithTypeCollector::ReadByteArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::BYTE_ARRAY, "byte[]");
+          checkType(fieldName, PdxTypes::BYTE_ARRAY, "byte[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "byte[]", PdxTypes::BYTE_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<Byte>^ retVal = PdxLocalReader::ReadByteArray(fieldName);
@@ -357,10 +357,10 @@ namespace Apache
 
         array<SByte>^ PdxReaderWithTypeCollector::ReadSByteArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::BYTE_ARRAY, "byte[]");
+          checkType(fieldName, PdxTypes::BYTE_ARRAY, "byte[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "byte[]", PdxTypes::BYTE_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<SByte>^ retVal = PdxLocalReader::ReadSByteArray(fieldName);
@@ -372,10 +372,10 @@ namespace Apache
 
         array<short>^ PdxReaderWithTypeCollector::ReadShortArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::SHORT_ARRAY, "short[]");
+          checkType(fieldName, PdxTypes::SHORT_ARRAY, "short[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "short[]", PdxTypes::SHORT_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<Int16>^ retVal = PdxLocalReader::ReadShortArray(fieldName);
@@ -387,10 +387,10 @@ namespace Apache
 
         array<System::UInt16>^ PdxReaderWithTypeCollector::ReadUnsignedShortArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::SHORT_ARRAY, "short[]");
+          checkType(fieldName, PdxTypes::SHORT_ARRAY, "short[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "short[]", PdxTypes::SHORT_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<UInt16>^ retVal = PdxLocalReader::ReadUnsignedShortArray(fieldName);
@@ -402,10 +402,10 @@ namespace Apache
 
         array<System::Int32>^ PdxReaderWithTypeCollector::ReadIntArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::INT_ARRAY, "int[]");
+          checkType(fieldName, PdxTypes::INT_ARRAY, "int[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "int[]", PdxTypes::INT_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<Int32>^ retVal = PdxLocalReader::ReadIntArray(fieldName);
@@ -417,10 +417,10 @@ namespace Apache
 
         array<System::UInt32>^ PdxReaderWithTypeCollector::ReadUnsignedIntArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::INT_ARRAY, "int[]");
+          checkType(fieldName, PdxTypes::INT_ARRAY, "int[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "int[]", PdxTypes::INT_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<UInt32>^ retVal = PdxLocalReader::ReadUnsignedIntArray(fieldName);
@@ -432,10 +432,10 @@ namespace Apache
 
         array<Int64>^ PdxReaderWithTypeCollector::ReadLongArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::LONG_ARRAY, "long[]");
+          checkType(fieldName, PdxTypes::LONG_ARRAY, "long[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "long[]", PdxTypes::LONG_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<Int64>^ retVal = PdxLocalReader::ReadLongArray(fieldName);
@@ -445,12 +445,12 @@ namespace Apache
           return nullptr;
         }
 
-        array<System::UInt64>^ PdxReaderWithTypeCollector::ReadUnsignedLongArray(String^ fieldName )
+        array<System::UInt64>^ PdxReaderWithTypeCollector::ReadUnsignedLongArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::LONG_ARRAY, "long[]");
+          checkType(fieldName, PdxTypes::LONG_ARRAY, "long[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "long[]", PdxTypes::LONG_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<UInt64>^ retVal = PdxLocalReader::ReadUnsignedLongArray(fieldName);
@@ -462,10 +462,10 @@ namespace Apache
 
         array<float>^ PdxReaderWithTypeCollector::ReadFloatArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::FLOAT_ARRAY, "float[]");
+          checkType(fieldName, PdxTypes::FLOAT_ARRAY, "float[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "float[]", PdxTypes::FLOAT_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<float>^ retVal = PdxLocalReader::ReadFloatArray(fieldName);
@@ -477,10 +477,10 @@ namespace Apache
 
         array<double>^ PdxReaderWithTypeCollector::ReadDoubleArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::DOUBLE_ARRAY, "double[]");
+          checkType(fieldName, PdxTypes::DOUBLE_ARRAY, "double[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "double[]", PdxTypes::DOUBLE_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<Double>^ retVal = PdxLocalReader::ReadDoubleArray(fieldName);
@@ -492,10 +492,10 @@ namespace Apache
 
         array<String^>^ PdxReaderWithTypeCollector::ReadStringArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::STRING_ARRAY, "String[]");
+          checkType(fieldName, PdxTypes::STRING_ARRAY, "String[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "String[]", PdxTypes::STRING_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<String^>^ retVal = PdxLocalReader::ReadStringArray(fieldName);
@@ -507,10 +507,10 @@ namespace Apache
 
         List<Object^>^ PdxReaderWithTypeCollector::ReadObjectArray(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::OBJECT_ARRAY, "Object[]");
+          checkType(fieldName, PdxTypes::OBJECT_ARRAY, "Object[]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "Object[]", PdxTypes::OBJECT_ARRAY);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             List<Object^>^ retVal = PdxLocalReader::ReadObjectArray(fieldName);
@@ -521,12 +521,12 @@ namespace Apache
           return nullptr;
         }
 
-        array<array<Byte>^>^ PdxReaderWithTypeCollector::ReadArrayOfByteArrays(String^ fieldName )
+        array<array<Byte>^>^ PdxReaderWithTypeCollector::ReadArrayOfByteArrays(String^ fieldName)
         {
-					checkType(fieldName, PdxTypes::ARRAY_OF_BYTE_ARRAYS, "byte[][]");
+          checkType(fieldName, PdxTypes::ARRAY_OF_BYTE_ARRAYS, "byte[][]");
           m_newPdxType->AddVariableLengthTypeField(fieldName, "byte[][]", PdxTypes::ARRAY_OF_BYTE_ARRAYS);
           int position = m_pdxType->GetFieldPosition(fieldName, m_offsetsBuffer, m_offsetSize, m_serializedLength);
-          if(position != -1)
+          if (position != -1)
           {
             m_dataInput->AdvanceCursorPdx(position);
             array<array<Byte>^>^ retVal = PdxLocalReader::ReadArrayOfByteArrays(fieldName);
@@ -539,8 +539,8 @@ namespace Apache
         //TODO:
         //void WriteEnum(String^ fieldName, Enum e) ;
         //void WriteInetAddress(String^ fieldName, InetAddress address);
-    }  // 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/PdxType.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxType.cpp b/src/clicache/src/impl/PdxType.cpp
index 8d3319e..424ee04 100644
--- a/src/clicache/src/impl/PdxType.cpp
+++ b/src/clicache/src/impl/PdxType.cpp
@@ -34,19 +34,19 @@ namespace Apache
       namespace Internal
       {
         void PdxType::AddFixedLengthTypeField(String^ fieldName, String^ className,
-          Byte typeId, Int32 size)
+                                              Byte typeId, Int32 size)
         {
           int current = m_pdxFieldTypes->Count;
           PdxFieldType^ pfType = gcnew PdxFieldType(fieldName, className, (Byte)typeId,
-            current/*field index*/,
-            false, size, 0/*var len field idx*/);
+                                                    current/*field index*/,
+                                                    false, size, 0/*var len field idx*/);
           m_pdxFieldTypes->Add(pfType);
           //this will make sure one can't add same field name
           m_fieldNameVsPdxType->Add(fieldName, pfType);
         }
 
         void PdxType::AddVariableLengthTypeField(String^ fieldName, String^ className,
-          Byte typeId)
+                                                 Byte typeId)
         {
           //we don't store offset of first var len field, this is the purpose of following check
           if (m_isVarLenFieldAdded)
@@ -58,7 +58,7 @@ namespace Apache
 
           int current = m_pdxFieldTypes->Count;
           PdxFieldType^ pfType = gcnew PdxFieldType(fieldName, className, (Byte)typeId,
-            current, true, -1, m_varLenFieldIdx);
+                                                    current, true, -1, m_varLenFieldIdx);
           m_pdxFieldTypes->Add(pfType);
           //this will make sure one can't add same field name
           m_fieldNameVsPdxType->Add(fieldName, pfType);
@@ -67,14 +67,14 @@ namespace Apache
         void PdxType::ToData(DataOutput^ output)
         {
           //defaulf java Dataserializable require this
-          output->WriteByte(GemFireClassIds::DATA_SERIALIZABLE);
-          output->WriteByte(GemFireClassIds::JAVA_CLASS);
+          output->WriteByte(GeodeClassIds::DATA_SERIALIZABLE);
+          output->WriteByte(GeodeClassIds::JAVA_CLASS);
           output->WriteObject((Object^)m_javaPdxClass);
 
           //pdx type
           output->WriteString(m_className);
           output->WriteBoolean(m_noJavaClass);
-          output->WriteInt32(m_gemfireTypeId);
+          output->WriteInt32(m_geodeTypeId);
           output->WriteInt32(m_varLenFieldIdx);
 
           output->WriteArrayLen(m_pdxFieldTypes->Count);
@@ -103,7 +103,7 @@ namespace Apache
           m_pdxDomainType = pdxWrapper->GetObject()->GetType();*/
           //Log::Debug("PdxType::FromData " + m_className);
           m_noJavaClass = input->ReadBoolean();
-          m_gemfireTypeId = input->ReadInt32();
+          m_geodeTypeId = input->ReadInt32();
           m_varLenFieldIdx = input->ReadInt32();
 
           int len = input->ReadArrayLen();
@@ -207,9 +207,9 @@ namespace Apache
           {
             //need to read offset and then subtract relative offset
             return PdxHelper::ReadInt(offsetPosition +
-              (m_numberOfVarLenFields - offset - 1)*offsetSize,
-              offsetSize)
-              + fixLenField->RelativeOffset;
+                                      (m_numberOfVarLenFields - offset - 1)*offsetSize,
+                                      offsetSize)
+                                      + fixLenField->RelativeOffset;
           }
         }
 
@@ -261,12 +261,12 @@ namespace Apache
             if (!found)
             {
               PdxFieldType^ newFt = gcnew PdxFieldType(tmp->FieldName,
-                tmp->ClassName,
-                tmp->TypeId,
-                newone->m_pdxFieldTypes->Count,//sequence id
-                tmp->IsVariableLengthType,
-                tmp->Size,
-                (tmp->IsVariableLengthType ? varLenFields++/*it increase after that*/ : 0));
+                                                       tmp->ClassName,
+                                                       tmp->TypeId,
+                                                       newone->m_pdxFieldTypes->Count,//sequence id
+                                                       tmp->IsVariableLengthType,
+                                                       tmp->Size,
+                                                       (tmp->IsVariableLengthType ? varLenFields++/*it increase after that*/ : 0));
               newone->m_pdxFieldTypes->Add(newFt);//fieldnameVsPFT will happen after that							
             }
           }
@@ -306,7 +306,7 @@ namespace Apache
         PdxType^ PdxType::clone()
         {
           PdxType^ newone = gcnew PdxType(m_className, false);
-          newone->m_gemfireTypeId = 0;
+          newone->m_geodeTypeId = 0;
           newone->m_numberOfVarLenFields = m_numberOfVarLenFields;
 
           for each(PdxFieldType^ tmp in m_pdxFieldTypes)
@@ -394,7 +394,7 @@ namespace Apache
 
           if (localPdxType != nullptr)
           {
-            //Log::Debug("In initLocalToRemote: " + m_gemfireTypeId);
+            //Log::Debug("In initLocalToRemote: " + m_geodeTypeId);
             IList<PdxFieldType^>^ localPdxFields = localPdxType->m_pdxFieldTypes;
 
             Int32 fieldIdx = 0;

http://git-wip-us.apache.org/repos/asf/geode/blob/fc9f1f6f/src/clicache/src/impl/PdxType.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxType.hpp b/src/clicache/src/impl/PdxType.hpp
index 82af710..22a3c60 100644
--- a/src/clicache/src/impl/PdxType.hpp
+++ b/src/clicache/src/impl/PdxType.hpp
@@ -20,7 +20,7 @@
 #include "PdxFieldType.hpp"
 //#include "../DataOutput.hpp"
 //#include "../DataInput.hpp"
-#include "../GemFireClassIds.hpp"
+#include "../GeodeClassIds.hpp"
 using namespace System;
 using namespace System::Collections::Generic;
 
@@ -31,8 +31,8 @@ namespace Apache
     namespace Client
     {
 
-				ref class DataOutput;
-				ref class DataInput;
+      ref class DataOutput;
+      ref class DataInput;
       namespace Internal
       {
         public ref class PdxType : public IGFSerializable
@@ -43,16 +43,16 @@ namespace Apache
           IList<PdxFieldType^>^   m_pdxFieldTypes;
           IList<PdxType^>^        m_otherVersions;
           Int32                   m_cachedHashcode;
-          
+
           //Type^                 m_pdxDomainType;
           String^               m_className;
-          Int32                   m_gemfireTypeId;
+          Int32                   m_geodeTypeId;
           bool                    m_isLocal;
           Int32                   m_numberOfVarLenFields;
           Int32                   m_varLenFieldIdx;
 
           Int32                   m_numberOfFieldsExtra;
-          
+
           array<Int32>^           m_remoteToLocalFieldMap;
           array<Int32>^           m_localToRemoteFieldMap;
 
@@ -60,9 +60,9 @@ namespace Apache
           IDictionary<String^, PdxFieldType^>^ m_fieldNameVsPdxType;
 
           bool                   m_isVarLenFieldAdded;
-					bool									 m_noJavaClass;
-        
-					void initRemoteToLocal();
+          bool									 m_noJavaClass;
+
+          void initRemoteToLocal();
           void initLocalToRemote();
           //first has more fields than second
           PdxType^ isContains(PdxType^ first, PdxType^ second);
@@ -74,128 +74,128 @@ namespace Apache
 
           PdxType^ isLocalTypeContains(PdxType^ otherType);
           PdxType^ isRemoteTypeContains(PdxType^ localType);
-         public:
-           PdxType()
-           {
-             m_cachedHashcode = 0;
-             m_lockObj = gcnew Object();
-             m_pdxFieldTypes = gcnew List<PdxFieldType^>();
-             m_otherVersions = gcnew List<PdxType^>();
-             m_isLocal = false;
-             m_numberOfVarLenFields = 0;
-             m_varLenFieldIdx = 0;//start with 0
-             m_isVarLenFieldAdded = false;
-             m_fieldNameVsPdxType = gcnew Dictionary<String^, PdxFieldType^>();
-						 m_noJavaClass = false;
-             m_gemfireTypeId = 0;
+        public:
+          PdxType()
+          {
+            m_cachedHashcode = 0;
+            m_lockObj = gcnew Object();
+            m_pdxFieldTypes = gcnew List<PdxFieldType^>();
+            m_otherVersions = gcnew List<PdxType^>();
+            m_isLocal = false;
+            m_numberOfVarLenFields = 0;
+            m_varLenFieldIdx = 0;//start with 0
+            m_isVarLenFieldAdded = false;
+            m_fieldNameVsPdxType = gcnew Dictionary<String^, PdxFieldType^>();
+            m_noJavaClass = false;
+            m_geodeTypeId = 0;
             // m_pdxDomainType = nullptr;
-           }
-
-           PdxType(String^ pdxDomainClassName,
-                   bool  isLocal )
-           {
-             m_cachedHashcode = 0;
-              m_lockObj = gcnew Object();
-              m_pdxFieldTypes = gcnew List<PdxFieldType^>();
-              m_otherVersions = gcnew List<PdxType^>();
+          }
+
+          PdxType(String^ pdxDomainClassName,
+                  bool  isLocal)
+          {
+            m_cachedHashcode = 0;
+            m_lockObj = gcnew Object();
+            m_pdxFieldTypes = gcnew List<PdxFieldType^>();
+            m_otherVersions = gcnew List<PdxType^>();
             //  m_className = className;
-             // m_pdxDomainType = pdxDomainType;
-              m_className = pdxDomainClassName;
-              m_isLocal = isLocal;
-              m_numberOfVarLenFields = 0;
-              m_varLenFieldIdx = 0;//start with 0
-              m_isVarLenFieldAdded = false;
-              m_fieldNameVsPdxType = gcnew Dictionary<String^, PdxFieldType^>();
-							m_noJavaClass = false;
-              m_gemfireTypeId = 0;
-           }
-
-           static IGFSerializable^ CreateDeserializable()
-           {
-             return gcnew PdxType();
-           }
-           property Int32 TotalVarLenFields
-           {
-             Int32 get() {return m_numberOfVarLenFields;};
-           }
-					 property Int32 Totalfields
-					 {
-						 Int32 get() {return m_pdxFieldTypes->Count;};
-					 }
-           property IList<PdxFieldType^>^ PdxFieldList
-           {
-             IList<PdxFieldType^>^ get(){return m_pdxFieldTypes;}
-           }
-           property Int32 TypeId
-           {
-             Int32 get() {return m_gemfireTypeId;}
-             void set(Int32 value) {m_gemfireTypeId = value;}
-           }
+            // m_pdxDomainType = pdxDomainType;
+            m_className = pdxDomainClassName;
+            m_isLocal = isLocal;
+            m_numberOfVarLenFields = 0;
+            m_varLenFieldIdx = 0;//start with 0
+            m_isVarLenFieldAdded = false;
+            m_fieldNameVsPdxType = gcnew Dictionary<String^, PdxFieldType^>();
+            m_noJavaClass = false;
+            m_geodeTypeId = 0;
+          }
+
+          static IGFSerializable^ CreateDeserializable()
+          {
+            return gcnew PdxType();
+          }
+          property Int32 TotalVarLenFields
+          {
+            Int32 get() { return m_numberOfVarLenFields; };
+          }
+          property Int32 Totalfields
+          {
+            Int32 get() { return m_pdxFieldTypes->Count; };
+          }
+          property IList<PdxFieldType^>^ PdxFieldList
+          {
+            IList<PdxFieldType^>^ get(){ return m_pdxFieldTypes; }
+          }
+          property Int32 TypeId
+          {
+            Int32 get() { return m_geodeTypeId; }
+            void set(Int32 value) { m_geodeTypeId = value; }
+          }
           /* property Type^ PdxDomainType
            {
-             Type^ get() {return m_pdxDomainType;}
-             void set(Type^ type) {m_pdxDomainType = type;}
+           Type^ get() {return m_pdxDomainType;}
+           void set(Type^ type) {m_pdxDomainType = type;}
            }*/
-           property String^ PdxClassName
-           {
-             String^ get() {return m_className;}
-             void set(String^ className) {m_className = className;}
-           }
-           property Int32 NumberOfFieldsExtra
-           {
-             Int32 get(){return m_numberOfFieldsExtra;}
-           }
-
-           PdxFieldType^ GetPdxField(String^ fieldName)
-           {
-             PdxFieldType^ retVal= nullptr;
-
-             m_fieldNameVsPdxType->TryGetValue(fieldName, retVal);
-
-             return retVal;
-           }
-           void AddOtherVersion(PdxType^ otherVersion)
-           {
+          property String^ PdxClassName
+          {
+            String^ get() { return m_className; }
+            void set(String^ className) { m_className = className; }
+          }
+          property Int32 NumberOfFieldsExtra
+          {
+            Int32 get(){ return m_numberOfFieldsExtra; }
+          }
+
+          PdxFieldType^ GetPdxField(String^ fieldName)
+          {
+            PdxFieldType^ retVal = nullptr;
+
+            m_fieldNameVsPdxType->TryGetValue(fieldName, retVal);
+
+            return retVal;
+          }
+          void AddOtherVersion(PdxType^ otherVersion)
+          {
             m_otherVersions->Add(otherVersion);
-           }
-
-           array<int>^ GetLocalToRemoteMap();
-           array<int>^ GetRemoteToLocalMap();
-           property Int32 NumberOfVarLenFields
-           {
-             Int32 get(){return m_numberOfVarLenFields;}
-           }
-           property bool IsLocal
-           {
-             bool get() {return m_isLocal;}
-             void set(bool val) {m_isLocal = val;}
-           }
-           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 GemFireClassIds::PdxType;}
-           }
-           virtual String^ ToString( ) override
-           {
+          }
+
+          array<int>^ GetLocalToRemoteMap();
+          array<int>^ GetRemoteToLocalMap();
+          property Int32 NumberOfVarLenFields
+          {
+            Int32 get(){ return m_numberOfVarLenFields; }
+          }
+          property bool IsLocal
+          {
+            bool get() { return m_isLocal; }
+            void set(bool val) { m_isLocal = val; }
+          }
+          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 GeodeClassIds::PdxType; }
+          }
+          virtual String^ ToString() override
+          {
             return "PdxType";
-           }
-           void AddFixedLengthTypeField(String^ fieldName, String^ className, Byte typeId, Int32 size);
-           void AddVariableLengthTypeField(String^ fieldName, String^ className, Byte typeId);
-           void InitializeType();
-           PdxType^ MergeVersion(PdxType^ otherVersion);
-           Int32 GetFieldPosition(String^ fieldName, uint8_t* offsetPosition, Int32 offsetSize, Int32 pdxStreamlen);
-           Int32 GetFieldPosition(Int32 fieldIdx, uint8_t* offsetPosition, Int32 offsetSize, Int32 pdxStreamlen);
-
-           virtual bool Equals(Object^ otherType) override;
-           virtual Int32 GetHashCode() override;
+          }
+          void AddFixedLengthTypeField(String^ fieldName, String^ className, Byte typeId, Int32 size);
+          void AddVariableLengthTypeField(String^ fieldName, String^ className, Byte typeId);
+          void InitializeType();
+          PdxType^ MergeVersion(PdxType^ otherVersion);
+          Int32 GetFieldPosition(String^ fieldName, uint8_t* offsetPosition, Int32 offsetSize, Int32 pdxStreamlen);
+          Int32 GetFieldPosition(Int32 fieldIdx, uint8_t* offsetPosition, Int32 offsetSize, Int32 pdxStreamlen);
+
+          virtual bool Equals(Object^ otherType) override;
+          virtual Int32 GetHashCode() override;
         };
-    }  // namespace Client
-  }  // namespace Geode
-}  // namespace Apache
+      }  // namespace Client
+    }  // namespace Geode
+  }  // namespace Apache
 
 }


Mime
View raw message