/// <summary>
/// Writes the specified <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected void WriteArray(ArrayNode node)
{
if (node.Rank != 1) throw new ArgumentException("Non single-Rank arrays are not supported");
this.writer.WriteAttributeString("type", node.TypeString);
if (node.ObjId != 0) this.writer.WriteAttributeString("id", XmlConvert.ToString(node.ObjId));
if (node.Rank != 1) this.writer.WriteAttributeString("rank", XmlConvert.ToString(node.Rank));
if (node.PrimitiveData != null)
{
this.writer.WriteAttributeString("length", XmlConvert.ToString(node.PrimitiveData.Length));
Array objAsArray = node.PrimitiveData;
if (objAsArray is byte[])
{
byte[] byteArr = objAsArray as byte[];
this.writer.WriteString(this.ByteArrayToString(byteArr));
}
else
{
SerializeType elemType = objAsArray.GetType().GetElementType().GetSerializeType();
for (long l = 0; l < objAsArray.Length; l++)
this.WriteObject(new PrimitiveNode(elemType.DataType, objAsArray.GetValue(l)));
}
}
else
{
this.writer.WriteAttributeString("length", XmlConvert.ToString(node.SubNodes.Count()));
foreach (DataNode subNode in node.SubNodes)
this.WriteObject(subNode);
}
}
/// <summary>
/// Writes the specified <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected void WriteArray(ArrayNode node)
{
if (node.Rank != 1) throw new ArgumentException("Non single-Rank arrays are not supported");
this.writer.Write(node.TypeString);
this.writer.Write(node.ObjId);
this.writer.Write(node.Rank);
if (node.PrimitiveData != null)
{
this.writer.Write(node.PrimitiveData.Length);
Array objAsArray = node.PrimitiveData;
if (objAsArray is bool[]) this.WriteArrayData(objAsArray as bool[]);
else if (objAsArray is byte[]) this.WriteArrayData(objAsArray as byte[]);
else if (objAsArray is sbyte[]) this.WriteArrayData(objAsArray as sbyte[]);
else if (objAsArray is short[]) this.WriteArrayData(objAsArray as short[]);
else if (objAsArray is ushort[]) this.WriteArrayData(objAsArray as ushort[]);
else if (objAsArray is int[]) this.WriteArrayData(objAsArray as int[]);
else if (objAsArray is uint[]) this.WriteArrayData(objAsArray as uint[]);
else if (objAsArray is long[]) this.WriteArrayData(objAsArray as long[]);
else if (objAsArray is ulong[]) this.WriteArrayData(objAsArray as ulong[]);
else if (objAsArray is float[]) this.WriteArrayData(objAsArray as float[]);
else if (objAsArray is double[]) this.WriteArrayData(objAsArray as double[]);
else if (objAsArray is decimal[]) this.WriteArrayData(objAsArray as decimal[]);
else if (objAsArray is char[]) this.WriteArrayData(objAsArray as char[]);
else if (objAsArray is string[]) this.WriteArrayData(objAsArray as string[]);
}
else
{
this.writer.Write(node.SubNodes.Count());
foreach (DataNode subNode in node.SubNodes)
this.WriteObject(subNode);
}
}
/// <summary>
/// Writes the specified <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected void WriteArray(ArrayNode node)
{
if (node.Rank != 1)
{
throw new ArgumentException("Non single-Rank arrays are not supported");
}
this.writer.WriteAttributeString("type", node.TypeString);
if (node.ObjId != 0)
{
this.writer.WriteAttributeString("id", XmlConvert.ToString(node.ObjId));
}
if (node.Rank != 1)
{
this.writer.WriteAttributeString("rank", XmlConvert.ToString(node.Rank));
}
if (node.PrimitiveData != null)
{
this.writer.WriteAttributeString("length", XmlConvert.ToString(node.PrimitiveData.Length));
Array objAsArray = node.PrimitiveData;
if (objAsArray is byte[])
{
byte[] byteArr = objAsArray as byte[];
this.writer.WriteString(this.ByteArrayToString(byteArr));
}
else
{
SerializeType elemType = objAsArray.GetType().GetElementType().GetSerializeType();
if (elemType.DataType == DataType.String)
{
for (long l = 0; l < objAsArray.Length; l++)
{
string str = (string)objAsArray.GetValue(l);
this.WriteObjectData(str != null ? new StringNode(str) : this.GetNullObject());
}
}
else
{
for (long l = 0; l < objAsArray.Length; l++)
{
this.WriteObjectData(new PrimitiveNode(elemType.DataType, objAsArray.GetValue(l)));
}
}
}
}
else
{
this.writer.WriteAttributeString("length", XmlConvert.ToString(node.SubNodes.Count()));
foreach (DataNode subNode in node.SubNodes)
{
this.WriteObjectData(subNode);
}
}
}
/// <summary>
/// Reads an <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected ArrayNode ReadArray()
{
string arrTypeString = this.reader.ReadString();
uint objId = this.reader.ReadUInt32();
int arrRank = this.reader.ReadInt32();
int arrLength = this.reader.ReadInt32();
Type arrType = ReflectionHelper.ResolveType(arrTypeString, false);
ArrayNode result = new ArrayNode(arrTypeString, objId, arrRank, arrLength);
// Prepare object reference
this.idManager.Inject(result, objId);
// Store primitive data block
bool nonPrimitive = false;
if (arrType != null)
{
Array arrObj = Array.CreateInstance(arrType.GetElementType(), arrLength);
if (arrObj is bool[]) this.ReadArrayData(arrObj as bool[]);
else if (arrObj is byte[]) this.ReadArrayData(arrObj as byte[]);
else if (arrObj is sbyte[]) this.ReadArrayData(arrObj as sbyte[]);
else if (arrObj is short[]) this.ReadArrayData(arrObj as short[]);
else if (arrObj is ushort[]) this.ReadArrayData(arrObj as ushort[]);
else if (arrObj is int[]) this.ReadArrayData(arrObj as int[]);
else if (arrObj is uint[]) this.ReadArrayData(arrObj as uint[]);
else if (arrObj is long[]) this.ReadArrayData(arrObj as long[]);
else if (arrObj is ulong[]) this.ReadArrayData(arrObj as ulong[]);
else if (arrObj is float[]) this.ReadArrayData(arrObj as float[]);
else if (arrObj is double[]) this.ReadArrayData(arrObj as double[]);
else if (arrObj is decimal[]) this.ReadArrayData(arrObj as decimal[]);
else if (arrObj is char[]) this.ReadArrayData(arrObj as char[]);
else if (arrObj is string[]) this.ReadArrayData(arrObj as string[]);
else
nonPrimitive = true;
if (!nonPrimitive) result.PrimitiveData = arrObj;
}
else
nonPrimitive = true;
// Store other data as sub-nodes
if (nonPrimitive)
{
for (int i = 0; i < arrLength; i++)
{
DataNode child = this.ReadObjectData() as DataNode;
child.Parent = result;
}
}
return result;
}
/// <summary>
/// Reads an <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected ArrayNode ReadArray()
{
string arrTypeString = this.reader.GetAttribute("type");
string objIdString = this.reader.GetAttribute("id");
string arrRankString = this.reader.GetAttribute("rank");
string arrLengthString = this.reader.GetAttribute("length");
uint objId = objIdString == null ? 0 : XmlConvert.ToUInt32(objIdString);
int arrRank = arrRankString == null ? 1 : XmlConvert.ToInt32(arrRankString);
int arrLength = arrLengthString == null ? 0 : XmlConvert.ToInt32(arrLengthString);
Type arrType = ReflectionHelper.ResolveType(arrTypeString, false);
ArrayNode result = new ArrayNode(arrTypeString, objId, arrRank, arrLength);
// Prepare object reference
this.idManager.Inject(result, objId);
// Store primitive data block
bool nonPrimitive;
if (arrType != null)
{
Array arrObj = Array.CreateInstance(arrType.GetElementType(), arrLength);
if (arrObj is bool[] ||
arrObj is byte[] || arrObj is sbyte[] ||
arrObj is short[] || arrObj is ushort[] ||
arrObj is int[] || arrObj is uint[] ||
arrObj is long[] || arrObj is ulong[] ||
arrObj is float[] || arrObj is double[] ||
arrObj is decimal[] ||
arrObj is char[] || arrObj is string[])
nonPrimitive = false;
else
nonPrimitive = true;
if (!nonPrimitive)
{
if (arrObj is byte[])
{
byte[] byteArr = arrObj as byte[];
string binHexString = this.reader.ReadString();
byte[] byteArr2 = this.StringToByteArray(binHexString);
for (int l = 0; l < arrLength; l++)
byteArr[l] = byteArr2[l];
}
else
{
for (int l = 0; l < arrLength; l++)
{
PrimitiveNode elemNode = this.ReadObject() as PrimitiveNode;
if (arrObj != null) arrObj.SetValue(elemNode.PrimitiveValue, l);
}
}
result.PrimitiveData = arrObj;
}
}
else
nonPrimitive = true;
// Store other data as sub-nodes
if (nonPrimitive)
{
for (int i = 0; i < arrLength; i++)
{
DataNode child = this.ReadObject() as DataNode;
child.Parent = result;
}
}
return result;
}
/// <summary>
/// Reads an <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected ArrayNode ReadArray()
{
string arrTypeString = this.reader.ReadString();
uint objId = this.reader.ReadUInt32();
int arrRank = this.reader.ReadInt32();
int arrLength = this.reader.ReadInt32();
Type arrType = ReflectionHelper.ResolveType(arrTypeString, false);
ArrayNode result = new ArrayNode(arrTypeString, objId, arrRank, arrLength);
// Prepare object reference
this.idManager.Inject(result, objId);
// Store primitive data block
bool nonPrimitive = false;
if (arrType != null)
{
Array arrObj = Array.CreateInstance(arrType.GetElementType(), arrLength);
if (arrObj is bool[])
{
this.ReadArrayData(arrObj as bool[]);
}
else if (arrObj is byte[])
{
this.ReadArrayData(arrObj as byte[]);
}
else if (arrObj is sbyte[])
{
this.ReadArrayData(arrObj as sbyte[]);
}
else if (arrObj is short[])
{
this.ReadArrayData(arrObj as short[]);
}
else if (arrObj is ushort[])
{
this.ReadArrayData(arrObj as ushort[]);
}
else if (arrObj is int[])
{
this.ReadArrayData(arrObj as int[]);
}
else if (arrObj is uint[])
{
this.ReadArrayData(arrObj as uint[]);
}
else if (arrObj is long[])
{
this.ReadArrayData(arrObj as long[]);
}
else if (arrObj is ulong[])
{
this.ReadArrayData(arrObj as ulong[]);
}
else if (arrObj is float[])
{
this.ReadArrayData(arrObj as float[]);
}
else if (arrObj is double[])
{
this.ReadArrayData(arrObj as double[]);
}
else if (arrObj is decimal[])
{
this.ReadArrayData(arrObj as decimal[]);
}
else if (arrObj is char[])
{
this.ReadArrayData(arrObj as char[]);
}
else if (arrObj is string[])
{
this.ReadArrayData(arrObj as string[]);
}
else
{
nonPrimitive = true;
}
if (!nonPrimitive)
{
result.PrimitiveData = arrObj;
}
}
else
{
nonPrimitive = true;
}
// Store other data as sub-nodes
if (nonPrimitive)
{
for (int i = 0; i < arrLength; i++)
{
DataNode child = this.ReadObject() as DataNode;
child.Parent = result;
}
}
return(result);
}
/// <summary>
/// Writes the specified <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected void WriteArray(ArrayNode node)
{
if (node.Rank != 1)
{
throw new ArgumentException("Non single-Rank arrays are not supported");
}
this.writer.Write(node.TypeString);
this.writer.Write(node.ObjId);
this.writer.Write(node.Rank);
if (node.PrimitiveData != null)
{
this.writer.Write(node.PrimitiveData.Length);
Array objAsArray = node.PrimitiveData;
if (objAsArray is bool[])
{
this.WriteArrayData(objAsArray as bool[]);
}
else if (objAsArray is byte[])
{
this.WriteArrayData(objAsArray as byte[]);
}
else if (objAsArray is sbyte[])
{
this.WriteArrayData(objAsArray as sbyte[]);
}
else if (objAsArray is short[])
{
this.WriteArrayData(objAsArray as short[]);
}
else if (objAsArray is ushort[])
{
this.WriteArrayData(objAsArray as ushort[]);
}
else if (objAsArray is int[])
{
this.WriteArrayData(objAsArray as int[]);
}
else if (objAsArray is uint[])
{
this.WriteArrayData(objAsArray as uint[]);
}
else if (objAsArray is long[])
{
this.WriteArrayData(objAsArray as long[]);
}
else if (objAsArray is ulong[])
{
this.WriteArrayData(objAsArray as ulong[]);
}
else if (objAsArray is float[])
{
this.WriteArrayData(objAsArray as float[]);
}
else if (objAsArray is double[])
{
this.WriteArrayData(objAsArray as double[]);
}
else if (objAsArray is decimal[])
{
this.WriteArrayData(objAsArray as decimal[]);
}
else if (objAsArray is char[])
{
this.WriteArrayData(objAsArray as char[]);
}
else if (objAsArray is string[])
{
this.WriteArrayData(objAsArray as string[]);
}
}
else
{
this.writer.Write(node.SubNodes.Count());
foreach (DataNode subNode in node.SubNodes)
{
this.WriteObject(subNode);
}
}
}
/// <summary>
/// Reads an <see cref="Duality.Serialization.MetaFormat.ArrayNode"/>, including possible child nodes.
/// </summary>
/// <param name="node"></param>
protected ArrayNode ReadArray()
{
string arrTypeString = this.reader.GetAttribute("type");
string objIdString = this.reader.GetAttribute("id");
string arrRankString = this.reader.GetAttribute("rank");
string arrLengthString = this.reader.GetAttribute("length");
uint objId = objIdString == null ? 0 : XmlConvert.ToUInt32(objIdString);
int arrRank = arrRankString == null ? 1 : XmlConvert.ToInt32(arrRankString);
int arrLength = arrLengthString == null ? 0 : XmlConvert.ToInt32(arrLengthString);
Type arrType = ReflectionHelper.ResolveType(arrTypeString, false);
ArrayNode result = new ArrayNode(arrTypeString, objId, arrRank, arrLength);
// Prepare object reference
this.idManager.Inject(result, objId);
// Store primitive data block
bool nonPrimitive;
if (arrType != null)
{
Array arrObj = Array.CreateInstance(arrType.GetElementType(), arrLength);
if (arrObj is bool[] ||
arrObj is byte[] || arrObj is sbyte[] ||
arrObj is short[] || arrObj is ushort[] ||
arrObj is int[] || arrObj is uint[] ||
arrObj is long[] || arrObj is ulong[] ||
arrObj is float[] || arrObj is double[] ||
arrObj is decimal[] ||
arrObj is char[] || arrObj is string[])
{
nonPrimitive = false;
}
else
{
nonPrimitive = true;
}
if (!nonPrimitive)
{
if (arrObj is byte[])
{
byte[] byteArr = arrObj as byte[];
string binHexString = this.reader.ReadString();
byte[] byteArr2 = this.StringToByteArray(binHexString);
for (int l = 0; l < arrLength; l++)
{
byteArr[l] = byteArr2[l];
}
}
else
{
for (int l = 0; l < arrLength; l++)
{
DataNode elemNode = this.ReadObjectData() as DataNode;
if (arrObj != null)
{
if (elemNode is PrimitiveNode)
{
arrObj.SetValue((elemNode as PrimitiveNode).PrimitiveValue, l);
}
else if (elemNode is StringNode)
{
arrObj.SetValue((elemNode as StringNode).StringValue, l);
}
}
}
}
result.PrimitiveData = arrObj;
}
}
else
{
nonPrimitive = true;
}
// Store other data as sub-nodes
if (nonPrimitive)
{
for (int i = 0; i < arrLength; i++)
{
DataNode child = this.ReadObjectData() as DataNode;
child.Parent = result;
}
}
return(result);
}
