public override void visit(NameSpace obj, bool visitSubNodes) { Types.NameSpace nameSpace = (Types.NameSpace)obj; if (nameSpace.allNameSpaceRefs() != null) { foreach (NameSpaceRef nameSpaceRef in nameSpace.allNameSpaceRefs()) { Types.NameSpace subNameSpace = nameSpaceRef.LoadNameSpace(LockFiles, AllowErrorsDuringLoad); if (subNameSpace != null) { nameSpace.appendNameSpaces(subNameSpace); subNameSpace.NameSpaceRef = nameSpaceRef; } else { ErrorsDuringLoad.Add(new ElementLog(ElementLog.LevelEnum.Error, "Cannot load file " + nameSpaceRef.FileName)); } } nameSpace.allNameSpaceRefs().Clear(); } base.visit(obj, visitSubNodes); }
/// <summary> /// Either provides the requested namespace or creates it if it cannot be found /// This method can create many levels of nested namespaces /// </summary> /// <param name="levels">The name of the namespace, with the levels separated into separate Strings</param> /// <param name="initialDictionary">The dictionary the namespace structure is being copied form</param> /// <returns></returns> public Types.NameSpace GetNameSpaceUpdate(String[] levels, Dictionary initialDictionary) { Types.NameSpace retVal = null; if (levels.Length > 0) { retVal = FindNameSpace(levels[0]); Types.NameSpace initialNameSpace = initialDictionary.FindNameSpace(levels[0]); if (retVal == null) { retVal = (Types.NameSpace)acceptor.getFactory().createNameSpace(); retVal.setName(levels[0]); appendNameSpaces(retVal); // set the updates link for the new namespace retVal.setUpdates(initialNameSpace.Guid); } for (int index = 1; index < levels.Length; index++) { initialNameSpace = initialNameSpace.findNameSpaceByName((levels[index])); retVal = retVal.FindOrCreateNameSpaceUpdate(levels[index], initialNameSpace); } } return(retVal); }
public void TestRefactorStructureName() { Dictionary test = CreateDictionary("Test"); NameSpace n1 = CreateNameSpace(test, "N1"); Collection collection = CreateCollection(n1, "Col", "Integer", 10); Variable v = CreateVariable(n1, "V", "Col"); v.setDefaultValue("[]"); RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1"); Action a1 = CreateAction(rc1, "INSERT 1 IN V"); RuleCondition rc2 = CreateRuleAndCondition(n1, "Rule2"); Action a2 = CreateAction(rc2, "INSERT 2 IN V"); // ReSharper disable once UseObjectOrCollectionInitializer Runner runner = new Runner(false); runner.CheckForCompatibleChanges = true; runner.Cycle(); ListValue listValue = v.Value as ListValue; Assert.IsNotNull(listValue); Assert.AreEqual(2, listValue.Val.Count); Assert.AreEqual(0, a1.Messages.Count); Assert.AreEqual(0, a2.Messages.Count); }
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); }
public override void visit(NameSpace obj, bool visitSubNodes) { base.visit(obj, visitSubNodes); Types.NameSpace nameSpace = (Types.NameSpace)obj; if (_beforeSave) { nameSpace.ClearTempFiles(); nameSpace.allNameSpaceRefs().Clear(); if (nameSpace.allNameSpaces() != null) { foreach (Types.NameSpace subNameSpace in nameSpace.allNameSpaces()) { nameSpace.appendNameSpaceRefs(referenceNameSpace(nameSpace, subNameSpace)); } } nameSpace.StoreInfo(); } else { nameSpace.RestoreInfo(); } }
public void TestSubRulesPriority() { Dictionary test = CreateDictionary("Test"); NameSpace n1 = CreateNameSpace(test, "N1"); Variable v1 = CreateVariable(n1, "V", "Integer"); v1.setDefaultValue("0"); Variable v2 = CreateVariable(n1, "V2", "Integer"); v2.setDefaultValue("0"); // Priority is Processing RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1"); Action a1 = CreateAction(rc1, "V2 <- V2 + 1"); // Priority is Update out RuleCondition rc2 = CreateRuleAndCondition(rc1, "Rule2"); rc2.EnclosingRule.setPriority(acceptor.RulePriority.aUpdateOUT); Action a2 = CreateAction(rc2, "V <- V + 1"); // ReSharper disable once UseObjectOrCollectionInitializer Runner runner = new Runner(false); runner.Cycle(); IntValue value = v1.Value as IntValue; Assert.IsNotNull(value); Assert.AreEqual(1, value.Val); value = v2.Value as IntValue; Assert.IsNotNull(value); Assert.AreEqual(1, value.Val); }
public override NameSpace createNameSpace() { NameSpace retVal = new Types.NameSpace(); _defaultValueSetter.SetDefaultValue(retVal); return(retVal); }
/// <summary> /// Saves the namespace provided associated to this namespace ref /// </summary> /// <param name="nameSpace"></param> public void SaveNameSpace(NameSpace nameSpace) { Directory.CreateDirectory(Path.GetDirectoryName(FileName)); VersionedWriter writer = new VersionedWriter(FileName); nameSpace.unParse(writer, false); writer.Close(); }
/// <summary> /// Constructor /// </summary> /// <param name="model"></param> /// <param name="index"></param> public SelectionButton(NameSpace model, int index) { Model = model; Index = index; Image = NameSpaceImages.Instance.Images.Images[index-1]; Click += OnClick; Size = new Size(32, 32); }
GetStandardValues(ITypeDescriptorContext context) { ItemEditor editor = (ItemEditor)context.Instance; DataDictionary.Types.NameSpace nameSpace = editor.Item.NameSpace; DataDictionary.Types.Type type = editor.Item.Type; return(GetValues(nameSpace, type)); }
public void CreateNamespaceSection(FunctionalAnalysisReport report, NameSpace nameSpace, List<AccessMode> accesses) { Log.Info("..generating name space " + nameSpace.Name); report.CreateNameSpaceSection(nameSpace, accesses); foreach (NameSpace subNameSpace in nameSpace.NameSpaces) { CreateNamespaceSection(report, subNameSpace, accesses); } }
/// <summary> /// Refactors a single element /// </summary> /// <param name="element"></param> /// <param name="originalName">The original element's name</param> /// <param name="newName">The new element's name</param> private void RefactorElement(ModelElement element, string originalName, string newName) { if (element != null) { NameSpace nameSpace = element as NameSpace; if (nameSpace != null) { NameSpaceRefactorer refactorer = new NameSpaceRefactorer(nameSpace); foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries) { refactorer.visit(dictionary); } } else { // the system keeps track where the element is used List <Usage> usageList = EfsSystem.Instance.FindReferences(element); SortedSet <Usage> usages = new SortedSet <Usage>(usageList, new CompareUsages()); foreach (Usage usage in usages) { RefactorIExpressionable(element, usage.User as IExpressionable); RefactorTypedElement(element, usage.User as ITypedElement); } if (element is StructureElement) { Structure structure = element.Enclosing as Structure; if (structure != null && structure.IsAbstract) { usages = new SortedSet <Usage>(EfsSystem.Instance.FindReferences(structure)); foreach (Usage usage in usages) { if (usage.Mode == Usage.ModeEnum.Interface) { Structure redefiningStructure = usage.User as Structure; if (redefiningStructure != null) { ModelElement el = redefiningStructure.FindStructureElement(originalName); if (el != null) { el.Name = newName; RefactorElement(el, originalName, newName); } } } } } } } } }
/// <summary> /// Creates a copy of the collection in the designated dictionary. The namespace structure is copied over. /// The new collection is set to update this one. /// </summary> /// <param name="dictionary">The target dictionary of the copy</param> /// <returns></returns> public Collection CreateCollectionUpdate(Dictionary dictionary) { Collection retVal = (Collection)Duplicate(); retVal.setUpdates(Guid); retVal.ClearAllRequirements(); String[] names = FullName.Split('.'); names = names.Take(names.Count() - 1).ToArray(); NameSpace nameSpace = dictionary.GetNameSpaceUpdate(names, Dictionary); nameSpace.appendCollections(retVal); return(retVal); }
/// <summary> /// Loads a namespace and locks the file /// </summary> /// <param name="filePath"></param> /// <param name="enclosing"></param> /// <param name="lockFiles"></param> /// <param name="allowErrors"></param> /// <returns></returns> public static Types.NameSpace LoadNameSpace(string filePath, ModelElement enclosing, bool lockFiles, bool allowErrors) { Types.NameSpace retVal = LoadFile <Types.NameSpace>(filePath, enclosing, lockFiles); if (retVal == null) { if (!allowErrors) { throw new Exception("Cannot read file " + filePath); } } return(retVal); }
/// <summary> /// Creates a copy of the variable in the designated dictionary. The namespace structure is copied over. /// The new variable is set to update this one. /// </summary> /// <param name="dictionary">The target dictionary of the copy</param> /// <returns></returns> public Variable CreateVariableUpdate(Dictionary dictionary) { Variable retVal = (Variable)Duplicate(); retVal.setUpdates(Guid); retVal.ClearAllRequirements(); String[] names = FullName.Split('.'); names = names.Take(names.Count() - 1).ToArray(); NameSpace nameSpace = dictionary.GetNameSpaceUpdate(names, Dictionary); nameSpace.appendVariables(retVal); return(retVal); }
/// <summary> /// Either provides the requested state machine or creates it if it cannot be found /// </summary> /// <param name="name">The name pf the state machine</param> /// <param name="initialNameSpace">The namespace the state machine is being copied from</param> /// <returns></returns> public StateMachine GetStateMachineUpdate(string name, NameSpace initialNameSpace) { StateMachine retVal = null; if (name != null) { retVal = findStateMachineByName(name); StateMachine initialStateMachine = initialNameSpace.findStateMachineByName(name); if (retVal == null) { retVal = initialStateMachine.CreateStateMachineUpdate(Dictionary); } } return(retVal); }
private NameSpaceRef referenceNameSpace(ModelElement enclosing, Types.NameSpace nameSpace) { NameSpaceRef retVal = nameSpace.NameSpaceRef; if (retVal == null) { retVal = (NameSpaceRef)acceptor.getFactory().createNameSpaceRef(); } retVal.Name = nameSpace.Name; retVal.setFather(enclosing); retVal.SaveNameSpace(nameSpace); return(retVal); }
/// <summary> /// Finds or creates a new namespace, and indicates that the original namespace is updated /// </summary> /// <param name="name">The name of the namespace to find or create</param> /// <param name="initialNameSpace">The namespace that is updated</param> /// <returns></returns> public NameSpace FindOrCreateNameSpaceUpdate(string name, NameSpace initialNameSpace) { NameSpace retVal = findNameSpaceByName(name); if (retVal == null) { retVal = (NameSpace)acceptor.getFactory().createNameSpace(); retVal.setName(name); appendNameSpaces(retVal); // set the updates link for the new namespace retVal.setUpdates(initialNameSpace.Guid); } return(retVal); }
/// <summary> /// Creates a copy of the structure in the designated dictionary. The namespace structure is copied over. /// The new structure is set to update this one. /// </summary> /// <param name="dictionary">The target dictionary of the copy</param> /// <returns></returns> public Structure CreateStructureUpdate(Dictionary dictionary) { Structure retVal = (Structure)acceptor.getFactory().createStructure(); retVal.Name = Name; retVal.Comment = Comment; retVal.IsAbstract = IsAbstract; retVal.SetUpdateInformation(this); String[] names = FullName.Split('.'); names = names.Take(names.Count() - 1).ToArray(); NameSpace nameSpace = dictionary.GetNameSpaceUpdate(names, Dictionary); nameSpace.appendStructures(retVal); return(retVal); }
private static NameSpace findNameSpace(string name) { NameSpace retVal = null; EfsSystem system = EfsSystem.Instance; foreach (Dictionary dictionary in system.Dictionaries) { retVal = OverallNameSpaceFinder.INSTANCE.findByName(dictionary, name); if (retVal != null) { break; } } return(retVal); }
/// <summary> /// Adds a model element in this model element /// </summary> /// <param name="element"></param> public override void AddModelElement(IModelElement element) { { Types.NameSpace item = element as Types.NameSpace; if (item != null) { appendNameSpaces(item); } } { Frame item = element as Frame; if (item != null) { appendTests(item); } } }
/// <summary> /// Creates a copy of the enum in the designated dictionary. The namespace structure is copied over. /// The new enum is set to update this one. /// </summary> /// <param name="dictionary">The target dictionary of the copy</param> /// <returns></returns> public Enum CreateEnumUpdate(Dictionary dictionary) { Enum retVal = (Enum)GetTopLevelEnum().Duplicate(); retVal.SetUpdateInformation(GetTopLevelEnum()); retVal.ClearAllRequirements(); String[] names = GetTopLevelEnum().FullName.Split('.'); names = names.Take(names.Count() - 1).ToArray(); NameSpace nameSpace = dictionary.GetNameSpaceUpdate(names, Dictionary); if (nameSpace != null) { nameSpace.appendEnumerations(retVal); } return(retVal); }
public override void visit(Generated.Dictionary obj, bool visitSubNodes) { Dictionary dictionary = (Dictionary)obj; if (dictionary.allNameSpaceRefs() != null) { foreach (NameSpaceRef nameSpaceRef in dictionary.allNameSpaceRefs()) { Types.NameSpace nameSpace = nameSpaceRef.LoadNameSpace(LockFiles, AllowErrorsDuringLoad); if (nameSpace != null) { dictionary.appendNameSpaces(nameSpace); nameSpace.NameSpaceRef = nameSpaceRef; } else { ErrorsDuringLoad.Add(new ElementLog(ElementLog.LevelEnum.Error, "Cannot load file " + nameSpaceRef.FileName)); } } dictionary.allNameSpaceRefs().Clear(); } if (dictionary.allTestRefs() != null) { foreach (FrameRef testRef in dictionary.allTestRefs()) { Frame frame = testRef.LoadFrame(LockFiles, AllowErrorsDuringLoad); if (frame != null) { dictionary.appendTests(frame); frame.FrameRef = testRef; } else { ErrorsDuringLoad.Add(new ElementLog(ElementLog.LevelEnum.Error, "Cannot load file " + testRef.FileName)); } } dictionary.allTestRefs().Clear(); } base.visit(obj, visitSubNodes); }
/// <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); }
/// <summary> /// Creates a copy of the structure element in the designated dictionary. The namespace structure is copied over. /// The new structure element is set to update this one. /// </summary> /// <param name="dictionary">The target dictionary of the copy</param> /// <returns></returns> public StructureElement CreateStructureElementUpdate(Dictionary dictionary) { StructureElement retVal = new StructureElement(); retVal.Name = Name; retVal.TypeName = TypeName; retVal.Comment = Comment; retVal.setUpdates(Guid); String[] names = FullName.Split('.'); names = names.Take(names.Count() - 1).ToArray(); String[] nameSpaceRef = names.Take(names.Count() - 1).ToArray(); NameSpace nameSpace = dictionary.GetNameSpaceUpdate(nameSpaceRef, Dictionary); Structure structure = nameSpace.GetStructureUpdate(names.Last(), (NameSpace)nameSpace.Updates); structure.appendElements(retVal); return(retVal); }
/// <summary> /// Provides the type which corresponds to the given name /// </summary> /// <param name="name">the type name to find</param> /// <param name="findInEnclosingNameSpaces">indicates that the search must be performed in the enclosing namespaces</param> /// <returns></returns> private Type innerFindTypeByName(string name, bool findInEnclosingNameSpaces) { Type retVal = null; string[] names = name.Split('.'); if (names.Length == 1) { retVal = (Type)NamableUtils.FindByName(name, Types); } else { NameSpace nameSpace = (NameSpace)NamableUtils.FindByName(names[0], NameSpaces); if (nameSpace != null) { retVal = nameSpace.innerFindTypeByName(name.Substring(nameSpace.Name.Length + 1), false); } } if (retVal == null && findInEnclosingNameSpaces && EnclosingNameSpace != null) { retVal = EnclosingNameSpace.innerFindTypeByName(name, true); } //HacK: get the unified structure to take care of Updates Structure structure = retVal as Structure; if (structure != null) { retVal = structure.UnifiedStructure; } //HacK: get the unified state machine to take care of Updates StateMachine stateMachine = retVal as StateMachine; if (stateMachine != null) { retVal = stateMachine.UnifiedStateMachine; } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="model"></param> public ImagesSelector(NameSpace model) { InitializeComponent(); Model = model; Point location = new Point(0,0); for (int imageIndex = 1; imageIndex<=NameSpaceImages.Instance.Images.Images.Count; imageIndex++) { Button button= new SelectionButton(model, imageIndex); button.Location = location; panel.Controls.Add(button); if (imageIndex % 6 == 0) { location = new Point(0, location.Y + 32); } else { location = new Point(location.X + 32, location.Y); } } }
/// <summary> /// Provides the type associated to the name /// </summary> /// <param name="nameSpace"></param> /// <param name="name"></param> /// <returns></returns> public Types.Type findType(Types.NameSpace nameSpace, string name) { Types.Type retVal = null; if (name != null) { foreach (Dictionary dictionary in Dictionaries) { retVal = dictionary.findType(nameSpace, name); if (retVal != null) { break; } } if (retVal == null) { PredefinedTypes.TryGetValue(name, out retVal); } } return(retVal); }
/// <summary> /// Adds a model element in this model element /// </summary> /// <param name="copy"></param> public override void AddModelElement(Utils.IModelElement element) { { Types.NameSpace item = element as Types.NameSpace; if (item != null) { appendNameSpaces(item); } } { Rules.RuleDisabling item = element as Rules.RuleDisabling; if (item != null) { appendRuleDisablings(item); } } { Tests.Frame item = element as Tests.Frame; if (item != null) { appendTests(item); } } }
/// <summary> /// Provides the type associated to the name, if it exists. /// If it does not exist, does not raise any errors. /// </summary> /// <param name="nameSpace"></param> /// <param name="name"></param> /// <returns></returns> public Type FindType_silent(NameSpace nameSpace, string name) { Type retVal = null; ModelElement.DontRaiseError(() => { retVal = FindType(nameSpace, name); }); return retVal; }
/// <summary> /// Constructor /// </summary> /// <param name="nameSpace"></param> public NameSpaceRefactorer(NameSpace nameSpace) { NameSpace = nameSpace; }
/// <summary> /// Constructor /// </summary> /// <param name="panel"></param> /// <param name="model"></param> public NameSpaceModelControl(ModelDiagramPanel panel, NameSpace model) : base(panel, model) { NormalColor = Color.LightGreen; BoxMode = BoxModeEnum.RoundedCorners; }
/// <summary> /// Indicates whether a call should be considered in the ProcedureOrFunctionCalls /// </summary> /// <param name="variableReference"></param> /// <param name="container"></param> /// <param name="sourceNameSpace"></param> /// <param name="targetNameSpace"></param> /// <returns></returns> private static bool considerVariableReference(Usage variableReference, IEnclosesNameSpaces container, NameSpace sourceNameSpace, NameSpace targetNameSpace) { bool retVal = considerCommon(container, sourceNameSpace, targetNameSpace); // Only consider variables retVal = retVal && variableReference.Referenced is IVariable; // Only consider variable accesses when the mode is known retVal = retVal && variableReference.Mode != null; return retVal; }
/// <summary> /// Indicates whether a call should be considered in the ProcedureOrFunctionCalls /// </summary> /// <param name="functionCall"></param> /// <param name="container"></param> /// <param name="sourceNameSpace"></param> /// <param name="targetNameSpace"></param> /// <returns></returns> private static bool considerCall(Usage functionCall, IEnclosesNameSpaces container, NameSpace sourceNameSpace, NameSpace targetNameSpace) { bool retVal = considerCommon(container, sourceNameSpace, targetNameSpace); // Only consider callables retVal = retVal && functionCall.Referenced is ICallable; // Ignore casting retVal = retVal && !(functionCall.Referenced is Range); return retVal; }
private NameSpaceRef referenceNameSpace(ModelElement enclosing, NameSpace nameSpace) { NameSpaceRef retVal = (NameSpaceRef)Generated.acceptor.getFactory().createNameSpaceRef(); retVal.Name = nameSpace.Name; retVal.setFather(enclosing); retVal.SaveNameSpace(nameSpace); 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); }
public void CreateNamespaceSection(ModelReport report, NameSpace aNameSpace) { bool informationAdded = false; if (!aNameSpace.FullName.StartsWith("Messages")) { if (AddRanges) { if (report.CountDisplayedReqRelated(aNameSpace.Ranges) > 0) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); report.CreateRangesSection(aNameSpace.Ranges, AddRangesDetails); informationAdded = true; } } if (AddEnumerations) { if (report.CountDisplayedReqRelated(aNameSpace.Enumerations) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateEnumerationsSection(aNameSpace.Enumerations, AddEnumerationsDetails); } } if (AddStructures) { if (report.CountDisplayedReqRelated(aNameSpace.Structures) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateStructuresSection(aNameSpace.Structures, AddStructuresDetails); } } if (AddCollections) { if (report.CountDisplayedReqRelated(aNameSpace.Collections) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateCollectionsSection(aNameSpace.Collections, AddCollectionsDetails); } } if (AddStateMachines) { if (report.CountDisplayedReqRelated(aNameSpace.StateMachines) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateStateMachinesSection(aNameSpace.StateMachines, AddStateMachinesDetails); } } if (AddFunctions) { if (report.CountDisplayedReqRelated(aNameSpace.Functions) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateFunctionsSection(aNameSpace.Functions, AddFunctionsDetails); } } if (AddProcedures) { if (report.CountDisplayedReqRelated(aNameSpace.Procedures) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateProceduresSection(aNameSpace.Procedures, AddProceduresDetails, false); } } if (AddVariables) { if (report.CountDisplayedVariables(aNameSpace.Variables, InOutOnly) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateVariablesSection(aNameSpace.Variables, AddVariablesDetails, InOutOnly); } } if (AddRules) { if (report.CountDisplayedReqRelated(aNameSpace.Rules) > 0) { if (!informationAdded) { report.AddSubParagraph("Namespace " + aNameSpace.FullName); informationAdded = true; } report.CreateRulesSection(aNameSpace.Rules, AddRulesDetails, false); } } if (informationAdded) { report.CloseSubParagraph(); } foreach (NameSpace nameSpace in aNameSpace.NameSpaces) { CreateNamespaceSection(report, nameSpace); } } }
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); }
/// <summary> /// Creates a copy of the namespace in the designated dictionary. The enclosing namespace structure is copied over. /// The new namespace is set to update this one. /// </summary> /// <param name="dictionary">The target dictionary of the copy</param> /// <returns></returns> public NameSpace CreateUpdateInDictionary(Dictionary dictionary) { NameSpace retVal = dictionary.GetNameSpaceUpdate(FullName.Split('.'), Dictionary); return(retVal); }
/// <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; } if (variable.Name.StartsWith(field.Variable)) // we use StartsWith and not Equals because we can have N_ITER_1 and N_ITER { 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); 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++; } } // if all the fields of the structue are filled, we terminated if (j == aStructure.SubVariables.Count) { break; } else { currentIndex += 1; } } }
private static IValue FillDefaultPacket(DBMessage message, IVariable structure) { IValue retVal = structure.Value; if (isPacket(structure)) { Structure defaultPacketType = (Structure)structure.Type; StructureValue defaultPacket = new StructureValue(defaultPacketType); NameSpace packetNameSpace = structure.NameSpace; foreach (DBPacket packet in message.Packets) { DBField nidPacketField = packet.Fields[0] as DBField; int packetID = int.Parse(nidPacketField.Value); Structure packetType = (Structure)FindStructure(packetID).Type; if (packetType == defaultPacketType) { int defaultPacketIndex = 0; FillStructure(packetNameSpace, packet.Fields, ref defaultPacketIndex, defaultPacket); retVal = defaultPacket; } } } else { Structure structureType = structure.Type as Structure; StructureValue Structure = new StructureValue(structureType); if (Structure != null) { foreach (KeyValuePair <string, IVariable> subVariable in Structure.SubVariables) { if (isPacket(subVariable.Value)) { Structure defaultPacketType = (Structure)subVariable.Value.Type; StructureValue defaultPacket = new StructureValue(defaultPacketType); NameSpace packetNameSpace = subVariable.Value.NameSpace; foreach (DBPacket packet in message.Packets) { DBField nidPacketField = packet.Fields[0] as DBField; int packetID = int.Parse(nidPacketField.Value); Structure packetType = (Structure)FindStructure(packetID).Type; if (packetType == defaultPacketType) { int defaultPacketIndex = 0; FillStructure(packetNameSpace, packet.Fields, ref defaultPacketIndex, defaultPacket); Structure.GetVariable(subVariable.Value.Name).Value = defaultPacket; } } } } retVal = Structure; } } return(retVal); }
/// <summary> /// Creates a section for a namespace /// </summary> /// <param name="nameSpace">The namespace to consider</param> /// <param name="accesses">The accesses performed in the system</param> /// <returns></returns> public void CreateNameSpaceSection(NameSpace nameSpace, List<AccessMode> accesses) { AddSubParagraph("Namespace " + nameSpace.FullName); Dictionary<Procedure, List<ProcedureOrFunctionCall>> procedureCalls = new Dictionary<Procedure, List<ProcedureOrFunctionCall>>(); Dictionary<Function, List<ProcedureOrFunctionCall>> functionCalls = new Dictionary<Function, List<ProcedureOrFunctionCall>>(); Dictionary<IVariable, List<AccessToVariable>> accessesToVariables = new Dictionary<IVariable, List<AccessToVariable>>(); foreach (AccessMode access in accesses) { ProcedureOrFunctionCall call = access as ProcedureOrFunctionCall; if (call != null) { if (call.Target == nameSpace) { { Function function = call.ReferencedModel as Function; if (function != null) { List<ProcedureOrFunctionCall> calls; if (!functionCalls.TryGetValue(function, out calls)) { calls = new List<ProcedureOrFunctionCall>(); functionCalls.Add(function, calls); } calls.Add(call); } } { Procedure procedure = call.ReferencedModel as Procedure; if (procedure != null) { List<ProcedureOrFunctionCall> calls; if (!procedureCalls.TryGetValue(procedure, out calls)) { calls = new List<ProcedureOrFunctionCall>(); procedureCalls.Add(procedure, calls); } calls.Add(call); } } } } AccessToVariable accessToVariable = access as AccessToVariable; if (accessToVariable != null) { if (accessToVariable.Target == nameSpace) { List<AccessToVariable> variableAccesses; if (!accessesToVariables.TryGetValue(accessToVariable.Variable, out variableAccesses)) { variableAccesses = new List<AccessToVariable>(); accessesToVariables.Add(accessToVariable.Variable, variableAccesses); } variableAccesses.Add(accessToVariable); } } } if (procedureCalls.Keys.Count > 0) { AddSubParagraph("Exposed procedures"); foreach (KeyValuePair<Procedure, List<ProcedureOrFunctionCall>> pair in procedureCalls) { Procedure procedure = pair.Key; AddSubParagraph("Procedure " + procedure.Name); CreateProcedureOrFunctionHeader(procedure); CreateProcedureOrFunctionUsage(pair.Value); CloseSubParagraph(); } CloseSubParagraph(); } if (functionCalls.Keys.Count > 0) { AddSubParagraph("Exposed functions"); foreach (KeyValuePair<Function, List<ProcedureOrFunctionCall>> pair in functionCalls) { Function function = pair.Key; AddSubParagraph("Function " + function.Name); CreateProcedureOrFunctionHeader(function); CreateProcedureOrFunctionUsage(pair.Value); CloseSubParagraph(); } CloseSubParagraph(); } if (accessesToVariables.Count > 0) { AddSubParagraph("Exposed variables"); foreach (KeyValuePair<IVariable, List<AccessToVariable>> pair in accessesToVariables) { IVariable variable = pair.Key; AddSubParagraph("Variable " + variable.Name); CreateVariableHeader(variable); CreateVariableUsage(pair.Value); CloseSubParagraph(); } CloseSubParagraph(); } CloseSubParagraph(); }
/// <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) { bool foundMatch = false; DBField field = fields[currentIndex] as DBField; KeyValuePair<string, IVariable> pair = aStructure.SubVariables.ElementAt(j); IVariable variable = pair.Value; // Conditioned 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)) { foundMatch = true; 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; } else if (stringValue.EndsWith(" b")) { stringValue = stringValue.Substring(0, stringValue.Length - 2); v = Convert.ToInt32(stringValue, 2); } } 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)) { foundMatch = true; 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 if (!foundMatch) { // We used a lookahead to determine if we needed to fill the structure // But the encountered field is not the right one // (for instance, because of a conditional field determiner by a Q_XXX value) // => Rollback currentIndex -= 1; break; } else { currentIndex += 1; } } }
/// <summary> /// Common part of the consideration of an access /// </summary> /// <param name="container"></param> /// <param name="sourceNameSpace"></param> /// <param name="targetNameSpace"></param> /// <param name="retVal"></param> /// <returns></returns> private static bool considerCommon(IEnclosesNameSpaces container, NameSpace sourceNameSpace, NameSpace targetNameSpace) { bool retVal = true; // Only display things that are relevant namespacewise retVal = retVal && sourceNameSpace != null && targetNameSpace != null; // Do not consider internal accesses retVal = retVal && sourceNameSpace != targetNameSpace; if (container != null) { // Only display things that can be displayed in this functional view // TODO : also consider sub namespaces in the diagram retVal = retVal && (container.NameSpaces.Contains(sourceNameSpace) || container.NameSpaces.Contains(targetNameSpace)); } 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; }
public override NameSpace createNameSpace() { NameSpace retVal = new Types.NameSpace(); _defaultValueSetter.SetDefaultValue(retVal); return retVal; }
/// <summary> /// Provides the type associated to the name /// </summary> /// <param name="nameSpace"></param> /// <param name="name"></param> /// <returns></returns> public Type FindType(NameSpace nameSpace, string name) { Type retVal = null; if (name != null) { foreach (Dictionary dictionary in Dictionaries) { retVal = dictionary.FindType(nameSpace, name); if (retVal != null) { break; } } if (retVal == null) { PredefinedTypes.TryGetValue(name, out retVal); } } return retVal; }
/// <summary> /// Fills the tree view with the namespace and enclosed namespaces /// </summary> /// <param name="treeNode"></param> /// <param name="nameSpace"></param> /// <param name="filterConfiguration">The filter configuration used to set up the check boxes</param> private void GatherNamespaces(TreeNode treeNode, NameSpace nameSpace, FilterConfiguration filterConfiguration) { NamableTreeNode nameSpaceTreeNode = new NamableTreeNode(nameSpace); nameSpaceTreeNode.Checked = filterConfiguration.NameSpaces.Contains(nameSpace); nameSpaceTreeNode.Collapse(); treeNode.Nodes.Add(nameSpaceTreeNode); // Adds the variables to the selection List<Variable> variables = new List<Variable>(); foreach (Variable variable in nameSpace.Variables) { variables.Add(variable); } variables.Sort(); foreach (Variable variable in variables) { NamableTreeNode variableTreeNode = new NamableTreeNode(variable); variableTreeNode.Checked = filterConfiguration.Variables.Contains(variable); nameSpaceTreeNode.Nodes.Add(variableTreeNode); } // Adds the subnamespaces to the selection List<NameSpace> subNameSpaces = new List<NameSpace>(); foreach (NameSpace otherNameSpace in nameSpace.NameSpaces) { subNameSpaces.Add(otherNameSpace); } subNameSpaces.Sort(); foreach (NameSpace subNameSpace in subNameSpaces) { GatherNamespaces(nameSpaceTreeNode, subNameSpace, filterConfiguration); } }
/// <summary> /// Constructor /// </summary> /// <param name="item"></param> /// <param name="buildSubNodes"></param> public NameSpaceSubNameSpacesTreeNode(NameSpace item, bool buildSubNodes) : base(item, buildSubNodes, "Namespaces", true) { }
public StandardValuesCollection GetValues(NameSpace nameSpace, Type type) { FinderRepository.INSTANCE.ClearCache(); List<string> retVal = new List<string>(); if (type != null) { string prefix = type.FullName; if (nameSpace == type.NameSpace && nameSpace != null) { prefix = prefix.Substring(nameSpace.FullName.Length + 1); } OverallValueFinder.INSTANCE.findAllValueNames(prefix, type, false, retVal); retVal.Sort(); } return new StandardValuesCollection(retVal); }
/// <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; } } }