public ArrayElementValueIterator(IArrayValue arrayValue)
{
this._arrayValue = arrayValue;
this._array = (IArrayInstance)arrayValue.Symbol;
this._type = (IArrayType)arrayValue.DataType;
this._indexIter = new ArrayIndexIterator(this._type);
}
private Array createPrimitiveValueArray(IArrayInstance arraySymbol, byte[] rawData, int offset, DateTime utcReadTime)
{
Array array = null;
IArrayType dataType = (IArrayType)arraySymbol.DataType;
IDataType elementType = dataType.ElementType;
IResolvableType type3 = elementType as IResolvableType;
if (type3 != null)
{
elementType = type3.ResolveType(DataTypeResolveStrategy.AliasReference);
}
int elementCount = dataType.Dimensions.ElementCount;
Type managed = null;
int[] dimensionLengths = dataType.Dimensions.GetDimensionLengths();
Array.Reverse(dimensionLengths);
array = !base.valueConverter.TryGetManagedType(elementType, out managed) ? Array.CreateInstance(typeof(object), dimensionLengths) : Array.CreateInstance(managed, dimensionLengths);
foreach (int[] numArray2 in new ArrayIndexIterator(dataType, false))
{
int[] numArray3 = ArrayIndexConverter.NormalizeIndices(numArray2, dataType);
Array.Reverse(numArray3);
int num2 = ArrayIndexConverter.IndicesToSubIndex(numArray2, dataType);
object obj2 = this.CreateValue(arraySymbol.SubSymbols[num2], rawData, offset, utcReadTime);
array.SetValue(obj2, numArray3);
offset += elementType.ByteSize;
}
return(array);
}
public object ReadArrayElement(IArrayInstance symbol, int[] indices, out DateTime utcReadTime)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
if (indices == null)
{
throw new ArgumentNullException("indices");
}
if (indices.Length == 0)
{
throw new ArgumentOutOfRangeException("indices");
}
int num = 0;
object result = null;
string str = string.Join <int>(",", indices);
num = this.tryReadValue(symbol, indices, out result, out utcReadTime);
if (num == 0)
{
return(true);
}
Exception ex = new SymbolException($"Could not read ArrayInstance '{symbol.InstancePath}[{str}]'! Error: {num}", symbol);
Module.Trace.TraceError(ex);
throw ex;
}
private bool TryGetSubSymbol(IArrayInstance root, int[] indices, out T found)
{
IArrayType dataType = (IArrayType)root.DataType;
ISymbol symbol = null;
T local = default(T);
if (!root.TryGetElement(indices, out symbol))
{
found = default(T);
return(false);
}
local = (T)symbol;
found = local;
return(true);
}
private bool TryGetSubSymbol(T root, string[] relativePath, int index, out T found)
{
string instanceName = null;
IList <int[]> list;
SymbolParser.ArrayIndexType type;
string indicesStr = null;
IList <ISymbol> list2;
if (!SymbolParser.TryParseArrayElement(relativePath[index], out instanceName, out indicesStr, out list, out type))
{
if (root.Category == DataTypeCategory.Struct)
{
return(this.TryGetSubSymbol((IStructInstance)root, relativePath, index, out found));
}
found = default(T);
return(false);
}
((IStructInstance)root).MemberInstances.TryGetInstanceByName(instanceName, out list2);
IArrayInstance instance2 = (IArrayInstance)list2[0];
T local = default(T);
bool flag = true;
int num = 0;
while (true)
{
if (num < list.Count)
{
flag &= this.TryGetSubSymbol(instance2, list[num], out local);
if (flag)
{
instance2 = local as IArrayInstance;
num++;
continue;
}
}
if (flag)
{
found = local;
}
else
{
found = default(T);
}
return(flag);
}
}
private void WriteArrayElement(IArrayInstance arrInstance, int[] indices, object value, out DateTime utcWriteTime)
{
if (arrInstance == null)
{
throw new ArgumentNullException("arrInstance");
}
if (indices == null)
{
throw new ArgumentNullException("indices");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
IArrayType dataType = (IArrayType)arrInstance.DataType;
IDataType elementType = dataType.ElementType;
ArrayType.CheckIndices(indices, dataType, false);
int elementPosition = ArrayType.GetElementPosition(indices, dataType);
ISymbol symbol = arrInstance.SubSymbols[elementPosition];
this.WriteValue(symbol, value, out utcWriteTime);
}
public bool TryGetElement(IList <int[]> jaggedIndices, out ISymbol symbol)
{
if (jaggedIndices == null)
{
throw new ArgumentNullException("jaggedIndices");
}
if (((IArrayType)base.DataType).JaggedLevel < jaggedIndices.Count)
{
throw new ArgumentOutOfRangeException("jaggedIndices");
}
bool flag = true;
IArrayInstance instance = this;
ISymbol symbol2 = null;
symbol = null;
int num = 0;
while (true)
{
if (num < jaggedIndices.Count)
{
flag &= instance.TryGetElement(jaggedIndices[num], out symbol2);
if (flag)
{
instance = symbol2 as IArrayInstance;
num++;
continue;
}
}
if (flag)
{
symbol = symbol2;
}
return(flag);
}
}
public void Apply(IArrayInstance instance)
{
instance.Access.Field();
}
internal static bool TryGetSubItem(IInstanceCollection <T> coll, string[] pathSplit, int splitIndex, out T symbol)
{
SymbolParser.ArrayIndexType type;
T local = default(T);
symbol = default(T);
string nameWithIndices = pathSplit[splitIndex];
string instanceName = null;
IList <int[]> jaggedIndices = null;
string indicesStr = null;
bool flag = SymbolParser.TryParseArrayElement(nameWithIndices, out instanceName, out indicesStr, out jaggedIndices, out type);
if (flag)
{
nameWithIndices = instanceName;
}
bool flag2 = nameWithIndices[nameWithIndices.Length - 1] == '^';
if (flag2)
{
nameWithIndices = nameWithIndices.Substring(0, nameWithIndices.Length - 1);
}
IList <T> list2 = null;
if (coll.TryGetInstanceByName(nameWithIndices, out list2))
{
local = list2[0];
if (flag)
{
ISymbol symbol2 = null;
IArrayInstance instance = local as IArrayInstance;
IReferenceInstanceAccess access = local as IReferenceInstanceAccess;
if (instance != null)
{
instance.TryGetElement(jaggedIndices, out symbol2);
}
else if (access != null)
{
access.TryGetElement(jaggedIndices, out symbol2);
}
local = (T)symbol2;
}
if ((local == null) || (splitIndex >= (pathSplit.Length - 1)))
{
symbol = !((splitIndex == (pathSplit.Length - 1)) & flag2) ? local : ((ISymbolInternal)local).SubSymbolsInternal[0];
}
else
{
ISymbol symbol3 = local as ISymbol;
if (symbol3.IsContainerType)
{
ISymbolCollection subSymbolsInternal = ((ISymbolInternal)symbol3).SubSymbolsInternal;
if (flag2)
{
subSymbolsInternal = ((ISymbolInternal)subSymbolsInternal[0]).SubSymbolsInternal;
}
if ((subSymbolsInternal != null) && (subSymbolsInternal.Count > 0))
{
T local2 = default(T);
splitIndex++;
if (InstanceCollection <T> .TryGetSubItem((IInstanceCollection <T>)subSymbolsInternal, pathSplit, splitIndex, out local2))
{
symbol = local2;
}
else
{
symbol = default(T);
}
}
}
}
}
return(((T)symbol) != null);
}
internal DynamicArrayInstance(IArrayInstance symbol) : base((IValueSymbol)symbol)
{
}
public static void AddSymbolRecursive(List <ISymbol> symbols, ISymbol symbol, bool debug = false)
{
try
{
if (symbol.DataType == null && symbol.Category != DataTypeCategory.Struct)
{
return;
}
if (symbol.DataType != null && symbol.DataType.Name.StartsWith("TC2_MC2."))
{
return;
}
if (symbol.TypeName != null && symbol.TypeName == "TC2_MC2.MC_Power")
{
Console.WriteLine();
}
foreach (ITypeAttribute attribute in symbol.Attributes)
{
if (debug)
{
Debug.WriteLine($"{attribute.Name} : {attribute.Value}");
}
}
if (debug)
{
Debug.WriteLine(
$"{symbol.InstancePath} : {symbol.TypeName} (IG: 0x{((IAdsSymbol)symbol).IndexGroup:x} IO: 0x{((IAdsSymbol)symbol).IndexOffset:x} size: {symbol.Size})");
}
switch (symbol.Category)
{
case DataTypeCategory.Array:
IArrayInstance arrInstance = (IArrayInstance)symbol;
//IArrayType arrType = (IArrayType)symbol.DataType;
if (arrInstance.Elements != null)
{
// int count = 0;
foreach (ISymbol arrayElement in arrInstance.Elements)
{
AddSymbolRecursive(symbols, arrayElement);
//count++;
//if (count > 20) // Write only the first 20 to limit output
// break;
}
}
else
{
Debug.WriteLine($"Array elements of {arrInstance.TypeName} are null");
}
break;
case DataTypeCategory.Struct:
IStructInstance structInstance = (IStructInstance)symbol;
//IStructType structType = (IStructType)symbol.DataType;
try
{
foreach (ISymbol member in structInstance.MemberInstances)
{
AddSymbolRecursive(symbols, member);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
break;
case DataTypeCategory.Reference:
// "REFERENCE TO ..." cannot be read, so filter it out. Comes from InOut variables in function blocks
// pass
if (symbol.IsPointer || symbol.DataType.Name.StartsWith("POINTER"))
{
break;
}
break;
default:
symbols.Add(symbol);
break;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw;
}
}