/// <summary>
/// Initializes a new instance of the <see cref="AttributeValue"/> class.
/// </summary>
/// <param name="theDefinition">The definition.</param>
/// <param name="theValue">The value.</param>
/// <param name="theParentStruct">The parent struct.</param>
public AttributeValue(AttributeDefinition theDefinition, Value theValue, StructureValue theParentStruct)
{
Definition = theDefinition;
Name = theDefinition.Name;
Value = theValue;
ParentStruct = theParentStruct;
}
private string[] HandleLtFrame(StructureValue map27FrameStruct, double timestamp, string direction)
{
List<string> analysisReports = null;
AttributeValue nsAttribute = (AttributeValue)map27FrameStruct.Attributes[1];
ulong rxFrameNs = nsAttribute.Value.GetUlongValue();
if (rxFrameNs == Nr)
{
Nr = Nr.PlusOneMod256();
}
else
{
if (rxFrameNs == Nr.LessOneMod256())
{
// Retransmission of previous frames
analysisReports = AddStringToList(analysisReports, string.Format("{0} Retransmission N(S) = {1} ({2:F4}s)", direction, rxFrameNs, (timestamp - m_PreviousLtFrameTimestamp)));
}
else
{
// Out of sequence frame
analysisReports = AddStringToList(analysisReports, string.Format("{0} Out of sequence frame: Current N(R) = {1}, received N(S) = {2}", direction, Nr, rxFrameNs));
}
}
m_PreviousLtFrameTimestamp = timestamp;
return analysisReports == null ? null : analysisReports.ToArray();
}
internal string[] HandleFrame(StructureValue map27SignalStruct, double timestamp, string direction)
{
AttributeValue map27FrameAttribute = (AttributeValue)map27SignalStruct.Attributes[0];
StructureValue map27FrameStruct = (StructureValue)map27FrameAttribute.Value;
string[] analysisReports = null;
switch (map27FrameAttribute.Name)
{
case "LR":
Map27LinkState = Map27LinkState.LinkWait;
Nr = 1;
Ns = 0;
break;
case "LA":
Map27LinkState = Map27LinkState.Ready;
break;
case "LT":
analysisReports = HandleLtFrame(map27FrameStruct, timestamp, direction);
break;
}
return analysisReports;
}
/// <summary>
/// Determines whether the specified value is the end marker
/// </summary>
/// <param name="theStructValue">The struct value.</param>
/// <returns>
/// <c>true</c> if the specified value is the end marker; otherwise, <c>false</c>.
/// </returns>
private static bool IsEndMarker(StructureValue theStructValue)
{
if (!theStructValue.IsTlvStructure)
{
return false;
}
// End marker for a sequence of TLV items signalled by length and type attributes being zero
bool isEndMarker = true;
AttributeValue typeAttribute = theStructValue.Attributes[theStructValue.GetTlvTypeAttributeName()];
if (typeAttribute.Value.FundamentalType.TypeId == TypeId.EnumType)
{
EnumValue enumValue = typeAttribute.Value as EnumValue;
if (enumValue.IntegerValue != 0)
{
isEndMarker = false;
}
}
AttributeValue lengthAttribute = theStructValue.Attributes[theStructValue.GetTlvLengthAttributeName()];
if (lengthAttribute.Value.FundamentalType.TypeId == TypeId.BaseType)
{
BaseTypeValue baseValue = lengthAttribute.Value as BaseTypeValue;
int length = baseValue.IsSigned ? (int)baseValue.SignedValue : (int)baseValue.UnsignedValue;
if (length != 0)
{
isEndMarker = false;
}
}
return isEndMarker;
}
/// <summary>
/// Gets the discriminator value.
/// </summary>
/// <param name="theParentStruct">The parent struct.</param>
/// <returns>Discriminator value</returns>
public int GetDiscriminatorValue(StructureValue theParentStruct)
{
Value discriminatorValue = theParentStruct.Attributes[Discriminator.Name].Value;
int discriminatorValueAsInteger = 0;
if (discriminatorValue.FundamentalType.TypeId == TypeId.EnumType)
{
EnumValue discriminatorValueAsEnum = discriminatorValue as EnumValue;
discriminatorValueAsInteger = discriminatorValueAsEnum.IntegerValue;
}
else if (discriminatorValue.FundamentalType.TypeId == TypeId.BaseType)
{
BaseTypeValue discriminatorValueAsBaseType = discriminatorValue as BaseTypeValue;
discriminatorValueAsInteger = discriminatorValueAsBaseType.IsSigned ?
(int)discriminatorValueAsBaseType.SignedValue : (int)discriminatorValueAsBaseType.UnsignedValue;
}
else
{
throw new DataDictionaryException("SwitchDefinition {0}: DiscriminatorValue {1} is neither enum nor base type",
Name, discriminatorValue.FundamentalType.Name);
}
return discriminatorValueAsInteger;
}
/// <summary>
/// Gets the switch case definition corresponding to the value of the discriminator in the parent structure
/// or null if there's no match
/// </summary>
/// <param name="theParentStruct">The parent structure</param>
/// <returns>The switch case definition corresponding to the value of the discriminator in the parent structure</returns>
public SwitchCaseDefinition GetSwitchCaseDefinition(StructureValue theParentStruct)
{
SwitchCaseDefinition theCaseDefinition = null;
int discriminatorValue = GetDiscriminatorValue(theParentStruct);
bool valueFound = Cases.TryGetValue(discriminatorValue, out theCaseDefinition);
if (!valueFound)
{
throw new DataDictionaryException("Parent {2} Case {0}: value {1} not found",
this.Name, discriminatorValue, theParentStruct.FundamentalType.Name);
}
return theCaseDefinition;
}
private static void ShowStructOnSingleLine(StringBuilder sb, StructureValue theStruct)
{
foreach (var attribute in theStruct.Attributes)
{
StructureValue theStructureValue = attribute.Value as StructureValue;
EnumValue theEnumValue = null;
if (theStructureValue != null)
{
sb.Append("{");
ShowStructOnSingleLine(sb, theStructureValue);
sb.Append("} ");
}
else if ((theEnumValue = attribute.Value as EnumValue) != null)
{
sb.AppendFormat("{0}:{1} ", attribute.Name, theEnumValue.StringValue, theEnumValue.IntegerValue);
}
else
{
sb.AppendFormat("{0}:{1} ", attribute.Name, attribute.Value);
}
}
}
private void ShowStructOnMultipleLines(StringBuilder sb, StructureValue theStruct, int indentCount)
{
string indentString = string.Format("\n{0}", new string(' ', indentCount));
foreach (var attribute in theStruct.Attributes)
{
StructureValue theStructureValue = attribute.Value as StructureValue;
EnumValue theEnumValue = null;
if (theStructureValue != null)
{
//sb.AppendFormat("{0}{{", indentString);
ShowStructOnMultipleLines(sb, theStructureValue, indentCount + 2);
//sb.AppendFormat("{0}}} ", indentString);
}
else if ((theEnumValue = attribute.Value as EnumValue) != null)
{
sb.AppendFormat("{0}{1}:{2} ({3}) ", indentString, attribute.Name, theEnumValue.StringValue, theEnumValue.IntegerValue);
}
else
{
sb.AppendFormat("{0}{1}:{2} ", indentString, attribute.Name, attribute.Value);
}
}
}
private void ShowTapFrameOnMultipleLines(StringBuilder sb, StructureValue tapFrameStruct, int indentCount)
{
string indentString = string.Format("\n{0}", new string(' ', indentCount));
sb.AppendFormat("{0}{1} Block:{2} Count:{3} Command:{4}",
indentString,
"TAP", // GetIntegerValue(tapFrameStruct.Attributes["Type"].Value),
GetIntegerValue(tapFrameStruct.Attributes["Block"].Value),
GetIntegerValue(tapFrameStruct.Attributes["Count"].Value),
GetEnumValue(tapFrameStruct.Attributes["Command"].Value));
if (tapFrameStruct.Attributes.Count == 5 && tapFrameStruct.Attributes[4].Value is StructureValue)
{
//sb.AppendFormat("{0}{{", indentString);
ShowStructOnMultipleLines(sb, (StructureValue)tapFrameStruct.Attributes[4].Value, indentCount + 2);
//sb.AppendFormat("{0}}} ", indentString);
}
}
/// <summary>
/// Encodes the type of the struct.
/// </summary>
/// <param name="structureValue">The structure value.</param>
/// <param name="signalText">The signal text.</param>
/// <param name="prefix">The prefix.</param>
/// <param name="valueName">Name of the value.</param>
private void EncodeStructType(StructureValue structureValue, StringBuilder signalText, string prefix, string valueName)
{
signalText.AppendFormat("{0}{1} {2}:\n", prefix, structureValue.InitialType.Name, valueName);
foreach (var attribute in structureValue.Attributes)
{
EncodeSignalElement(attribute.Value, signalText, prefix, attribute.Name);
}
}
