/// <summary>
/// Deserialize items from byte array.
/// </summary>
/// <param name="byteArray">The byte array which contains response message.</param>
/// <param name="currentIndex">The index special where to start.</param>
/// <param name="lengthOfItems">The length of items.</param>
protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
{
int index = currentIndex;
this.RequestID = BasicObject.Parse <Compact64bitInt>(byteArray, ref index);
this.RequestType = BasicObject.Parse <Compact64bitInt>(byteArray, ref index);
this.Status = (byteArray[index] & 0x1) == 0x1 ? true : false;
this.Reserved = (byte)(byteArray[index] >> 1);
index += 1;
if (index - currentIndex != lengthOfItems)
{
throw new ResponseParseErrorException(currentIndex, "CellSubResponse object over-parse error", null);
}
if (this.Status)
{
this.ResponseError = StreamObject.GetCurrent <ResponseError>(byteArray, ref index);
}
else
{
this.SubResponseData = SubResponseData.GetCurrentSubResponseData((int)this.RequestType.DecodedValue, byteArray, ref index);
if (SharedContext.Current.IsMsFsshttpRequirementsCaptured)
{
// Capture the requirements related response data.
new MsfsshttpbAdapterCapture().InvokeCaptureMethod(this.SubResponseData.GetType(), this.SubResponseData, SharedContext.Current.Site);
}
}
currentIndex = index;
}
/// <summary>
/// Used to return the length of this element.
/// </summary>
/// <param name="byteArray">A Byte array</param>
/// <param name="startIndex">Start position</param>
/// <returns>The element length</returns>
public override int DeserializeDataElementDataFromByteArray(byte[] byteArray, int startIndex)
{
int index = startIndex;
this.DataElementFragment = StreamObject.GetCurrent <DataElementFragment>(byteArray, ref index);
return(index - startIndex);
}
/// <summary>
/// Deserialize sub response data from byte array.
/// </summary>
/// <param name="byteArray">The byte array which contains sub response data.</param>
/// <param name="currentIndex">The index special where to start.</param>
protected override void DeserializeSubResponseDataFromByteArray(byte[] byteArray, ref int currentIndex)
{
int index = currentIndex;
this.ReadAccessResponse = StreamObject.GetCurrent <ReadAccessResponse>(byteArray, ref index);
this.WriteAccessResponse = StreamObject.GetCurrent <WriteAccessResponse>(byteArray, ref index);
currentIndex = index;
using (BitReader bitReader = new BitReader(byteArray, index))
{
int headertype = bitReader.ReadInt32(2);
if (headertype == 0x2)
{
StreamObjectHeaderStart32bit header = new StreamObjectHeaderStart32bit();
header.HeaderType = headertype;
header.Compound = bitReader.ReadInt32(1);
int type = bitReader.ReadInt32(14);
header.Type = (StreamObjectTypeHeaderStart)type;
header.Length = bitReader.ReadInt32(15);
index += 4;
ResponseError responseError = StreamObject.GetCurrent <ResponseError>(byteArray, ref index);
}
// If header type is not 16-bit Stream Object Header End
if (headertype != 0x3)
{
currentIndex = index + 2;
}
}
}
/// <summary>
/// Deserialize sub response data from byte array.
/// </summary>
/// <param name="byteArray">The byte array which contains sub response data.</param>
/// <param name="currentIndex">The index special where to start.</param>
protected override void DeserializeSubResponseDataFromByteArray(byte[] byteArray, ref int currentIndex)
{
PutChangesResponseSerialNumberReassignAll outValue;
int index = currentIndex;
if (StreamObject.TryGetCurrent <PutChangesResponseSerialNumberReassignAll>(byteArray, ref index, out outValue))
{
this.PutChangesResponseSerialNumberReassignAll = outValue;
}
PutChangesResponse putChangesResponse;
if (StreamObject.TryGetCurrent <PutChangesResponse>(byteArray, ref index, out putChangesResponse))
{
this.PutChangesResponse = putChangesResponse;
}
this.Knowledge = StreamObject.GetCurrent <Knowledge>(byteArray, ref index);
DiagnosticRequestOptionOutput diagnosticRequestOptionOutput;
if (StreamObject.TryGetCurrent <DiagnosticRequestOptionOutput>(byteArray, ref index, out diagnosticRequestOptionOutput))
{
this.DiagnosticRequestOptionOutput = diagnosticRequestOptionOutput;
}
currentIndex = index;
}
/// <summary>
/// Used to de-serialize the element.
/// </summary>
/// <param name="byteArray">A Byte array</param>
/// <param name="currentIndex">Start position</param>
/// <param name="lengthOfItems">The length of the items</param>
protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
{
int index = currentIndex;
if (lengthOfItems != 0)
{
throw new StreamObjectParseErrorException(currentIndex, "LeafNodeObjectData", "Stream Object over-parse error", null);
}
this.Signature = StreamObject.GetCurrent <SignatureObject>(byteArray, ref index);
this.DataSize = StreamObject.GetCurrent <DataSizeObject>(byteArray, ref index);
// Try to read StreamObjectHeaderStart to see there is data hash object or not
StreamObjectHeaderStart streamObjectHeader;
if ((StreamObjectHeaderStart.TryParse(byteArray, index, out streamObjectHeader)) != 0)
{
if (streamObjectHeader.Type == StreamObjectTypeHeaderStart.DataHashObject)
{
this.DataHash = StreamObject.GetCurrent <DataHashObject>(byteArray, ref index);
}
}
currentIndex = index;
}
/// <summary>
/// Used to return the length of this element.
/// </summary>
/// <param name="byteArray">A Byte array</param>
/// <param name="startIndex">Start position</param>
/// <returns>The element length</returns>
public override int DeserializeDataElementDataFromByteArray(byte[] byteArray, int startIndex)
{
int index = startIndex;
this.CellManifestCurrentRevision = StreamObject.GetCurrent <CellManifestCurrentRevision>(byteArray, ref index);
return(index - startIndex);
}
/// <summary>
/// Used to de-serialize data element.
/// </summary>
/// <param name="byteArray">Byte array</param>
/// <param name="startIndex">Start position</param>
/// <returns>The length of the array</returns>
public override int DeserializeDataElementDataFromByteArray(byte[] byteArray, int startIndex)
{
int index = startIndex;
this.StorageManifestSchemaGUID = StreamObject.GetCurrent <StorageManifestSchemaGUID>(byteArray, ref index);
this.StorageManifestRootDeclareList = new List <StorageManifestRootDeclare>();
StreamObjectHeaderStart header;
int headerLength = 0;
while ((headerLength = StreamObjectHeaderStart.TryParse(byteArray, index, out header)) != 0)
{
if (header.Type == StreamObjectTypeHeaderStart.StorageManifestRootDeclare)
{
index += headerLength;
this.StorageManifestRootDeclareList.Add(StreamObject.ParseStreamObject(header, byteArray, ref index) as StorageManifestRootDeclare);
}
else
{
throw new DataElementParseErrorException(index, "Failed to parse StorageManifestDataElement, expect the inner object type StorageManifestRootDeclare, but actual type value is " + header.Type, null);
}
}
return(index - startIndex);
}
/// <summary>
/// Deserialize items from byte array.
/// </summary>
/// <param name="byteArray">The byte array which contains response message.</param>
/// <param name="currentIndex">The index special where to start.</param>
/// <param name="lengthOfItems">The length of items.</param>
protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
{
if (lengthOfItems != 0)
{
throw new ResponseParseErrorException(currentIndex, "ReadAccessResponse over-parse error", null);
}
int index = currentIndex;
this.ReadResponseError = StreamObject.GetCurrent <ResponseError>(byteArray, ref index);
currentIndex = index;
}
/// <summary>
/// Deserialize items from byte array.
/// </summary>
/// <param name="byteArray">The byte array which contains response message.</param>
/// <param name="currentIndex">The index special where to start.</param>
/// <param name="lengthOfItems">The length of items.</param>
protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
{
int index = currentIndex;
if (lengthOfItems != 16)
{
throw new StreamObjectParseErrorException(currentIndex, "ResponseError", "Stream object over-parse error", null);
}
byte[] guidarray = new byte[16];
Array.Copy(byteArray, index, guidarray, 0, 16);
this.ErrorTypeGUID = new Guid(guidarray);
index += 16;
switch (this.ErrorTypeGUID.ToString().ToUpper(CultureInfo.CurrentCulture))
{
case CellErrorGuid:
this.ErrorData = StreamObject.GetCurrent <CellError>(byteArray, ref index);
break;
case ProtocolErrorGuid:
this.ErrorData = StreamObject.GetCurrent <ProtocolError>(byteArray, ref index);
break;
case Win32ErrorGuid:
this.ErrorData = StreamObject.GetCurrent <Win32Error>(byteArray, ref index);
break;
case HresultErrorGuid:
this.ErrorData = StreamObject.GetCurrent <HRESULTError>(byteArray, ref index);
break;
default:
throw new StreamObjectParseErrorException(index - 16, "ResponseError", "Failed to extract the error Guid value, the value" + this.ErrorTypeGUID + "is not defined", null);
}
ErrorStringSupplementalInfo errorInfo;
if (StreamObject.TryGetCurrent <ErrorStringSupplementalInfo>(byteArray, ref index, out errorInfo))
{
this.ErrorStringSupplementalInfo = errorInfo;
}
ResponseError chainedError;
if (StreamObject.TryGetCurrent <ResponseError>(byteArray, ref index, out chainedError))
{
this.ChainedError = chainedError;
}
currentIndex = index;
}
/// <summary>
/// Used to de-serialize the element.
/// </summary>
/// <param name="byteArray">A Byte array</param>
/// <param name="currentIndex">Start position</param>
/// <param name="lengthOfItems">The length of the items</param>
protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
{
int index = currentIndex;
if (lengthOfItems != 0)
{
throw new StreamObjectParseErrorException(currentIndex, "IntermediateNodeObject", "Stream Object over-parse error", null);
}
this.Signature = StreamObject.GetCurrent <SignatureObject>(byteArray, ref index);
this.DataSize = StreamObject.GetCurrent <DataSizeObject>(byteArray, ref index);
currentIndex = index;
}
/// <summary>
/// Used to return the length of this element.
/// </summary>
/// <param name="byteArray">A Byte array</param>
/// <param name="startIndex">Start position</param>
/// <returns>The length of the element</returns>
public override int DeserializeDataElementDataFromByteArray(byte[] byteArray, int startIndex)
{
int index = startIndex;
DataElementHash dataElementHash;
if (StreamObject.TryGetCurrent <DataElementHash>(byteArray, ref index, out dataElementHash))
{
this.DataElementHash = dataElementHash;
}
this.ObjectGroupDeclarations = StreamObject.GetCurrent <ObjectGroupDeclarations>(byteArray, ref index);
ObjectGroupMetadataDeclarations objectMetadataDeclaration = new ObjectGroupMetadataDeclarations();
if (StreamObject.TryGetCurrent <ObjectGroupMetadataDeclarations>(byteArray, ref index, out objectMetadataDeclaration))
{
this.ObjectMetadataDeclaration = objectMetadataDeclaration;
}
this.ObjectGroupData = StreamObject.GetCurrent <ObjectGroupData>(byteArray, ref index);
return(index - startIndex);
}
/// <summary>
/// Deserialize response from byte array.
/// </summary>
/// <param name="byteArray">Server returned message.</param>
/// <param name="startIndex">The index special where start.</param>
/// <returns>The instance of CellResponse.</returns>
public static FsshttpbResponse DeserializeResponseFromByteArray(byte[] byteArray, int startIndex)
{
int index = startIndex;
FsshttpbResponse response = new FsshttpbResponse();
response.ProtocolVersion = LittleEndianBitConverter.ToUInt16(byteArray, index);
index += 2;
response.MinimumVersion = LittleEndianBitConverter.ToUInt16(byteArray, index);
index += 2;
response.Signature = LittleEndianBitConverter.ToUInt64(byteArray, index);
index += 8;
int length = 0;
StreamObjectHeaderStart streamObjectHeader;
if ((length = StreamObjectHeaderStart.TryParse(byteArray, index, out streamObjectHeader)) == 0)
{
throw new ResponseParseErrorException(index, "Failed to parse the response header", null);
}
if (!(streamObjectHeader is StreamObjectHeaderStart32bit))
{
throw new ResponseParseErrorException(index, "Unexpected 16-bit response stream object header, expect 32-bit stream object header for Response", null);
}
if (streamObjectHeader.Type != StreamObjectTypeHeaderStart.FsshttpbResponse)
{
throw new ResponseParseErrorException(index, "Failed to extract the response header type, unexpected value " + streamObjectHeader.Type, null);
}
if (streamObjectHeader.Length != 1)
{
throw new ResponseParseErrorException(index, "Response object over-parse error", null);
}
index += length;
response.ResponseStart = streamObjectHeader as StreamObjectHeaderStart32bit;
response.Status = (byteArray[index] & 0x1) == 0x1 ? true : false;
response.Reserved = (byte)(byteArray[index] >> 1);
index += 1;
try
{
if (response.Status)
{
response.ResponseError = StreamObject.GetCurrent <ResponseError>(byteArray, ref index);
response.DataElementPackage = null;
response.CellSubResponses = null;
}
else
{
DataElementPackage package;
if (StreamObject.TryGetCurrent <DataElementPackage>(byteArray, ref index, out package))
{
response.DataElementPackage = package;
}
response.CellSubResponses = new List <FsshttpbSubResponse>();
FsshttpbSubResponse subResponse;
while (StreamObject.TryGetCurrent <FsshttpbSubResponse>(byteArray, ref index, out subResponse))
{
response.CellSubResponses.Add(subResponse);
}
}
response.ResponseEnd = BasicObject.Parse <StreamObjectHeaderEnd16bit>(byteArray, ref index);
}
catch (StreamObjectParseErrorException streamObjectException)
{
throw new ResponseParseErrorException(index, streamObjectException);
}
catch (DataElementParseErrorException dataElementException)
{
throw new ResponseParseErrorException(index, dataElementException);
}
catch (KnowledgeParseErrorException knowledgeException)
{
throw new ResponseParseErrorException(index, knowledgeException);
}
if (index != byteArray.Length)
{
throw new ResponseParseErrorException(index, "Failed to pass the whole response, not reach the end of the byte array", null);
}
return(response);
}
