public void AddHandler(object sender, EventArgs args)
{
Rule rule = (Rule)acceptor.getFactory().createRule();
rule.Name = "<Rule" + (GetNodeCount(false) + 1) + ">";
Item.appendRules(rule);
}
/// <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 RuleTreeNode)
{
RuleTreeNode node = SourceNode as RuleTreeNode;
DataDictionary.Rules.Rule rule = node.Item;
node.Delete();
AddRule(rule);
}
else if (SourceNode is SpecificationView.ParagraphTreeNode)
{
SpecificationView.ParagraphTreeNode node = SourceNode as SpecificationView.ParagraphTreeNode;
DataDictionary.Specification.Paragraph paragaph = node.Item;
DataDictionary.Rules.Rule rule = (DataDictionary.Rules.Rule)DataDictionary.Generated.acceptor.getFactory().createRule();
rule.Name = paragaph.Name;
DataDictionary.ReqRef reqRef = (DataDictionary.ReqRef)DataDictionary.Generated.acceptor.getFactory().createReqRef();
reqRef.Name = paragaph.FullId;
rule.appendRequirements(reqRef);
AddRule(rule);
}
}
/// <summary>
/// Adds a rule in this set of sub rules
/// </summary>
/// <param name="rule"></param>
public void AddRule(DataDictionary.Rules.Rule rule)
{
Item.appendSubRules(rule);
Nodes.Add(new RuleTreeNode(rule));
SortSubNodes();
Item.setVerified(false);
}
/// <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>
/// Creates a rule and a rule condition in the procedure
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected RuleCondition CreateRuleAndCondition(Procedure enclosing, string name)
{
Rule rule = (Rule)Factory.createRule();
enclosing.appendRules(rule);
rule.Name = name;
return(CreateRuleCondition(rule, name));
}
/// <summary>
/// Adds a rule in the corresponding namespace
/// </summary>
/// <param name="variable"></param>
public RuleTreeNode AddRule(DataDictionary.Rules.Rule rule)
{
Item.appendRules(rule);
RuleTreeNode retVal = new RuleTreeNode(rule);
Nodes.Add(retVal);
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));
}
public override void visit(Generated.Rule obj, bool visitSubNodes)
{
DataDictionary.Rules.Rule rule = (DataDictionary.Rules.Rule)obj;
if (!rule.getVerified())
{
rule.AddInfo("Rule not verified");
}
base.visit(obj, visitSubNodes);
}
private int Comparer(DataDictionary.Rules.Rule r1, DataDictionary.Rules.Rule r2)
{
if (r1.ExecutionTimeInMilli < r2.ExecutionTimeInMilli)
{
return(1);
}
else if (r1.ExecutionTimeInMilli > r2.ExecutionTimeInMilli)
{
return(-1);
}
return(0);
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is RuleTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding rule ?", "Move rule", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
RuleTreeNode ruleTreeNode = (RuleTreeNode)SourceNode;
DataDictionary.Rules.Rule rule = ruleTreeNode.Item;
ruleTreeNode.Delete();
AddRule(rule);
}
}
}
/// <summary>
/// Compares two rules according to their execution time
/// </summary>
/// <param name="r1"></param>
/// <param name="r2"></param>
/// <returns></returns>
private static int Comparer(Rule r1, Rule r2)
{
int retVal = 0;
if (r1.ExecutionTimeInMilli < r2.ExecutionTimeInMilli)
{
retVal = 1;
}
else if (r1.ExecutionTimeInMilli > r2.ExecutionTimeInMilli)
{
retVal = -1;
}
return(retVal);
}
/// <summary>
/// Provides the rule according to its fullname
/// </summary>
/// <param name="fullName"></param>
/// <returns></returns>
public Rule FindRule(string fullName)
{
Rule retVal = null;
foreach (Rule rule in AllRules)
{
if (rule.FullName.Equals(fullName))
{
retVal = rule;
break;
}
}
return(retVal);
}
/// <summary>
/// Sets the update information for this structure
/// </summary>
/// <param name="source">The source structure for which this structure has been created (as an update)</param>
public override void SetUpdateInformation(ModelElement source)
{
base.SetUpdateInformation(source);
Structure sourceStructure = (Structure)source;
foreach (StructureElement element in Elements)
{
StructureElement baseElement = sourceStructure.FindStructureElement(element.Name);
if (baseElement != null)
{
element.SetUpdateInformation(baseElement);
}
}
foreach (Procedure procedure in Procedures)
{
Procedure baseProcedure = sourceStructure.FindProcedure(procedure.Name);
if (baseProcedure != null)
{
procedure.SetUpdateInformation(baseProcedure);
}
}
foreach (Rule rule in Rules)
{
Rule baseRule = sourceStructure.FindRule(rule.Name);
if (baseRule != null)
{
rule.SetUpdateInformation(baseRule);
}
}
foreach (StateMachine stateMachine in StateMachines)
{
StateMachine baseStateMachine = sourceStructure.FindStateMachine(stateMachine.Name);
if (baseStateMachine != null)
{
stateMachine.SetUpdateInformation(baseStateMachine);
}
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="element"></param>
public override void AddModelElement(IModelElement element)
{
{
StructureRef item = element as StructureRef;
if (item != null)
{
appendInterfaces(item);
}
}
{
StructureElement item = element as StructureElement;
if (item != null)
{
appendElements(item);
}
}
{
Procedure item = element as Procedure;
if (item != null)
{
appendProcedures(item);
}
}
{
StateMachine item = element as StateMachine;
if (item != null)
{
appendStateMachines(item);
}
}
{
Rule item = element as Rule;
if (item != null)
{
appendRules(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Creates a section for an (implemented) rule (or sub-rule of a rule)
/// </summary>
/// <param name="section">Section to which the new section will be added</param>
/// <param name="anEnum">The rule to add</param>
/// <param name="addDetails">Add details or simply enumerate the enums</param>
private void AddRuleRow(DataDictionary.Rules.Rule aRule, bool addDetails)
{
if (addDetails)
{
AddTableHeader("Rule " + aRule.Name);
AddRow(aRule.Comment);
AddRow("Activation priority", aRule.getPriority_AsString());
AddRow(Utils.RTFConvertor.RTFToPlainText(aRule.getExplain(false)));
}
else
{
AddRow(aRule.Name + " (" + GetRequirementsAsString(aRule.Requirements) + ")");
}
foreach (DataDictionary.Rules.RuleCondition ruleCondition in aRule.RuleConditions)
{
foreach (DataDictionary.Rules.Rule subRule in ruleCondition.SubRules)
{
AddRuleRow(subRule, addDetails);
}
}
}
/// <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 RuleTreeNode)
{
RuleTreeNode ruleTreeNode = sourceNode as RuleTreeNode;
Rule rule = ruleTreeNode.Item;
ruleTreeNode.Delete();
Item.appendRules(rule);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
Rule rule = Rule.CreateDefault(Item.Rules);
Item.appendRules(rule);
rule.FindOrCreateReqRef(paragraph);
}
}
/// <summary>
/// Creates a section for an (implemented) rule (or sub-rule of a rule)
/// </summary>
/// <param name="section">Section to which the new section will be added</param>
/// <param name="anEnum">The rule to add</param>
/// <param name="addDetails">Add details or simply enumerate the enums</param>
private void AddRuleSection(DataDictionary.Rules.Rule aRule, bool addDetails)
{
if (addDetails)
{
AddSubParagraph(aRule.Name);
AddRuleRow(aRule, addDetails);
CloseSubParagraph();
}
else
{
AddParagraph(aRule.Name + " (" + GetRequirementsAsString(aRule.Requirements) + ")");
}
foreach (DataDictionary.Rules.RuleCondition ruleCondition in aRule.RuleConditions)
{
foreach (DataDictionary.Rules.Rule subRule in ruleCondition.SubRules)
{
if (subRule.ImplementationPartiallyCompleted == true)
{
AddRuleSection(subRule, addDetails);
}
}
}
}
/// <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>
/// Compares two rules according to their execution time
/// </summary>
/// <param name="r1"></param>
/// <param name="r2"></param>
/// <returns></returns>
private static int Comparer(Rule r1, Rule r2)
{
int retVal = 0;
if (r1.ExecutionTimeInMilli < r2.ExecutionTimeInMilli)
{
retVal = 1;
}
else if (r1.ExecutionTimeInMilli > r2.ExecutionTimeInMilli)
{
retVal = -1;
}
return retVal;
}
private int Comparer(Rule r1, Rule r2)
{
if (r1.ExecutionTimeInMilli < r2.ExecutionTimeInMilli)
{
return 1;
}
else if (r1.ExecutionTimeInMilli > r2.ExecutionTimeInMilli)
{
return -1;
}
return 0;
}
public DisplayObject(Rule rule)
{
Rule = rule;
}
public override void visit(DataDictionary.Generated.Rule obj, bool visitSubNodes)
{
Rule rule = obj as Rule;
Rules.Add(rule);
}
public DisplayObject(Rule rule)
{
Rule = rule;
}
/// <summary>
/// Adds information about a rule (or sub-rule of a rule)
/// </summary>
/// <param name="aRule">The rule to add</param>
/// <param name="addDetails">Add details or simply enumerate the enums</param>
/// <param name="addToExistingTable">Add information to an existing table or create a separate section</param>
private void AddRuleSection(Rule aRule, bool addDetails, bool addToExitingTable)
{
if (addDetails)
{
if (!addToExitingTable)
{
AddSubParagraph(aRule.Name);
}
AddRuleRow(aRule, addDetails);
if (!addToExitingTable)
{
CloseSubParagraph();
}
}
else
{
AddParagraph(aRule.Name + " (" + GetRequirementsAsString(aRule.Requirements) + ")");
}
}
/// <summary>
/// Adds a row for a rule (or sub-rule of a rule)
/// </summary>
/// <param name="aRule">The rule to add</param>
/// <param name="addDetails">Add details or simply enumerate the enums</param>
private void AddRuleRow(Rule aRule, bool addDetails)
{
if (addDetails)
{
if (aRule.EnclosingRuleCondition != null)
{
AddTable(
new string[]
{
"Sub-rule " + aRule.Name + " (parent rule condition : " + aRule.EnclosingRuleCondition.Name +
")"
}, new int[] {40, 100});
}
else
{
AddTable(new string[] {"Rule " + aRule.Name}, new int[] {40, 100});
}
AddRow(aRule.Comment);
AddRow("Activation priority", aRule.getPriority_AsString());
TextualExplanation explanation = new TextualExplanation();
aRule.GetExplain(explanation, false);
AddRow(explanation.Text);
}
else
{
AddRow(aRule.Name + " (" + GetRequirementsAsString(aRule.Requirements) + ")");
}
foreach (RuleCondition ruleCondition in aRule.RuleConditions)
{
if (CountDisplayedReqRelated(ruleCondition.SubRules) > 0)
{
AddTableHeader("Sub-rules of " + ruleCondition.Name);
foreach (Rule subRule in ruleCondition.SubRules)
{
if (considerReqRelated(subRule))
{
AddRuleRow(subRule, addDetails);
}
}
}
}
}
