/// <summary>
/// Initializes a new ArrayDataView from array.
/// </summary>
///
/// <param name="array">array of data.</param>
///
public ArrayDataView(Array array)
{
if (array.Rank > 2)
{
throw new ArgumentException("Supports only up to two dimentional arrays", "array");
}
this.data = array;
if (array.Rank == 2)
{
rowCount = array.GetLength(0);
colCount = array.GetLength(1);
type = ArrayDataType.Multidimensional;
rows = new ArrayRowView[rowCount];
for (int i = 0; i < rows.Length; i++)
{
rows[i] = new ArrayRowView(this, i);
}
}
else
{
rowCount = 1;
colCount = array.GetLength(0);
rows = new ArrayRowView[] { new ArrayRowView(this, 0) };
type = ArrayDataType.Simple;
}
}
protected override LambdaExpression MakeArray(ArrayDataType type, LambdaExpression elementType)
{
if (!type.UnderlyingType.IsArray)
{
return(MakeList(type, elementType));
}
var streamParameter = Expression.Parameter(typeof(Stream), "stream");
var resultParameter = Expression.Parameter(type.UnderlyingType, "result");
var lengthParameter = Expression.Parameter(typeof(int), "length");
var loopParameter = Expression.Parameter(typeof(int), "i");
var tcParameter = Expression.Parameter(typeof(byte), "tc");
var serializerParameter = default(ParameterExpression);
var innerInvoke = MakeInnerDeserialize(elementType, streamParameter, ref serializerParameter);
var typeCode = Protocol.TYPE_ARRAY;
var typeCodeConstant = Expression.Constant(typeCode, typeof(byte));
var body = Expression.Block(
// byte tc;
// T[] result;
new[] { tcParameter, resultParameter },
// tc = stream.ReadByte();
Expression.Assign(tcParameter, Expression.Call(ReflectionConstants.ReadByte, streamParameter)),
// if (tc & typeCode != typeCode) throw new InvalidDataException("Unexpected type code.");
Expression.IfThen(
Expression.NotEqual(Expression.And(tcParameter, typeCodeConstant), typeCodeConstant),
ReflectionConstants.ThrowUnexpectedTypeCode
),
// if (tc & Protocol.TYPE_FLAG_NULLVALUE == Protocol.TYPE_FLAG_NULLVALUE) return null;
Expression.Condition(
Expression.Equal(Expression.And(tcParameter, ReflectionConstants.NullValueFlag), ReflectionConstants.NullValueFlag),
Expression.Convert(ReflectionConstants.NullObject, type.UnderlyingType),
// else {
Expression.Block(
// int length, i;
new[] { lengthParameter, loopParameter },
// length = (int)stream.ReadUInt32Compact();
Expression.Assign(lengthParameter, Expression.ConvertChecked(Expression.Call(ReflectionConstants.ReadIntCompact, streamParameter), typeof(int))),
// result = new T[length];
Expression.Assign(resultParameter, Expression.NewArrayBounds(type.ElementType.UnderlyingType, lengthParameter)),
// var i = 0; while (true) { if (i < length) { result[i] = /* ... deserialize inner ... */; i++; } else { break; } }
ExpressionHelpers.For(
Expression.Assign(loopParameter, ReflectionConstants.ZeroInt32),
Expression.LessThan(loopParameter, lengthParameter),
Expression.PreIncrementAssign(loopParameter),
Expression.Assign(Expression.ArrayAccess(resultParameter, loopParameter), innerInvoke)
),
// return result;
resultParameter
)
// }
)
);
return(serializerParameter == null
? Expression.Lambda(body, streamParameter)
: Expression.Lambda(body, serializerParameter, streamParameter));
}
private TypeInfo CreateArrayType(ArrayDataType arrayType)
{
var result = new ArrayTypeInfo(arrayType.IsUnique, arrayType.IsOptional);
SetTypeInfoDelayed(arrayType.ElementType, result.SetElementType);
return(result);
}
void WriteZeroDefaultValuesForArrays(StreamWriter writer, ArrayDataType datatype)
{
writer.Write("{ { ");
for (int i = 0; i < datatype.Size; i++)
{
WriteZeroDefaultValue(writer, datatype.DataType);
if (i < datatype.Size - 1)
{
writer.Write(", ");
}
}
writer.Write(" } }");
}
/// <summary>
/// Checks if a constant can be converted from one array data type to another.
/// </summary>
/// <param name="newValue">Value to convert.</param>
/// <param name="oldDataType">Old data type.</param>
protected virtual void CheckConstantArray(Object newValue, ArrayDataType oldDataType)
{
var oldArray = oldDataType.GetList(newValue.Value);
if (!Helpers.TryGetElementType(newValue.TypeSlim, out var newElementType))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot convert constant of type '{0}' to type '{1}'.", oldDataType.UnderlyingType.ToCSharpStringPretty(), newValue.TypeSlim));
}
for (var i = 0; i < oldArray.Count; i++)
{
var oldElement = Object.Create(oldArray[i], newElementType, oldDataType.UnderlyingType);
CheckConstant(oldElement, oldDataType.ElementType);
}
}
/// <summary>
/// Initializes a new ArrayDataView from array with custom column names.
/// </summary>
///
/// <param name="array">array of data.</param>
/// <param name="columnNames">collection of column names.</param>
///
public ArrayDataView(Array array, object[] columnNames)
: this(array)
{
if (array.Rank == 2)
{
if (columnNames.Length != array.GetLength(1))
{
throw new ArgumentException("column names must correspond to array columns.", "columnNames");
}
rowCount = array.GetLength(0);
colCount = array.GetLength(1);
type = ArrayDataType.Multidimensional;
}
else
{
if (array.GetValue(0) is Array)
{
Array row = array.GetValue(0) as Array;
if (columnNames.Length != row.GetLength(0))
{
throw new ArgumentException("column names must correspond to array columns.", "columnNames");
}
rowCount = array.GetLength(0);
colCount = row.GetLength(0);
type = ArrayDataType.Jagged;
}
else
{
if (columnNames.Length != array.GetLength(0))
{
throw new ArgumentException("column names must correspond to array columns.", "columnNames");
}
rowCount = 1;
colCount = array.GetLength(0);
type = ArrayDataType.Simple;
}
}
this.columnNames = new string[columnNames.Length];
for (int i = 0; i < columnNames.Length; i++)
{
this.columnNames[i] = columnNames[i].ToString();
}
}
internal static void ReadDataFromSpectrumNavigator(XPathNodeIterator binaryDataArrayChildNodes, out double[] mz, out double[] intensity)
{
mz = null;
intensity = null;
int word_length_in_bytes = 0;
bool zlib_compressed = false;
ArrayDataType array_data_type = ArrayDataType.Unknown;
foreach(XPathNavigator navigator in binaryDataArrayChildNodes)
{
if(navigator.Name.Equals("cvParam", StringComparison.OrdinalIgnoreCase))
{
if(navigator.GetAttribute("name", string.Empty).Equals("32-bit float", StringComparison.OrdinalIgnoreCase))
{
word_length_in_bytes = 4;
}
else if(navigator.GetAttribute("name", string.Empty).Equals("64-bit float", StringComparison.OrdinalIgnoreCase))
{
word_length_in_bytes = 8;
}
else if(navigator.GetAttribute("name", string.Empty).Equals("zlib compression", StringComparison.OrdinalIgnoreCase))
{
zlib_compressed = true;
}
else if(navigator.GetAttribute("name", string.Empty).Equals("m/z array", StringComparison.OrdinalIgnoreCase))
{
array_data_type = ArrayDataType.MZ;
}
else if(navigator.GetAttribute("name", string.Empty).Equals("intensity array", StringComparison.OrdinalIgnoreCase))
{
array_data_type = ArrayDataType.Intensity;
}
}
else if(navigator.Name.Equals("binary", StringComparison.OrdinalIgnoreCase))
{
if(array_data_type == ArrayDataType.MZ)
{
mz = ReadBase64EncodedDoubleArray(navigator.InnerXml, word_length_in_bytes, zlib_compressed);
}
else if(array_data_type == ArrayDataType.Intensity)
{
intensity = ReadBase64EncodedDoubleArray(navigator.InnerXml, word_length_in_bytes, zlib_compressed);
}
}
}
}
private void AddArrayDataTypeMenu_Click(object sender, RoutedEventArgs e)
{
string ArrayDataTypeTemplateName = "New_ArrayDataType";
if (autosarApp.ArrayDataTypes.FindObject(ArrayDataTypeTemplateName) != null)
{
int index = 0;
while (autosarApp.ComplexDataTypes.FindObject(ArrayDataTypeTemplateName) != null)
{
index++;
ArrayDataTypeTemplateName = "New_ArrayDataType" + index.ToString();
}
}
ArrayDataType datatype = DataTypeFabric.Instance().CreateArrayDataType(ArrayDataTypeTemplateName);
autosarApp.ArrayDataTypes.Add(datatype);
AutosarTree.UpdateAutosarTreeView(datatype);
AutosarTree.Focus();
}
public IGUID GetDataType(Guid GUID)
{
BaseDataType baseDatatype = BaseDataTypes.FindObject(GUID);
if (baseDatatype != null)
{
return(baseDatatype);
}
SimpleDataType simpleDataType = SimpleDataTypes.FindObject(GUID);
if (simpleDataType != null)
{
return(simpleDataType);
}
ComplexDataType complexDataType = ComplexDataTypes.FindObject(GUID);
if (complexDataType != null)
{
return(complexDataType);
}
EnumDataType enumDataType = Enums.FindObject(GUID);
if (enumDataType != null)
{
return(enumDataType);
}
ArrayDataType arrayDataType = ArrayDataTypes.FindObject(GUID);
if (arrayDataType != null)
{
return(arrayDataType);
}
return(null);
}
public String GetDataTypeName(Guid GUID)
{
ArrayDataType arrayDatatype = ArrayDataTypes.FindObject(GUID);
if (arrayDatatype != null)
{
return(arrayDatatype.Name);
}
BaseDataType baseDatatype = BaseDataTypes.FindObject(GUID);
if (baseDatatype != null)
{
return(baseDatatype.Name);
}
SimpleDataType simpleDataType = SimpleDataTypes.FindObject(GUID);
if (simpleDataType != null)
{
return(simpleDataType.Name);
}
ComplexDataType complexDataType = ComplexDataTypes.FindObject(GUID);
if (complexDataType != null)
{
return(complexDataType.Name);
}
EnumDataType enumDataType = Enums.FindObject(GUID);
if (enumDataType != null)
{
return(enumDataType.Name);
}
return(ErrorDataType);
}
/// <summary>
/// Converts a constant from one array data type to another.
/// </summary>
/// <param name="originalValue">Original value to convert.</param>
/// <param name="oldDataType">Old data type.</param>
/// <param name="newDataType">New data type.</param>
/// <returns>Converted constant.</returns>
protected virtual object ConvertConstantArray(object originalValue, ArrayDataType oldDataType, ArrayDataType newDataType)
{
var oldArray = oldDataType.GetList(originalValue);
var newArray = (IList)newDataType.CreateInstance(oldArray.Count);
ConstantsMap[originalValue] = newArray; // Allow cycles
for (var i = 0; i < oldArray.Count; i++)
{
var oldElement = oldArray[i];
var newElement = ConvertConstant(oldElement, oldDataType.ElementType, newDataType.ElementType);
if (newArray.IsFixedSize)
{
newArray[i] = newElement;
}
else
{
newArray.Add(newElement);
}
}
return(newArray);
}
internal DataBlockDefinition(BlockDefinition blockDef, ArrayDataType dataType)
: base(blockDef.Module, blockDef.Id, blockDef.Offset, blockDef.Length)
{
DataType = dataType;
}
/// <summary>
/// Initializes a new ArrayDataView from array.
/// </summary>
///
/// <param name="array">array of data.</param>
///
public ArrayDataView(Array array)
{
if (array.Rank > 2)
throw new ArgumentException("Supports only up to two dimensional arrays", "array");
this.data = array;
if (array.Rank == 2)
{
rowCount = array.GetLength(0);
colCount = array.GetLength(1);
type = ArrayDataType.Multidimensional;
}
else
{
if (array.GetValue(0) is Array)
{
Array row = array.GetValue(0) as Array;
rowCount = array.GetLength(0);
colCount = row.GetLength(0);
type = ArrayDataType.Jagged;
}
else
{
rowCount = 1;
colCount = array.GetLength(0);
type = ArrayDataType.Simple;
}
}
rows = new ArrayRowView[rowCount];
for (int i = 0; i < rows.Length; i++)
rows[i] = new ArrayRowView(this, i);
}
public ArrayDataType CreateArrayDataType(string Name)
{
ArrayDataType datatype = new ArrayDataType();
datatype.Name = Name;
return datatype;
}
/// <summary>
/// Initializes a new ArrayDataView from array with custom column names.
/// </summary>
///
/// <param name="array">Array of data.</param>
/// <param name="columnNames">Collection of column names.</param>
/// <param name="rowNames">Collecion of row names.</param>
///
public ArrayDataView(Array array, object[] columnNames, object[] rowNames)
: this(array)
{
if (array.Rank == 2)
{
if (columnNames.Length != array.GetLength(1))
throw new ArgumentException("Column names must correspond to array columns.", "columnNames");
if (rowNames.Length != array.GetLength(0))
throw new ArgumentException("Row names must correspond to array rows.", "rowNames");
rowCount = array.GetLength(0);
colCount = array.GetLength(1);
type = ArrayDataType.Multidimensional;
}
else
{
if (array.GetValue(0) is Array)
{
Array row = array.GetValue(0) as Array;
if (columnNames.Length != row.GetLength(0))
throw new ArgumentException("column names must correspond to array columns.", "columnNames");
if (rowNames.Length != array.GetLength(0))
throw new ArgumentException("Row names must correspond to array rows.", "rowNames");
rowCount = array.GetLength(0);
colCount = row.GetLength(0);
type = ArrayDataType.Jagged;
}
else
{
if (columnNames.Length != array.GetLength(0))
throw new ArgumentException("column names must correspond to array columns.", "columnNames");
if (rowNames.Length != 1)
throw new ArgumentException("Row names must correspond to array rows.", "rowNames");
rowCount = 1;
colCount = array.GetLength(0);
type = ArrayDataType.Simple;
}
}
this.columnNames = new string[columnNames.Length];
for (int i = 0; i < columnNames.Length; i++)
this.columnNames[i] = columnNames[i].ToString();
this.rowNames = new string[rowNames.Length];
for (int i = 0; i < rowNames.Length; i++)
this.rowNames[i] = rowNames[i].ToString();
}
public bool Delete(ArrayDataType arrayDataType)
{
arrayDataTypes.Remove(arrayDataType);
return(true);
}
public virtual void VisitArrayDataType(ArrayDataType arrayDataType)
{
DefaultVisit(arrayDataType);
}
protected override Type MakeArray(ArrayDataType type, Type elementType)
{
return(elementType.MakeArrayType());
}
public DataBlockDefinition AsData(ArrayDataType elementDataType) => new DataBlockDefinition(this, elementDataType);
