/// <summary> /// Parse the GetPropList request type response body. /// </summary> /// <param name="rawData">The raw data of response.</param> /// <returns>The GetPropList request type response body.</returns> public static GetPropListResponseBody Parse(byte[] rawData) { GetPropListResponseBody responseBody = new GetPropListResponseBody(); int index = 0; responseBody.StatusCode = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.ErrorCode = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.HasPropertyTags = BitConverter.ToBoolean(rawData, index); index += sizeof(bool); if (responseBody.HasPropertyTags) { responseBody.PropertyTags = LargePropTagArray.Parse(rawData, ref index); } else { responseBody.PropertyTags = null; } responseBody.AuxiliaryBufferSize = BitConverter.ToUInt32(rawData, index); index += 4; responseBody.AuxiliaryBuffer = new byte[responseBody.AuxiliaryBufferSize]; Array.Copy(rawData, index, responseBody.AuxiliaryBuffer, 0, responseBody.AuxiliaryBufferSize); return(responseBody); }
/// <summary> /// Parse the ResolveNames request type response body. /// </summary> /// <param name="rawData">The raw data of response.</param> /// <returns>The ResolveNames request type response body.</returns> public static ResolveNamesResponseBody Parse(byte[] rawData) { ResolveNamesResponseBody responseBody = new ResolveNamesResponseBody(); int index = 0; responseBody.StatusCode = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.ErrorCode = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.CodePage = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.HasMinimalIds = BitConverter.ToBoolean(rawData, index); index += sizeof(bool); if (responseBody.HasMinimalIds) { responseBody.MinimalIdCount = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.MinimalIds = new uint[(uint)responseBody.MinimalIdCount]; for (int i = 0; i < responseBody.MinimalIdCount; i++) { responseBody.MinimalIds[i] = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); } } else { responseBody.MinimalIdCount = null; responseBody.MinimalIds = null; } responseBody.HasRowsAndPropertyTags = BitConverter.ToBoolean(rawData, index); index += sizeof(bool); if (responseBody.HasRowsAndPropertyTags) { responseBody.PropertyTags = LargePropTagArray.Parse(rawData, ref index); responseBody.RowCount = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.RowData = new AddressBookPropertyRow[(uint)responseBody.RowCount]; for (int i = 0; i < responseBody.RowCount; i++) { responseBody.RowData[i] = AddressBookPropertyRow.Parse(rawData, (LargePropTagArray)responseBody.PropertyTags, ref index); } } responseBody.AuxiliaryBufferSize = BitConverter.ToUInt32(rawData, index); index += 4; responseBody.AuxiliaryBuffer = new byte[responseBody.AuxiliaryBufferSize]; Array.Copy(rawData, index, responseBody.AuxiliaryBuffer, 0, responseBody.AuxiliaryBufferSize); return(responseBody); }
/// <summary> /// Parse the SeekEntries request type response body. /// </summary> /// <param name="rawData">The raw data of response.</param> /// <returns>The SeekEntries request type response body.</returns> public static SeekEntriesResponseBody Parse(byte[] rawData) { SeekEntriesResponseBody responseBody = new SeekEntriesResponseBody(); int index = 0; responseBody.StatusCode = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.ErrorCode = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); responseBody.HasState = BitConverter.ToBoolean(rawData, index); index += sizeof(bool); if (responseBody.HasState) { responseBody.State = STAT.Parse(rawData, ref index); } else { responseBody.State = null; } responseBody.HasColumnsAndRows = BitConverter.ToBoolean(rawData, index); index += sizeof(bool); if (responseBody.HasColumnsAndRows) { responseBody.Columns = LargePropTagArray.Parse(rawData, ref index); responseBody.RowCount = BitConverter.ToUInt32(rawData, index); responseBody.RowData = new AddressBookPropertyRow[(uint)responseBody.RowCount]; index += sizeof(uint); for (int i = 0; i < responseBody.RowCount; i++) { responseBody.RowData[i] = AddressBookPropertyRow.Parse(rawData, (LargePropTagArray)responseBody.Columns, ref index); } } else { responseBody.Columns = null; responseBody.RowCount = null; responseBody.RowData = null; } responseBody.AuxiliaryBufferSize = BitConverter.ToUInt32(rawData, index); index += 4; responseBody.AuxiliaryBuffer = new byte[responseBody.AuxiliaryBufferSize]; Array.Copy(rawData, index, responseBody.AuxiliaryBuffer, 0, responseBody.AuxiliaryBufferSize); return(responseBody); }
/// <summary> /// Compare whether two LargePropertyTagArrays are equal. /// </summary> /// <param name="propertyTagArray1">The first LargePropertyTagArray used to compare.</param> /// <param name="propertyTagArray2">The second LargePropertyTagArray used to compare.</param> /// <returns>Returns true if they are equal; otherwise false.</returns> public static bool AreTwoLargePropertyTagArrayEqual(LargePropTagArray propertyTagArray1, LargePropTagArray propertyTagArray2) { if (propertyTagArray1.PropertyTagCount != propertyTagArray2.PropertyTagCount) { site.Log.Add( LogEntryKind.Debug, "The length the two property tag array are not equal. The length of propertyTagArray1 is {0}, the length of propertyTagArray2 is {1}.", propertyTagArray1.PropertyTagCount, propertyTagArray2.PropertyTagCount); return(false); } else { PropertyTag[] propertyTags1 = propertyTagArray1.PropertyTags; PropertyTag[] propertyTags2 = propertyTagArray2.PropertyTags; for (int i = 0; i < propertyTags1.Length; i++) { if (propertyTags1[i].PropertyId != propertyTags2[i].PropertyId) { site.Log.Add( LogEntryKind.Debug, "The property ID of property {0} in the two property tag array are not equal. The property ID of propertyTags1 is {1}, the property ID of propertyTags2 is {2}", i, propertyTags1[i].PropertyId, propertyTags2[i].PropertyId); return(false); } else if (propertyTags1[i].PropertyType != propertyTags2[i].PropertyType) { site.Log.Add( LogEntryKind.Debug, "The property type of property {0} in the two property tag array are not equal. The property type of propertyTags1 is {1}, the property type of propertyTags2 is {2}", i, propertyTags1[i].PropertyType, propertyTags2[i].PropertyType); return(false); } } } return(true); }
/// <summary> /// Parse the Large property tag array from the response data. /// </summary> /// <param name="rawData">The response data.</param> /// <param name="index">The start index of response data.</param> /// <returns>The result of parse the response data</returns> public static LargePropTagArray Parse(byte[] rawData, ref int index) { LargePropTagArray largePropTagArray = new LargePropTagArray(); largePropTagArray.PropertyTagCount = BitConverter.ToUInt32(rawData, index); index += sizeof(uint); largePropTagArray.PropertyTags = new PropertyTag[largePropTagArray.PropertyTagCount]; int count = 0; while (largePropTagArray.PropertyTagCount > count) { largePropTagArray.PropertyTags[count].PropertyType = BitConverter.ToUInt16(rawData, index); index += 2; largePropTagArray.PropertyTags[count].PropertyId = BitConverter.ToUInt16(rawData, index); index += 2; count++; } return(largePropTagArray); }
/// <summary> /// Parse the AddressBookPropertyRow structure. /// </summary> /// <param name="rawBuffer">The raw data returned from server.</param> /// <param name="propTagArray">The list of property tags.</param> /// <param name="index">The start index.</param> /// <returns>Return an instance of AddressBookPropertyRow.</returns> public static AddressBookPropertyRow Parse(byte[] rawBuffer, LargePropTagArray propTagArray, ref int index) { AddressBookPropertyRow addressBookPropertyRow = new AddressBookPropertyRow(); addressBookPropertyRow.Flag = rawBuffer[index]; index++; List <PropertyValue> valueArray = new List <PropertyValue>(); Context.Instance.PropertyBytes = rawBuffer; Context.Instance.CurIndex = index; Context.Instance.CurProperty = new Property(PropertyType.PtypUnspecified); // If the value of the Flags field is set to 0x00: The array contains either a PropertyValue structure, or a TypedPropertyValue structure. // If the value of the Flags field is set to 0x01: The array contains either a FlaggedPropertyValue structure, or a FlaggedPropertyValueWithType structure. if (addressBookPropertyRow.Flag == 0x00) { foreach (PropertyTag propertyTag in propTagArray.PropertyTags) { if (propertyTag.PropertyType == 0x0000) { // If the value of the Flags field is set to 0x00: The array contains a TypedPropertyValue structure, if the type of property is PtyUnspecified. TypedPropertyValue typedPropertyValue = new TypedPropertyValue(); // Parse the TypedPropertyValue with the instance of the context which contains the datas and start index. typedPropertyValue.Parse(Context.Instance); valueArray.Add(typedPropertyValue); index = Context.Instance.CurIndex; } else { // If the value of the Flags field is set to 0x00: The array contains a PropertyValue structure, if the type of property is specified. Context.Instance.CurProperty.Type = (PropertyType)propertyTag.PropertyType; PropertyValue propertyValue = new PropertyValue(); // Parse the TypedPropertyValue with the instance of the context which contains the datas and start index. propertyValue.Parse(Context.Instance); valueArray.Add(propertyValue); index = Context.Instance.CurIndex; } } } else if (addressBookPropertyRow.Flag == 0x01) { foreach (PropertyTag propertyTag in propTagArray.PropertyTags) { if (propertyTag.PropertyType == 0x0000) { // If the value of the Flags field is set to 0x01: The array contains a FlaggedPropertyValueWithType structure, if the type of property is PtyUnspecified. FlaggedPropertyValueWithType flaggedPropertyValue = new FlaggedPropertyValueWithType(); // Parse the TypedPropertyValue with the instance of the context which contains the datas and start index. flaggedPropertyValue.Parse(Context.Instance); valueArray.Add(flaggedPropertyValue); index = Context.Instance.CurIndex; } else { // If the value of the Flags field is set to 0x01: The array contains a FlaggedPropertyValue structure, if the type of property is specified. Context.Instance.CurProperty.Type = (PropertyType)propertyTag.PropertyType; FlaggedPropertyValue propertyValue = new FlaggedPropertyValue(); // Parse the TypedPropertyValue with the instance of the context which contains the datas and start index. propertyValue.Parse(Context.Instance); valueArray.Add(propertyValue); index = Context.Instance.CurIndex; } } } addressBookPropertyRow.ValueArray = valueArray.ToArray(); return(addressBookPropertyRow); }