/// <summary>
/// This method is used to deserialize the items of the cell knowledge from the byte array.
/// </summary>
/// <param name="byteArray">Specify the byte array.</param>
/// <param name="currentIndex">Specify the start index from the byte array.</param>
/// <param name="lengthOfItems">Specify the current length of items in the cell knowledge.</param>
protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems)
{
if (lengthOfItems != 0)
{
throw new KnowledgeParseErrorException(currentIndex, "CellKnowledge object over-parse error", null);
}
int index = currentIndex;
StreamObjectHeaderStart header;
int length = 0;
this.CellKnowledgeEntryList = new List <CellKnowledgeEntry>();
this.CellKnowledgeRangeList = new List <CellKnowledgeRange>();
while ((length = StreamObjectHeaderStart.TryParse(byteArray, index, out header)) != 0)
{
index += length;
if (header.Type == StreamObjectTypeHeaderStart.CellKnowledgeEntry)
{
this.CellKnowledgeEntryList.Add(StreamObject.ParseStreamObject(header, byteArray, ref index) as CellKnowledgeEntry);
}
else if (header.Type == StreamObjectTypeHeaderStart.CellKnowledgeRange)
{
this.CellKnowledgeRangeList.Add(StreamObject.ParseStreamObject(header, byteArray, ref index) as CellKnowledgeRange);
}
else
{
throw new KnowledgeParseErrorException(currentIndex, "Failed to parse CellKnowledge, expect the inner object type is either CellKnowledgeEntry or CellKnowledgeRange but actual type value is " + header.Type, null);
}
}
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)
{
if (lengthOfItems != 0)
{
throw new StreamObjectParseErrorException(currentIndex, "ObjectGroupMetadataDeclarations", "Stream object over-parse error", null);
}
int index = currentIndex;
int headerLength = 0;
StreamObjectHeaderStart header;
this.ObjectGroupMetadataList = new List <ObjectGroupMetadata>();
while ((headerLength = StreamObjectHeaderStart.TryParse(byteArray, index, out header)) != 0)
{
index += headerLength;
if (header.Type == StreamObjectTypeHeaderStart.ObjectGroupMetadata)
{
this.ObjectGroupMetadataList.Add(StreamObject.ParseStreamObject(header, byteArray, ref index) as ObjectGroupMetadata);
}
else
{
throw new StreamObjectParseErrorException(index, "ObjectGroupDeclarations", "Failed to parse ObjectGroupMetadataDeclarations, expect the inner object type ObjectGroupMetadata, but actual type value is " + header.Type, null);
}
}
currentIndex = index;
}
/// <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>
/// Used to de-serialize the data element.
/// </summary>
/// <param name="byteArray">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;
int headerLength = 0;
StreamObjectHeaderStart header;
bool isStorageIndexManifestMappingExist = false;
while ((headerLength = StreamObjectHeaderStart.TryParse(byteArray, index, out header)) != 0)
{
index += headerLength;
if (header.Type == StreamObjectTypeHeaderStart.StorageIndexManifestMapping)
{
if (isStorageIndexManifestMappingExist)
{
throw new DataElementParseErrorException(index - headerLength, "Failed to parse StorageIndexDataElement, only can contain zero or one StorageIndexManifestMapping", null);
}
this.StorageIndexManifestMapping = StreamObject.ParseStreamObject(header, byteArray, ref index) as StorageIndexManifestMapping;
isStorageIndexManifestMappingExist = true;
}
else if (header.Type == StreamObjectTypeHeaderStart.StorageIndexCellMapping)
{
this.StorageIndexCellMappingList.Add(StreamObject.ParseStreamObject(header, byteArray, ref index) as StorageIndexCellMapping);
}
else if (header.Type == StreamObjectTypeHeaderStart.StorageIndexRevisionMapping)
{
this.StorageIndexRevisionMappingList.Add(StreamObject.ParseStreamObject(header, byteArray, ref index) as StorageIndexRevisionMapping);
}
else
{
throw new DataElementParseErrorException(index - headerLength, "Failed to parse StorageIndexDataElement, expect the inner object type StorageIndexCellMapping or StorageIndexRevisionMapping, but actual type value is " + header.Type, null);
}
}
return(index - startIndex);
}
