/// <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>
/// Constructor
/// </summary>
/// <param name="rule"></param>
/// <param name="preCondition">The precondition which setup the initial state</param>
/// <param name="initialState">The initial stae of this transition</param>
/// <param name="update">The statement which set up the target state</param>
/// <param name="targetState">The target state of this transition</param>
public Transition(PreCondition preCondition, State initialState, Interpreter.Statement.VariableUpdateStatement update, State targetState)
{
PreCondition = preCondition;
InitialState = initialState;
Update = update;
TargetState = targetState;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="rule"></param>
/// <param name="preCondition">The precondition which setup the initial state</param>
/// <param name="initialState">The initial stae of this transition</param>
/// <param name="update">The statement which set up the target state</param>
/// <param name="targetState">The target state of this transition</param>
public Transition(PreCondition preCondition, State initialState, Interpreter.Statement.VariableUpdateStatement update, State targetState)
{
PreCondition = preCondition;
InitialState = initialState;
Update = update;
TargetState = targetState;
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(IModelElement element)
{
{
PreCondition item = element as PreCondition;
if (item != null)
{
appendPreConditions(item);
}
}
{
Action item = element as Action;
if (item != null)
{
appendActions(item);
}
}
{
Rule item = element as Rule;
if (item != null)
{
appendSubRules(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="preCondition">The precondition which setup the initial state</param>
/// <param name="initialState">The initial stae of this transition</param>
/// <param name="update">The statement which set up the target state</param>
/// <param name="targetState">The target state of this transition</param>
public Transition(PreCondition preCondition, State initialState, VariableUpdateStatement update,
State targetState)
{
PreCondition = preCondition;
Source = initialState;
Update = update;
Target = targetState;
}
public override PreCondition createPreCondition()
{
PreCondition retVal = new Rules.PreCondition();
_defaultValueSetter.SetDefaultValue(retVal);
return(retVal);
}
/// <summary>
/// Duplicates this model element
/// </summary>
/// <returns></returns>
public PreCondition duplicate()
{
PreCondition retVal = (PreCondition)acceptor.getFactory().createPreCondition();
retVal.Name = Name;
retVal.ExpressionText = ExpressionText;
return(retVal);
}
/// <summary>
/// Creates a default element
/// </summary>
/// <param name="enclosingCollection"></param>
/// <returns></returns>
public static PreCondition CreateDefault(ICollection enclosingCollection)
{
PreCondition retVal = (PreCondition)acceptor.getFactory().createPreCondition();
Util.DontNotify(() =>
{
retVal.Name = "PreCondition" + GetElementNumber(enclosingCollection);
retVal.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>
/// 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(VariableUpdateStatement update, State target, PreCondition preCondition,
State initial)
{
bool retVal = false;
if (SameParentStateMachine(initial, target))
{
State initialState = StateMachine.StateInThisStateMachine(initial);
// TargetState is the target state either in this state machine or in a sub state machine
State targetState = StateMachine.StateInThisStateMachine(target);
// Determine the rule condition (if any) related to this state machine
Rules.RuleCondition condition = null;
if (update != null)
{
Action action = update.Root as 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 Transition(preCondition, initialState, update, targetState));
}
}
else
{
if (initialState == initial)
{
retVal = true;
}
}
}
}
return(retVal);
}
public override void visit(Generated.PreCondition obj, bool subNodes)
{
Rules.PreCondition preCondition = obj as Rules.PreCondition;
if (preCondition != null)
{
try
{
// Check whether the expression is valid
Interpreter.Expression expression = checkExpression(preCondition, preCondition.Condition);
if (!preCondition.Dictionary.EFSSystem.BoolType.Match(expression.GetExpressionType()))
{
preCondition.AddError("Expression type should be Boolean");
}
Types.ITypedElement element = OverallTypedElementFinder.INSTANCE.findByName(preCondition, preCondition.findVariable());
if (element != null)
{
if (element.Type is Types.StateMachine)
{
if (preCondition.findOperator() != null)
{
if (preCondition.findOperator().CompareTo("==") == 0)
{
preCondition.AddWarning("Operator == should not be used for state machines");
}
else if (preCondition.findOperator().CompareTo("!=") == 0)
{
preCondition.AddWarning("Operator != should not be used for state machines");
}
}
}
}
}
catch (Exception exception)
{
preCondition.AddException(exception);
}
}
base.visit(obj, subNodes);
}
/// <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(VariableUpdateStatement update, State target, PreCondition preCondition,
State initial)
{
bool retVal = false;
if (SameParentStateMachine(initial, target))
{
State initialState = StateMachine.StateInThisStateMachine(initial);
// TargetState is the target state either in this state machine or in a sub state machine
State targetState = StateMachine.StateInThisStateMachine(target);
// Determine the rule condition (if any) related to this state machine
Rules.RuleCondition condition = null;
if (update != null)
{
Action action = update.Root as 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 Transition(preCondition, initialState, update, targetState));
}
}
else
{
if (initialState == initial)
{
retVal = true;
}
}
}
}
return retVal;
}
public override PreCondition createPreCondition()
{
PreCondition retVal = new Rules.PreCondition();
_defaultValueSetter.SetDefaultValue(retVal);
return retVal;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="panel"></param>
/// <param name="model"></param>
public PreConditionModelControl(ModelDiagramPanel panel, PreCondition model)
: base(panel, model)
{
}
