/// <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;
}
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);
}
/// <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>
/// 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>
/// 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);
}
