/// <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);
}
