private static string format_euroloop_message(DBMessage message)
{
EfsSystem system = EfsSystem.Instance;
NameSpace nameSpace = findNameSpace("Messages.EUROLOOP");
Structure structureType = (Structure)system.FindType(nameSpace, "Message");
StructureValue structure = new StructureValue(structureType);
int currentIndex = 0;
FillStructure(nameSpace, message.Fields, ref currentIndex, structure);
// then we fill the packets
IVariable subSequenceVariable;
if (structure.SubVariables.TryGetValue("Sequence1", out subSequenceVariable))
{
subSequenceVariable.Value = get_message_packets(message, nameSpace, system);
}
else
{
throw new Exception("Cannot find SubSequence in variable");
}
return(structure.Name);
}
/// <summary>
/// Finds the type of the structure corresponding to the provided NID_PACKET
/// </summary>
/// <param name="nameSpace">The namespace where the type has to be found</param>
/// <param name="nidPacket">The id of the packet</param>
/// <returns></returns>
private static StructureValue FindStructure(int nidPacket)
{
EfsSystem system = EfsSystem.Instance;
Structure structure = null;
NameSpace nameSpace = findNameSpace("Messages.PACKET.TRACK_TO_TRAIN");
foreach (NameSpace packetNameSpace in nameSpace.NameSpaces)
{
Structure structureType =
(Structure)system.FindType(packetNameSpace, packetNameSpace.FullName + ".Message");
StructureValue structureValue = new StructureValue(structureType);
foreach (KeyValuePair <string, IVariable> pair in structureValue.SubVariables)
{
string variableName = pair.Key;
if (variableName.Equals("NID_PACKET"))
{
IntValue value = pair.Value.Value as IntValue;
if (value.Val == nidPacket)
{
structure = structureType;
}
}
if (structure != null)
{
break;
}
}
if (structure != null)
{
break;
}
}
StructureValue retVal = null;
if (structure != null)
{
retVal = new StructureValue(structure);
}
return(retVal);
}
private static ListValue get_message_packets(DBMessage message, NameSpace nameSpace, EfsSystem system)
{
ListValue retVal;
Collection collectionType = (Collection) system.FindType(nameSpace, "Collection1");
Structure subStructure1Type = (Structure) system.FindType(nameSpace, "SubStructure1");
string packetLocation = "Messages.PACKET.";
if (nameSpace.FullName.Contains("TRAIN_TO_TRACK"))
{
packetLocation += "TRAIN_TO_TRACK.Message";
}
else
{
packetLocation += "TRACK_TO_TRAIN.Message";
}
Structure packetStructureType = (Structure) system.FindType(nameSpace, packetLocation);
retVal = new ListValue(collectionType, new List<IValue>());
foreach (DBPacket packet in message.Packets)
{
DBField nidPacketField = packet.Fields[0] as DBField;
if (nidPacketField.Value != "255") // 255 means "end of information"
{
int packetId = int.Parse(nidPacketField.Value);
StructureValue subStructure = FindStructure(packetId);
int currentIndex = 0;
FillStructure(nameSpace, packet.Fields, ref currentIndex, subStructure);
StructureValue subStructure1 = new StructureValue(subStructure1Type);
// For Balise messages, we have an extra level of information to fill, so here we define StructureVal in one of two ways
StructureValue structureVal;
if (subStructure1.SubVariables.Count == 1 &&
subStructure1.SubVariables.ContainsKey("TRACK_TO_TRAIN"))
{
// For a Balise message, we have an extra level of structures for TRACK_TO_TRAIN
structureVal = new StructureValue(packetStructureType);
subStructure1.SubVariables["TRACK_TO_TRAIN"].Value = structureVal;
}
else
{
// For RBC, the collection directly holds the different packet types
structureVal = subStructure1;
}
// Find the right variable in the packet to add the structure we just created
foreach (KeyValuePair<string, IVariable> pair in structureVal.SubVariables)
{
string variableName = pair.Key;
string[] ids = subStructure.Structure.FullName.Split('.');
if (ids[ids.Length-2].Equals(variableName))
{
pair.Value.Value = subStructure;
retVal.Val.Add(subStructure1);
break;
}
}
}
}
return retVal;
}
private static string format_euroradio_message(DBMessage message)
{
EfsSystem system = EfsSystem.Instance;
NameSpace rbcRoot = findNameSpace("Messages.MESSAGE");
// Get the EFS namespace corresponding to the message
// Select the appropriate message type, tracktotrain or traintotrack
DBField nidMessage = message.Fields[0] as DBField;
string msg_id = get_namespace_from_ID(nidMessage.Value);
NameSpace nameSpace = OverallNameSpaceFinder.INSTANCE.findByName(rbcRoot, msg_id);
if (nameSpace == null)
{
throw new Exception("Message type not found in EFS");
}
// The EURORADIO messages are defined in the namespaces TRACK_TO_TRAIN and TRAIN_TO_TRACK, which enclose the specific message namespaces
// So we get the message type from nameSpace.EnclosingNameSpace and the actual structure corresponding to the message in nameSpace
Structure enclosingStructureType = (Structure)system.FindType(nameSpace.EnclosingNameSpace, "Message");
StructureValue Message = new StructureValue(enclosingStructureType);
// Within the message, get the appropriate field and get that structure
Structure structureType = (Structure)system.FindType(nameSpace, "Message");
StructureValue structure = new StructureValue(structureType);
// Fill the structure
int currentIndex = 0;
FillStructure(nameSpace, message.Fields, ref currentIndex, structure);
// Fill the default packets
int translatedPackets = 0;
foreach (KeyValuePair <string, IVariable> subVariable in structure.SubVariables)
{
if (subVariable.Value.TypeName.EndsWith("Message"))
{
// The structure of packets will always be a Message, but in some cases, it is a message that contains
// the different options for a single field in the message
structure.GetVariable(subVariable.Value.Name).Value = FillDefaultPacket(message, subVariable.Value);
translatedPackets++;
}
}
// and fill the packets
IVariable subSequenceVariable;
if (structure.SubVariables.TryGetValue("Sequence1", out subSequenceVariable) &&
message.Packets.Count > translatedPackets)
{
subSequenceVariable.Value = get_message_packets(message, nameSpace, system);
}
// Fill the correct field in Message with the structure.
foreach (KeyValuePair <string, IVariable> pair in Message.SubVariables)
{
if (msg_id.EndsWith(pair.Key))
{
pair.Value.Type = structureType;
pair.Value.Value = structure;
}
}
return(Message.Name);
}
/// <summary>
/// Fills the given structure with the values provided from the database
/// </summary>
/// <param name="aNameSpace">Namespace of the structure</param>
/// <param name="fields">Fields to be copied into the structure</param>
/// <param name="index">Index (of fields list) from which we have to start copying</param>
/// <param name="aStructure">The structure to be filled</param>
private static void FillStructure(NameSpace aNameSpace, ArrayList fields, ref int currentIndex,
StructureValue aStructure)
{
EfsSystem system = EfsSystem.Instance;
int j = 0;
while (currentIndex < fields.Count)
{
DBField field = fields[currentIndex] as DBField;
KeyValuePair <string, IVariable> pair = aStructure.SubVariables.ElementAt(j);
IVariable variable = pair.Value;
// conditional variables can be missing in the database fields, but present in our structure => skip them
while (!variable.Name.StartsWith(field.Variable) && j < aStructure.SubVariables.Count - 1)
{
j++;
pair = aStructure.SubVariables.ElementAt(j);
variable = pair.Value;
}
// We use StartsWith and not Equals because we can have N_ITER_1 and N_ITER
if (variable.Name.StartsWith(field.Variable))
{
if (variable.Type is Enum)
{
Enum type = variable.Type as Enum;
foreach (EnumValue enumValue in type.Values)
{
int value = int.Parse(enumValue.getValue());
int other = int.Parse(field.Value);
if (value == other)
{
variable.Value = enumValue;
j++;
break;
}
}
}
else if (variable.Type is Range)
{
Range type = variable.Type as Range;
object v = VariableConverter.INSTANCE.Convert(variable.Name, field.Value);
string stringValue = v as string;
if (stringValue != null)
{
int intValue;
if (int.TryParse(stringValue, out intValue))
{
v = intValue;
}
}
variable.Value = new IntValue(type, (int)v);
j++;
}
else if (variable.Type is StringType)
{
StringType type = variable.Type as StringType;
variable.Value = new StringValue(type, field.Value);
j++;
}
else
{
throw new Exception("Unhandled variable type");
}
if (variable.Name.StartsWith("N_ITER")) // we have to create a sequence
{
KeyValuePair <string, IVariable> sequencePair = aStructure.SubVariables.ElementAt(j);
IVariable sequenceVariable = sequencePair.Value;
Collection collectionType = (Collection)system.FindType(aNameSpace, sequenceVariable.TypeName);
ListValue sequence = new ListValue(collectionType, new List <IValue>());
int value = int.Parse(field.Value);
for (int k = 0; k < value; k++)
{
currentIndex++;
Structure structureType =
(Structure)system.FindType(aNameSpace, sequence.CollectionType.Type.FullName);
StructureValue structureValue = new StructureValue(structureType);
FillStructure(aNameSpace, fields, ref currentIndex, structureValue);
sequence.Val.Add(structureValue);
}
sequenceVariable.Value = sequence;
j++;
}
}
// Special case for X_TEXT
if ("Sequence1".Equals(variable.Name) && "X_TEXT".Equals(field.Variable))
{
KeyValuePair <string, IVariable> sequencePair = aStructure.SubVariables.ElementAt(j);
IVariable sequenceVariable = sequencePair.Value;
Collection collectionType = (Collection)system.FindType(aNameSpace, sequenceVariable.TypeName);
ListValue sequence = new ListValue(collectionType, new List <IValue>());
while (field != null && "X_TEXT".Equals(field.Variable))
{
if (string.IsNullOrEmpty(field.Value))
{
field.Value = " ";
}
Structure structureType =
(Structure)system.FindType(aNameSpace, sequence.CollectionType.Type.FullName);
StructureValue structureValue = new StructureValue(structureType);
FillStructure(aNameSpace, fields, ref currentIndex, structureValue);
sequence.Val.Add(structureValue);
currentIndex += 1;
if (currentIndex < fields.Count)
{
field = fields[currentIndex] as DBField;
}
else
{
field = null;
}
}
sequenceVariable.Value = sequence;
j++;
}
// if all the fields of the structue are filled, we terminated
if (j == aStructure.SubVariables.Count)
{
break;
}
else
{
currentIndex += 1;
}
}
}
private static ListValue get_message_packets(DBMessage message, NameSpace nameSpace, EfsSystem system)
{
ListValue retVal;
Collection collectionType = (Collection)system.FindType(nameSpace, "Collection1");
Structure subStructure1Type = (Structure)system.FindType(nameSpace, "SubStructure1");
string packetLocation = "Messages.PACKET.";
if (nameSpace.FullName.Contains("TRAIN_TO_TRACK"))
{
packetLocation += "TRAIN_TO_TRACK.Message";
}
else
{
packetLocation += "TRACK_TO_TRAIN.Message";
}
Structure packetStructureType = (Structure)system.FindType(nameSpace, packetLocation);
retVal = new ListValue(collectionType, new List <IValue>());
foreach (DBPacket packet in message.Packets)
{
DBField nidPacketField = packet.Fields[0] as DBField;
if (nidPacketField.Value != "255") // 255 means "end of information"
{
int packetId = int.Parse(nidPacketField.Value);
StructureValue subStructure = FindStructure(packetId);
int currentIndex = 0;
FillStructure(nameSpace, packet.Fields, ref currentIndex, subStructure);
StructureValue subStructure1 = new StructureValue(subStructure1Type);
// For Balise messages, we have an extra level of information to fill, so here we define StructureVal in one of two ways
StructureValue structureVal;
if (subStructure1.SubVariables.Count == 1 &&
subStructure1.SubVariables.ContainsKey("TRACK_TO_TRAIN"))
{
// For a Balise message, we have an extra level of structures for TRACK_TO_TRAIN
structureVal = new StructureValue(packetStructureType);
subStructure1.SubVariables["TRACK_TO_TRAIN"].Value = structureVal;
}
else
{
// For RBC, the collection directly holds the different packet types
structureVal = subStructure1;
}
// Find the right variable in the packet to add the structure we just created
foreach (KeyValuePair <string, IVariable> pair in structureVal.SubVariables)
{
string variableName = pair.Key;
if (subStructure.Structure.FullName.Contains(variableName))
{
pair.Value.Value = subStructure;
retVal.Val.Add(subStructure1);
break;
}
}
}
}
return(retVal);
}