/// <summary> /// Updates the step according to this translation /// </summary> /// <param name="step"></param> public void UpdateStep(Step step) { int subStepCounter = 1; foreach (SubStep subStep in SubSteps) { SubStep newSubStep = (SubStep)Generated.acceptor.getFactory().createSubStep(); newSubStep.Name = "Sub-step" + subStepCounter; step.appendSubSteps(newSubStep); foreach (Rules.Action action in subStep.Actions) { Rules.Action newAct = (Rules.Action)Generated.acceptor.getFactory().createAction(); action.copyTo(newAct); newSubStep.appendActions(newAct); Review(newAct); } foreach (Expectation expectation in subStep.Expectations) { Expectation newExp = (Expectation)Generated.acceptor.getFactory().createExpectation(); expectation.copyTo(newExp); newSubStep.appendExpectations(newExp); Review(newExp); } subStepCounter++; } }
public override void visit(Generated.Action obj, bool visitSubNodes) { Rules.Action action = (Rules.Action)obj; if (Rebuild) { action.Statement = null; } // Side effect : compiles or recompiles the statement DataDictionary.Interpreter.Statement.Statement statement = action.Statement; base.visit(obj, visitSubNodes); }
/// <summary> /// Adds a model element in this model element /// </summary> /// <param name="copy"></param> public override void AddModelElement(Utils.IModelElement element) { if (element is Rules.Action) { Rules.Action item = element as Rules.Action; if (item != null) { appendActions(item); } } else if (element is Expectation) { Tests.Expectation item = element as Tests.Expectation; if (item != null) { appendExpectations(item); } } }
/// <summary> /// Adds a transition in the transitions sets /// </summary> /// <param name="update">The update state which provides the target of the transition</param> /// <param name="target">The target state, as determined by the update statement</param> /// <param name="filteredOut"></param> /// <param name="preCondition">the precondition (if any) which is used to determine the initial state</param> /// <param name="initial">The initial state</param> /// <returns>true if the transition has been filtered out. A transition can be filtered out if the target state is equal to the initial state or the initial state is null /// </returns> private bool AddTransition(Interpreter.Statement.VariableUpdateStatement update, Constants.State target, Rules.PreCondition preCondition, Constants.State initial) { bool retVal = false; Constants.State initialState = StateMachine.StateInThisStateMachine(initial); // TargetState is the target state either in this state machine or in a sub state machine Constants.State targetState = StateMachine.StateInThisStateMachine(target); // Determine the rule condition (if any) related to this state machine Rules.RuleCondition condition = null; if (update != null) { Rules.Action action = update.Root as Rules.Action; condition = action.RuleCondition; } if (targetState != null || initialState != null) { // This transition is about this state machine. if (initialState != targetState && initialState != null) { // Check that the transition is not yet present // This case can occur when the same RuleCondition references two different states // in a substate machine. Only draws the transition once. if (!findMatchingTransition(condition, initialState, targetState)) { Transitions.Add(new Rules.Transition(preCondition, initialState, update, targetState)); } } else { if (initialState == initial) { retVal = true; } } } return(retVal); }
/// <summary> /// Review the expressions associated to this action /// </summary> /// <param name="action"></param> private void Review(Rules.Action action) { action.Expression = ReviewExpression(action.Step, action.Expression); }
/// <summary> /// Constructor /// </summary> /// <param name="action"The action which raised the variable update></param> public VariableUpdate(Rules.Action action, Utils.IModelElement instance) : base(action.Statement.ToString(), instance) { Action = action; }