/// <summary> /// Sets the update information for this rule condition (this rule condition updates source) /// </summary> /// <param name="source"></param> public override void SetUpdateInformation(ModelElement source) { base.SetUpdateInformation(source); RuleCondition sourceRuleCondition = (RuleCondition)source; foreach (Action action in Actions) { Action baseAction = sourceRuleCondition.FindAction(action.Name); if (baseAction != null) { action.SetUpdateInformation(baseAction); } } foreach (PreCondition preCondition in PreConditions) { PreCondition basePreCondition = sourceRuleCondition.FindPreCondition(preCondition.Name); if (basePreCondition != null) { preCondition.SetUpdateInformation(basePreCondition); } } foreach (Rule rule in SubRules) { Rule baseRule = sourceRuleCondition.FindRule(rule.Name); if (baseRule != null) { rule.SetUpdateInformation(baseRule); } } }
/// <summary> /// Updates (if possible) the initial state for this transition /// </summary> /// <param name="initialBox"></param> public void SetInitialBox(IGraphicalDisplay initialBox) { State initialState = (State)initialBox; if (Action != null) { if (PreCondition != null) { if (PreCondition.Rule == Action.Rule) { List <State> states = StateMachine.GetStates(PreCondition.Expression); if (states.Count == 1) { PreCondition.ExpressionText = "THIS == " + initialState.FullName; Source = initialState; } else { throw new CannotChangeRuleException("More than one state in the pre condition expression"); } } else { throw new CannotChangeRuleException("Precondition is not at the same level as the action"); } } else { RuleCondition ruleCondition = Action.Enclosing as RuleCondition; if (ruleCondition != null) { Rule rule = ruleCondition.EnclosingRule; if (EnclosingFinder <State> .find(rule) == Source) { if (rule.RuleConditions.Count == 1) { Source.StateMachine.removeRules(rule); Source = initialState; Source.StateMachine.appendRules(rule); } else { rule.removeConditions(ruleCondition); Source = initialState; Rule newRule = (Rule)acceptor.getFactory().createRule(); newRule.Name = rule.Name; newRule.appendConditions(ruleCondition); Source.StateMachine.appendRules(newRule); } } else { throw new CannotChangeRuleException("Action is not defined directly in the state"); } } } } Source = initialState; }
private void addTransitionMenuItem_Click(object sender, EventArgs e) { if (StateMachine.States.Count > 1) { DataDictionary.ObjectFactory factory = (DataDictionary.ObjectFactory)DataDictionary.Generated.acceptor.getFactory(); DataDictionary.Rules.Rule rule = (DataDictionary.Rules.Rule)factory.createRule(); rule.Name = "Rule" + (StateMachine.Rules.Count + 1); DataDictionary.Rules.RuleCondition ruleCondition = (DataDictionary.Rules.RuleCondition)factory.createRuleCondition(); ruleCondition.Name = "RuleCondition" + (rule.RuleConditions.Count + 1); rule.appendConditions(ruleCondition); DataDictionary.Rules.Action action = (DataDictionary.Rules.Action)factory.createAction(); action.Expression = "THIS <- " + ((State)StateMachine.States[1]).LiteralName; ruleCondition.appendActions(action); if (MDIWindow.DataDictionaryWindow != null) { DataDictionaryView.StateTreeNode stateNode = MDIWindow.DataDictionaryWindow.FindNode((State)StateMachine.States[0]) as DataDictionaryView.StateTreeNode; DataDictionaryView.RuleTreeNode ruleNode = stateNode.Rules.AddRule(rule); } StateContainerPanel.RefreshControl(); StateContainerPanel.Refresh(); TransitionControl control = StateContainerPanel.getTransitionControl(ruleCondition); Select(control); } }
public override RuleCondition createRuleCondition() { RuleCondition retVal = new Rules.RuleCondition(); _defaultValueSetter.SetDefaultValue(retVal); return(retVal); }
/// <summary> /// Updates (if possible) the initial state for this transition /// </summary> /// <param name="initialState"></param> public void SetInitialState(State initialState) { if (Action != null) { if (PreCondition != null) { if (PreCondition.Rule == Action.Rule) { List <State> states = DataDictionary.Types.StateMachine.GetStates(PreCondition.ExpressionTree); if (states.Count == 1) { PreCondition.ExpressionText = "THIS == " + initialState.FullName; InitialState = initialState; } else { throw new CannotChangeRuleException("More than one state in the pre condition expression"); } } else { throw new CannotChangeRuleException("Precondition is not at the same level as the action"); } } else { RuleCondition ruleCondition = Action.Enclosing as RuleCondition; Rule rule = ruleCondition.EnclosingRule; if (Utils.EnclosingFinder <Constants.State> .find(rule) == InitialState) { if (rule.RuleConditions.Count == 1) { InitialState.StateMachine.removeRules(rule); InitialState = initialState; InitialState.StateMachine.appendRules(rule); } else { rule.removeConditions(ruleCondition); InitialState = initialState; Rule newRule = (Rule)Generated.acceptor.getFactory().createRule(); newRule.Name = rule.Name; newRule.appendConditions(ruleCondition); InitialState.StateMachine.appendRules(newRule); } } else { throw new CannotChangeRuleException("Action is not defined directly in the state"); } } } InitialState = initialState; }
/// <summary> /// Take care of all conditions /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(Generated.RuleCondition obj, bool visitSubNodes) { RuleCondition ruleCondition = (RuleCondition)obj; if (ruleCondition.Uses(Target)) { Usages.Add(ruleCondition); } base.visit(obj, visitSubNodes); }
/// <summary> /// Creates a default element /// </summary> /// <param name="enclosingCollection"></param> /// <returns></returns> public static RuleCondition CreateDefault(ICollection enclosingCollection) { RuleCondition retVal = (RuleCondition)acceptor.getFactory().createRuleCondition(); Util.DontNotify(() => { retVal.Name = "RuleCondition" + GetElementNumber(enclosingCollection); }); return(retVal); }
/// <summary> /// Adds a model element in this model element /// </summary> /// <param name="element"></param> public override void AddModelElement(IModelElement element) { { RuleCondition item = element as RuleCondition; if (item != null) { appendConditions(item); } } base.AddModelElement(element); }
/// <summary> /// Duplicates this model element /// </summary> /// <returns></returns> public Rule duplicate() { Rule retVal = (Rule)acceptor.getFactory().createRule(); retVal.Name = Name; foreach (RuleCondition ruleCondition in RuleConditions) { RuleCondition newRuleCondition = ruleCondition.duplicate(); retVal.appendConditions(newRuleCondition); } return(retVal); }
/// <summary> /// Sets the update information for this rule (this rule updates source) /// </summary> /// <param name="source"></param> public override void SetUpdateInformation(ModelElement source) { base.SetUpdateInformation(source); Rule sourceRule = (Rule)source; foreach (RuleCondition ruleCondition in RuleConditions) { RuleCondition baseRuleCondition = sourceRule.FindRuleCondition(ruleCondition.Name); if (baseRuleCondition != null) { ruleCondition.SetUpdateInformation(baseRuleCondition); } } }
/// <summary> /// Creates a default element /// </summary> /// <param name="enclosingCollection"></param> /// <returns></returns> public static Rule CreateDefault(ICollection enclosingCollection) { Rule retVal = (Rule)acceptor.getFactory().createRule(); Util.DontNotify(() => { retVal.Name = "Rule" + GetElementNumber(enclosingCollection); RuleCondition condition = (RuleCondition)acceptor.getFactory().createRuleCondition(); condition.Name = "<Condition1>"; retVal.appendConditions(condition); }); return(retVal); }
/// <summary> /// Duplicates this model element /// </summary> /// <returns></returns> public RuleCondition duplicate() { RuleCondition retVal = (RuleCondition)Generated.acceptor.getFactory().createRuleCondition(); retVal.Name = Name; foreach (PreCondition preCondition in PreConditions) { PreCondition newPreCondition = preCondition.duplicate(); retVal.appendPreConditions(newPreCondition); } foreach (Action action in Actions) { Action newAction = action.duplicate(); retVal.appendActions(newAction); } return(retVal); }
/// <summary> /// Indicates whether a rule condition has been activated at a given time /// </summary> /// <param name="ruleCondition">The rule condition that should be activated</param> /// <param name="time">the time when the rule condition should be activated</param> /// <param name="variable">The variable impacted by this rule condition, if any</param> /// <returns>true if the corresponding rule condition has been activated at the time provided</returns> public bool RuleActivatedAtTime(RuleCondition ruleCondition, double time, IVariable variable) { return(EventTimeLine.RuleActivatedAtTime(ruleCondition, time, variable)); }
/// <summary> /// Constructor /// </summary> /// <param name="panel"></param> /// <param name="model"></param> public RuleConditionModelControl(ModelDiagramPanel panel, RuleCondition model) : base(panel, model) { BoxMode = BoxModeEnum.RoundedCorners; NormalColor = Color.LightBlue; }
/// <summary> /// Indicates whether a rule condition has been activated at a given time /// </summary> /// <param name="ruleCondition">The rule condition that should be activated</param> /// <param name="time">the time when the rule condition should be activated</param> /// <param name="variable">The variable impacted by this rule condition, if any</param> /// <returns>true if the corresponding rule condition has been activated at the time provided</returns> public bool RuleActivatedAtTime(DataDictionary.Rules.RuleCondition ruleCondition, double time, Variables.IVariable variable) { return(EventTimeLine.RuleActivatedAtTime(ruleCondition, time, variable)); }
/// <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="ruleCondition">The rule condition which leads to this activation</param> /// <param name="instance">The instance on which this rule condition's preconditions are evaluated to true</param> /// <param name="explanation"></param> public Activation(RuleCondition ruleCondition, IModelElement instance, ExplanationPart explanation) { RuleCondition = ruleCondition; Instance = instance; Explanation = explanation; }
/// <summary> /// Indicates whether a rule condition has been activated at the time provided /// </summary> /// <param name="ruleCondition">The rule condition that should be activated</param> /// <param name="time">the time when the rule condition should be activated</param> /// <param name="variable">The variable impacted by this rule condition, if any</param> /// <returns>True if the provided rule condition has been activated</returns> public bool RuleActivatedAtTime(RuleCondition ruleCondition, double time, IVariable variable) { bool retVal = false; if (variable != null) { foreach (ModelEvent modelEvent in Events) { RuleFired ruleFired = modelEvent as RuleFired; if (modelEvent.Time == time && ruleFired != null) { if (ruleFired.RuleCondition == ruleCondition) { retVal = ruleFired.ImpactVariable(variable); if (retVal) { break; } } } } } return retVal; }
public override RuleCondition createRuleCondition() { RuleCondition retVal = new Rules.RuleCondition(); _defaultValueSetter.SetDefaultValue(retVal); return retVal; }
public override void visit(Generated.RuleCondition obj, bool subNodes) { Rules.RuleCondition ruleCondition = obj as Rules.RuleCondition; if (ruleCondition != null) { try { bool found = false; ruleCondition.Messages.Clear(); foreach (Rules.PreCondition preCondition in ruleCondition.PreConditions) { Interpreter.BinaryExpression expression = checkExpression(preCondition, preCondition.Expression) as Interpreter.BinaryExpression; if (expression != null) { if (expression.IsSimpleEquality()) { Types.ITypedElement variable = expression.Left.Ref as Types.ITypedElement; if (variable != null) { if (variable.Type != null) { // Check that when preconditions are based on a request, // the corresponding action affects the value Request.Disabled to the same variable if (variable.Type.Name.Equals("Request") && expression.Right != null && expression.Right is Interpreter.UnaryExpression) { Values.IValue val2 = expression.Right.Ref as Values.IValue; if (val2 != null && "Response".CompareTo(val2.Name) == 0) { if (ruleCondition != null) { found = false; foreach (Rules.Action action in ruleCondition.Actions) { Variables.IVariable var = OverallVariableFinder.INSTANCE.findByName(action, preCondition.findVariable()); Interpreter.Statement.VariableUpdateStatement update = action.Modifies(var); if (update != null) { Interpreter.UnaryExpression updateExpr = update.Expression as Interpreter.UnaryExpression; if (updateExpr != null) { Values.IValue val3 = updateExpr.Ref as Values.IValue; if (val3 != null && val3.Name.CompareTo("Disabled") == 0) { found = true; break; } } } } if (!found) { preCondition.AddError("Rules where the Pre conditions is based on a Request type variable must assign that variable the value 'Request.Disabled'"); } } } } } // Check that the outgoing variables are not read if (variable.Mode == Generated.acceptor.VariableModeEnumType.aOutgoing) { if (ruleCondition.Reads(variable)) { preCondition.AddError("An outgoing variable cannot be read"); } } // Check that the incoming variables are not modified if (variable.Mode == Generated.acceptor.VariableModeEnumType.aIncoming) { if (ruleCondition.Modifies(variable) != null) { preCondition.AddError("An incoming variable cannot be written"); } } } } } } } catch (Exception exception) { ruleCondition.AddException(exception); } } base.visit(obj, subNodes); }
/// <summary> /// Indicates whether a rule condition has been activated at a given time /// </summary> /// <param name="ruleCondition">The rule condition that should be activated</param> /// <param name="time">the time when the rule condition should be activated</param> /// <param name="variable">The variable impacted by this rule condition, if any</param> /// <returns>true if the corresponding rule condition has been activated at the time provided</returns> public bool RuleActivatedAtTime(RuleCondition ruleCondition, double time, IVariable variable) { return EventTimeLine.RuleActivatedAtTime(ruleCondition, time, variable); }