/// <summary> /// Accepts drop of a tree node, in a drag & drop operation /// </summary> /// <param name="SourceNode"></param> public override void AcceptDrop(BaseTreeNode SourceNode) { base.AcceptDrop(SourceNode); if (SourceNode is VariableTreeNode) { VariableTreeNode variableTreeNode = SourceNode as VariableTreeNode; DataDictionary.Variables.Variable variable = variableTreeNode.Item; variableTreeNode.Delete(); AddVariable(variable); } else if (SourceNode is SpecificationView.ParagraphTreeNode) { SpecificationView.ParagraphTreeNode node = SourceNode as SpecificationView.ParagraphTreeNode; DataDictionary.Specification.Paragraph paragaph = node.Item; DataDictionary.Variables.Variable variable = (DataDictionary.Variables.Variable)DataDictionary.Generated.acceptor.getFactory().createVariable(); variable.Name = paragaph.Name; DataDictionary.ReqRef reqRef = (DataDictionary.ReqRef)DataDictionary.Generated.acceptor.getFactory().createReqRef(); reqRef.Name = paragaph.FullId; variable.appendRequirements(reqRef); AddVariable(variable); } }
public override void visit(Generated.Variable obj, bool visitSubNodes) { DataDictionary.Variables.Variable variable = obj as Variables.Variable; if (variable != null) { if (variable.Type == null) { variable.AddError("Cannot find type for variable"); } else { Types.Structure structure = variable.Type as Types.Structure; if (structure != null) { foreach (Types.StructureElement element in structure.Elements) { if (!ValidMode(variable.Mode, element.Mode)) { variable.AddWarning("Invalid mode for " + element.Name); } } } } if (Utils.Utils.isEmpty(variable.Comment) && variable.Type != null && Utils.Utils.isEmpty(variable.Type.Comment)) { variable.AddInfo("Missing variable semantics. Update the 'Comment' associated to the variable or to the corresponding type"); } } base.visit(obj, visitSubNodes); }
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); }
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); }
/// <summary> /// Indicates if a variable should be considered for the report /// </summary> /// <param name="aVariable"></param> /// <param name="inOutOnly"></param> /// <returns></returns> private bool considerVariable(Variable aVariable, bool inOutOnly) { return((aVariable.ImplementationPartiallyCompleted || !implementedOnly) && (!inOutOnly || aVariable.Mode == acceptor.VariableModeEnumType.aIncoming || aVariable.Mode == acceptor.VariableModeEnumType.aOutgoing || aVariable.Mode == acceptor.VariableModeEnumType.aInOut)); }
/// <summary> /// Appends a new field group in the namespace /// </summary> /// <param name="nameSpace">The namespace in which the field group should be added</param> /// <param name="name">The name of the field group</param> /// <param name="fieldGroup">The field group to append</param> private void AppendFieldGroup(DataDictionary.Types.NameSpace nameSpace, string name, FieldGroup fieldGroup) { DataDictionary.Types.NameSpace enclosingNameSpace = GetNameSpaceBasedOnName(nameSpace, name); // create a structure for the field group DataDictionary.Types.Structure structure = (DataDictionary.Types.Structure)DataDictionary.Generated.acceptor.getFactory().createStructure(); structure.Name = "Message"; structure.Comment = fieldGroup.description; enclosingNameSpace.appendStructures(structure); numberOfSubStructures = 1; numberOfCollections = 1; RenameDuplicates(fieldGroup.field_sequence.Items); foreach (object obj in fieldGroup.field_sequence.Items) { AppendField(obj, structure, fieldGroup.discriminant_value.ToString()); } // Handles root elements if (!Utils.Utils.isEmpty(fieldGroup.main)) { DataDictionary.Variables.Variable variable = (DataDictionary.Variables.Variable)DataDictionary.Generated.acceptor.getFactory().createVariable(); variable.Name = fieldGroup.main; variable.setTypeName(structure.FullName); variable.Mode = DataDictionary.Generated.acceptor.VariableModeEnumType.aInOut; nameSpace.appendVariables(variable); } }
private void displayVariable(Variable var) { switch (var.Mode) { case acceptor.VariableModeEnumType.aIncoming: Writer.Write("IN "); break; case acceptor.VariableModeEnumType.aInOut: Writer.Write("IN OUT "); break; case acceptor.VariableModeEnumType.aOutgoing: Writer.Write(" OUT "); break; default: return; } Type type = var.Type; Writer.WriteLine(var.FullName + " : " + type.FullName); displayType(1, type); }
// Visits a variable declaration public override void visit(DataDictionary.Generated.Variable obj, bool visitSubNodes) { Variable variable = (Variable)obj; switch (variable.Mode) { case acceptor.VariableModeEnumType.aIncoming: displayVariable(variable); break; case acceptor.VariableModeEnumType.aInOut: displayVariable(variable); break; case acceptor.VariableModeEnumType.aOutgoing: displayVariable(variable); break; case acceptor.VariableModeEnumType.aConstant: break; case acceptor.VariableModeEnumType.aInternal: break; default: break; } base.visit(obj, visitSubNodes); }
public void TestDifferentiationOfSubStatesWithSameName() { Dictionary dictionary = CreateDictionary("Test"); NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace"); StateMachine stateMachine = CreateStateMachine(nameSpace, "StateMachine"); // The left branch State state1 = CreateState(stateMachine, "State1"); State subState1 = CreateState(state1.StateMachine, "SubState"); // The right branch State state2 = CreateState(stateMachine, "State2"); State subState2 = CreateState(state2.StateMachine, "SubState"); Variable stateVariable = CreateVariable(nameSpace, "Variable", "StateMachine"); stateVariable.Default = "StateMachine.State1.SubState"; Compiler.Compile_Synchronous(true); Expression expression = new Parser().Expression(dictionary, "NameSpace.Variable in [NameSpace.StateMachine.State2.SubState]"); IValue value = expression.GetExpressionValue(new InterpretationContext(), null); Assert.AreEqual(System.BoolType.False, value); }
/// <summary> /// Sets the default values to each variable /// </summary> /// <param name="variable">The variable to set</param> /// <param name="subNodes">Indicates whether sub nodes should be considered</param> public override void visit(DataDictionary.Generated.Variable variable, bool subNodes) { DataDictionary.Variables.Variable var = (DataDictionary.Variables.Variable)variable; var.Value = var.DefaultValue; base.visit(variable, subNodes); }
/// <summary> /// Creates a variable in the namespace provided /// </summary> /// <param name="enclosing"></param> /// <param name="name"></param> /// <param name="typeName"></param> /// <returns></returns> protected Variable CreateVariable(NameSpace enclosing, string name, string typeName) { Variable retVal = (Variable)Factory.createVariable(); enclosing.appendVariables(retVal); retVal.Name = name; retVal.TypeName = typeName; return(retVal); }
/// <summary> /// Clears the cached FullName for all namables /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(Generated.Namable obj, bool visitSubNodes) { Namable namable = (Namable)obj; namable.ClearFullName(); Variable variable = namable as Variable; if (variable != null) { variable.Value = null; } base.visit(obj, visitSubNodes); }
/// <summary> /// Adds a variable in the corresponding namespace /// </summary> /// <param name="variable"></param> public VariableTreeNode AddVariable(DataDictionary.Variables.Variable variable) { // Ensure that variables always have a type if (variable.Type == null) { variable.Type = variable.EFSSystem.BoolType; } Item.appendVariables(variable); VariableTreeNode retVal = new VariableTreeNode(variable, new HashSet <DataDictionary.Types.Type>()); Nodes.Add(retVal); SortSubNodes(); return(retVal); }
public void TestCollectionConcatenation() { Dictionary dictionary = CreateDictionary("Test"); NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace"); Structure structure = CreateStructure(nameSpace, "ModelElement"); StructureElement structElem = CreateStructureElement(structure, "Value", "Boolean"); structElem.setDefault("True"); Collection collection = CreateCollection(nameSpace, "Coll", "ModelElement", 10); collection.Type = structure; collection.setMaxSize(3); collection.Default = "[]"; Variable variable = CreateVariable(nameSpace, "V", "Coll"); RuleCondition ruleCondition = CreateRuleAndCondition(nameSpace, "Test"); Action action = CreateAction(ruleCondition, "V <- V + [ModelElement{Value => True}] "); RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary); visitor.visit(nameSpace); Util.IsThereAnyError isThereAnyError = new Util.IsThereAnyError(); Assert.AreEqual(0, isThereAnyError.ErrorsFound.Count); Assert.AreEqual("[]", variable.Value.LiteralName); Runner runner = new Runner(false); runner.Cycle(); Assert.AreEqual("[" + structure.DefaultValue.LiteralName + "]", variable.Value.LiteralName); runner.Cycle(); Assert.AreEqual("[" + structure.DefaultValue.LiteralName + ", " + structure.DefaultValue.LiteralName + "]", variable.Value.LiteralName); runner.Cycle(); Assert.AreEqual("[" + structure.DefaultValue.LiteralName + ", " + structure.DefaultValue.LiteralName + ", " + structure.DefaultValue.LiteralName + "]", variable.Value.LiteralName); // In this case, the new collection cannot be placed in the variable runner.Cycle(); Assert.AreEqual(1, action.Messages.Count); Assert.AreEqual(ElementLog.LevelEnum.Error, action.Messages[0].Level); }
public void TestVariableAndTypeWithSameName() { Dictionary dictionary = CreateDictionary("Test"); NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace"); Structure structure = CreateStructure(nameSpace, "ModelElement"); StructureElement structElem = CreateStructureElement(structure, "Value", "Boolean"); structElem.setDefault("True"); Variable variable = CreateVariable(nameSpace, "ModelElement", "ModelElement"); variable.SubVariables["Value"].Value = System.BoolType.False; Expression expression = new Parser().Expression(dictionary, "NameSpace.ModelElement.Value"); IValue value = expression.GetExpressionValue(new InterpretationContext(), null); Assert.AreEqual(value, variable.SubVariables["Value"].Value); }
/// <summary> /// Called when the drop operation is performed on this text box /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void DragDropHandler(object sender, DragEventArgs e) { if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false)) { BaseTreeNode SourceNode = (BaseTreeNode)e.Data.GetData("WindowsForms10PersistentObject"); if (SourceNode != null) { DataDictionaryView.VariableTreeNode variableNode = SourceNode as DataDictionaryView.VariableTreeNode; if (variableNode != null) { StringBuilder text = new StringBuilder(); text.Append(StripUseless(SourceNode.Model.FullName, EnclosingForm.Selected) + " <- "); DataDictionary.Variables.Variable variable = variableNode.Item; DataDictionary.Types.Structure structure = variable.Type as DataDictionary.Types.Structure; if (structure != null) { text.Append(StripUseless(structure.FullName, EnclosingForm.Selected) + "{\n"); bool first = true; foreach (DataDictionary.Types.StructureElement element in structure.Elements) { if (!first) { text.Append(",\n"); } insertElement(element, text, 4); first = false; } text.Append("}\n"); } else { text.Append(variable.DefaultValue.FullName); } SelectedText = text.ToString(); } else { SelectedText = StripUseless(SourceNode.Model.FullName, EnclosingForm.Selected); } } } }
protected override void VisitDesignator(Designator designator) { base.VisitDesignator(designator); Utils.ModelElement current = designator.Ref as Utils.ModelElement; while (current != null && !(current is NameSpace) && !(current is Parameter)) { bool change; Variable variable = current as Variable; if (variable != null) { change = variable.AddDependancy(DependantFunction); DependancyChange = DependancyChange || change; } else { StructureElement structureElement = current as StructureElement; if (structureElement != null) { change = structureElement.AddDependancy(DependantFunction); DependancyChange = DependancyChange || change; change = structureElement.Structure.AddDependancy(DependantFunction); DependancyChange = DependancyChange || change; } else { Function function = current as Function; if (function != null) { change = function.AddDependancy(DependantFunction); DependancyChange = DependancyChange || change; } } } current = current.Enclosing as Utils.ModelElement; } }
public void AddHandler(object sender, EventArgs args) { DataDictionary.Variables.Variable variable = (DataDictionary.Variables.Variable)DataDictionary.Generated.acceptor.getFactory().createVariable(); variable.Name = "<Variable" + (GetNodeCount(false) + 1) + ">"; AddVariable(variable); }
/// <summary> /// Constructor /// </summary> /// <param name="panel"></param> /// <param name="model"></param> public VariableModelControl(ModelDiagramPanel panel, Variable model) : base(panel, model) { BoxMode = BoxModeEnum.RoundedCorners; NormalColor = Color.BlanchedAlmond; }
/// <summary> /// Adds a new variable /// </summary> /// <param name="variable"></param> /// <returns>the corresponding node</returns> public VariableTreeNode AddVariable(DataDictionary.Variables.Variable variable) { return(variables.AddVariable(variable)); }
/// <summary> /// Indicates if a variable should be considered for the report /// </summary> /// <param name="aVariable"></param> /// <param name="inOutOnly"></param> /// <returns></returns> private bool considerVariable(Variable aVariable, bool inOutOnly) { return (aVariable.ImplementationPartiallyCompleted || !implementedOnly) && (!inOutOnly || aVariable.Mode == acceptor.VariableModeEnumType.aIncoming || aVariable.Mode == acceptor.VariableModeEnumType.aOutgoing || aVariable.Mode == acceptor.VariableModeEnumType.aInOut); }