/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is RuleConditionTreeNode)
{
RuleConditionTreeNode node = SourceNode as RuleConditionTreeNode;
DataDictionary.Rules.RuleCondition ruleCondition = node.Item;
node.Delete();
AddRuleCondition(ruleCondition);
}
else if (SourceNode is SpecificationView.ParagraphTreeNode)
{
SpecificationView.ParagraphTreeNode node = SourceNode as SpecificationView.ParagraphTreeNode;
DataDictionary.Specification.Paragraph paragaph = node.Item;
DataDictionary.Rules.RuleCondition ruleCondition = (DataDictionary.Rules.RuleCondition)DataDictionary.Generated.acceptor.getFactory().createRuleCondition();
ruleCondition.Name = paragaph.Name;
DataDictionary.ReqRef reqRef = (DataDictionary.ReqRef)DataDictionary.Generated.acceptor.getFactory().createReqRef();
reqRef.Name = paragaph.FullId;
ruleCondition.appendRequirements(reqRef);
AddRuleCondition(ruleCondition);
}
}
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 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);
}
/// <summary>
/// Creates a rule condition in a rule
/// </summary>
/// <param name="rule"></param>
/// <param name="name"></param>
/// <returns></returns>
private RuleCondition CreateRuleCondition(Rule rule, string name)
{
RuleCondition retVal = (RuleCondition)Factory.createRuleCondition();
rule.appendConditions(retVal);
retVal.Name = name;
return(retVal);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="item"></param>
/// <param name="children"></param>
public RulePreConditionsTreeNode(DataDictionary.Rules.RuleCondition item)
: base(item, "Pre conditions", true, false)
{
foreach (DataDictionary.Rules.PreCondition preCondition in item.PreConditions)
{
Nodes.Add(new PreConditionTreeNode(preCondition));
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="item"></param>
public SubRulesTreeNode(DataDictionary.Rules.RuleCondition item)
: base(item, "Sub rules", true, false)
{
foreach (DataDictionary.Rules.Rule rule in item.SubRules)
{
Nodes.Add(new RuleTreeNode(rule));
}
SortSubNodes();
}
/// <summary>
/// Creates a precondition in the enclosing rule condition
/// </summary>
/// <param name="enclosing"></param>
/// <param name="expression"></param>
/// <returns></returns>
protected PreCondition CreatePreCondition(RuleCondition enclosing, string expression)
{
PreCondition retVal = (PreCondition)Factory.createPreCondition();
enclosing.appendPreConditions(retVal);
retVal.ExpressionText = expression;
return(retVal);
}
/// <summary>
/// Creates a rule and a rule condition in the rule condition
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected RuleCondition CreateRuleAndCondition(RuleCondition enclosing, string name)
{
Rule rule = (Rule)Factory.createRule();
enclosing.appendSubRules(rule);
rule.Name = name;
rule.setPriority(acceptor.RulePriority.aProcessing);
return(CreateRuleCondition(rule, name));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="item"></param>
public ActionsTreeNode(DataDictionary.Rules.RuleCondition item)
: base(item, "Actions", true, false)
{
foreach (DataDictionary.Rules.Action action in item.Actions)
{
Nodes.Add(new ActionTreeNode(action));
}
if (Item.EnclosingRule != null && !Item.EnclosingRule.BelongsToAProcedure())
{
SortSubNodes();
}
}
private void AddHandler(object sender, EventArgs args)
{
RuleCondition ruleCondition = (RuleCondition)acceptor.getFactory().createRuleCondition();
if (Item.RuleConditions.Count == 0)
{
ruleCondition.Name = Item.Name;
}
else
{
ruleCondition.Name = Item.Name + (Item.RuleConditions.Count + 1);
}
Item.appendConditions(ruleCondition);
}
/// <summary>
/// Provides the transition control which corresponds to the rule
/// </summary>
/// <param name="ruleCondition"></param>
/// <returns></returns>
public TransitionControl getTransitionControl(DataDictionary.Rules.RuleCondition ruleCondition)
{
TransitionControl retVal = null;
foreach (TransitionControl control in transitions.Values)
{
if (control.Transition.RuleCondition == ruleCondition)
{
retVal = control;
break;
}
}
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);
}
/// <summary>
/// Splits the selected action to several sub-actions
/// </summary>
public virtual void SplitHandler(object sender, EventArgs args)
{
Statement statement = new Parser().Statement(Item, Item.ExpressionText);
VariableUpdateStatement variableUpdateStatement = statement as VariableUpdateStatement;
if (variableUpdateStatement != null)
{
Expression expression = variableUpdateStatement.Expression;
StructExpression structExpression = expression as StructExpression;
if (structExpression != null)
{
Dictionary <Designator, Expression> associations = structExpression.Associations;
foreach (KeyValuePair <Designator, Expression> value in associations)
{
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = structExpression.Structure + "." + value.Key + " <- " +
value.Value;
ActionTreeNode actionTreeNode = new ActionTreeNode(action, true);
BaseTreeNode parent = Parent as BaseTreeNode;
if (parent != null)
{
RuleCondition ruleCondition = Item.Enclosing as RuleCondition;
if (ruleCondition != null)
{
ruleCondition.appendActions(action);
}
else
{
SubStep subStep = Item.Enclosing as SubStep;
if (subStep != null)
{
subStep.appendActions(action);
}
}
parent.Nodes.Add(actionTreeNode);
}
}
}
}
Delete();
}
/// <summary>
/// Splits the selected action to several sub-actions
/// </summary>
public virtual void SplitHandler(object sender, EventArgs args)
{
DataDictionary.Interpreter.Statement.Statement statement = Item.EFSSystem.Parser.Statement(Item, Item.ExpressionText);
DataDictionary.Interpreter.Statement.VariableUpdateStatement variableUpdateStatement = statement as DataDictionary.Interpreter.Statement.VariableUpdateStatement;
if (variableUpdateStatement != null)
{
DataDictionary.Interpreter.Expression expression = variableUpdateStatement.Expression;
DataDictionary.Interpreter.StructExpression structExpression = expression as DataDictionary.Interpreter.StructExpression;
if (structExpression != null)
{
Dictionary <string, DataDictionary.Interpreter.Expression> associations = structExpression.Associations;
foreach (KeyValuePair <string, DataDictionary.Interpreter.Expression> value in associations)
{
DataDictionary.Rules.Action action = (DataDictionary.Rules.Action)DataDictionary.Generated.acceptor.getFactory().createAction();
action.Expression = structExpression.Structure.ToString() + "." + value.Key + " <- " + value.Value.ToString();
string aString = value.Value.ToString();
ActionTreeNode actionTreeNode = new ActionTreeNode(action);
BaseTreeNode parent = Parent as BaseTreeNode;
if ((parent != null) && (parent.Nodes != null))
{
DataDictionary.Rules.RuleCondition ruleCondition = Item.Enclosing as DataDictionary.Rules.RuleCondition;
if (ruleCondition != null)
{
ruleCondition.appendActions(action);
}
else
{
DataDictionary.Tests.SubStep subStep = Item.Enclosing as DataDictionary.Tests.SubStep;
if (subStep != null)
{
subStep.appendActions(action);
}
}
parent.Nodes.Add(actionTreeNode);
}
}
}
}
Delete();
SortSubNodes();
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is RuleConditionTreeNode)
{
RuleConditionTreeNode node = sourceNode as RuleConditionTreeNode;
RuleCondition ruleCondition = node.Item;
node.Delete();
Item.appendConditions(ruleCondition);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
RuleCondition ruleCondition = RuleCondition.CreateDefault(Item.RuleConditions);
Item.appendConditions(ruleCondition);
ruleCondition.FindOrCreateReqRef(paragraph);
}
}
/// <summary>
/// Adds a new rule to the model
/// </summary>
/// <param name="ruleCondition"></param>
public void AddRuleCondition(DataDictionary.Rules.RuleCondition ruleCondition)
{
Item.appendConditions(ruleCondition);
Nodes.Add(new DataDictionaryView.RuleConditionTreeNode(ruleCondition));
}
private void AddHandler(object sender, EventArgs args)
{
DataDictionary.Rules.RuleCondition rule = (DataDictionary.Rules.RuleCondition)DataDictionary.Generated.acceptor.getFactory().createRuleCondition();
rule.Name = "<RuleCondition" + (GetNodeCount(false) + 1) + ">";
AddRuleCondition(rule);
}
/// <summary>
/// Creates a rule and a rule condition in the rule condition
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected RuleCondition CreateRuleAndCondition(RuleCondition enclosing, string name)
{
Rule rule = (Rule)Factory.createRule();
enclosing.appendSubRules(rule);
rule.Name = name;
rule.setPriority(acceptor.RulePriority.aProcessing);
return CreateRuleCondition(rule, name);
}
/// <summary>
/// Creates a precondition in the enclosing rule condition
/// </summary>
/// <param name="enclosing"></param>
/// <param name="expression"></param>
/// <returns></returns>
protected PreCondition CreatePreCondition(RuleCondition enclosing, string expression)
{
PreCondition retVal = (PreCondition) Factory.createPreCondition();
enclosing.appendPreConditions(retVal);
retVal.ExpressionText = expression;
return retVal;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="item"></param>
/// <param name="buildSubNodes"></param>
public ActionsTreeNode(RuleCondition item, bool buildSubNodes)
: base(item, buildSubNodes, "Actions", false)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="item"></param>
/// <param name="buildSubNodes"></param>
public SubRulesTreeNode(RuleCondition item, bool buildSubNodes)
: base(item, buildSubNodes, "Sub rules", false)
{
}
