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 }
