/// <summary>
/// Determines the set of rules in a specific namespace to be applied.
/// </summary>
/// <param name="priority">The priority for which this activation is requested</param>
/// <param name="activations">The set of activations to be filled</param>
/// <param name="nameSpace">The namespace to consider</param>
/// <returns></returns>
private void SetupNameSpaceActivations(Generated.acceptor.RulePriority priority, HashSet <Activation> activations, Types.NameSpace nameSpace)
{
// Finds all activations in sub namespaces
foreach (Types.NameSpace subNameSpace in nameSpace.SubNameSpaces)
{
SetupNameSpaceActivations(priority, activations, subNameSpace);
}
List <Rules.RuleCondition> rules = new List <Rules.RuleCondition>();
foreach (Rule rule in nameSpace.Rules)
{
rules.Clear();
rule.Evaluate(this, priority, rule, rules);
Activation.RegisterRules(activations, rules, nameSpace);
}
foreach (Functions.Procedure procedure in nameSpace.Procedures)
{
rules.Clear();
Activation.RegisterRules(activations, rules, procedure);
}
foreach (Variables.IVariable variable in nameSpace.Variables)
{
EvaluateVariable(priority, activations, variable);
}
}
/// <summary>
/// Evaluates the rule and its sub rules
/// </summary>
/// <param name="runner"></param>
/// <param name="priority">the priority level : a rule can be activated only if its priority level == priority</param>
/// <param name="instance">The instance on which the rule must be evaluated</param>
/// <param name="ruleConditions">the rule conditions to be activated</param>
/// <returns>the number of actions that were activated during this evaluation</returns>
public bool Evaluate(Tests.Runner.Runner runner, Generated.acceptor.RulePriority priority, Utils.IModelElement instance, List <RuleCondition> ruleConditions)
{
bool retVal = false;
long start = System.Environment.TickCount;
if (Disabled == false && ActivationPriorities.Contains(priority))
{
foreach (RuleCondition ruleCondition in RuleConditions)
{
retVal = ruleCondition.Evaluate(runner, priority, instance, ruleConditions);
if (retVal)
{
break;
}
}
}
// Guard evaluation execution time
long stop = System.Environment.TickCount;
long span = (stop - start);
ExecutionTimeInMilli += span;
return(retVal);
}
/// <summary>
/// Evaluates the rules associated to a single variable
/// </summary>
/// <param name="priority"></param>
/// <param name="activations"></param>
/// <param name="variable"></param>
private void EvaluateVariable(Generated.acceptor.RulePriority priority, HashSet <Activation> activations, Variables.IVariable variable)
{
if (variable != null)
{
if (variable.Type is Types.Structure)
{
List <Rules.RuleCondition> rules = new List <RuleCondition>();
Types.Structure structure = variable.Type as Types.Structure;
foreach (Rule rule in structure.Rules)
{
rule.Evaluate(this, priority, variable, rules);
}
Activation.RegisterRules(activations, rules, variable);
StructureValue value = variable.Value as StructureValue;
if (value != null)
{
foreach (Variables.IVariable subVariable in value.SubVariables.Values)
{
EvaluateVariable(priority, activations, subVariable);
}
}
}
else if (variable.Type is Types.StateMachine)
{
List <Rules.RuleCondition> rules = new List <RuleCondition>();
EvaluateStateMachine(rules, priority, variable);
Activation.RegisterRules(activations, rules, variable);
}
else if (variable.Type is Types.Collection)
{
Types.Collection collectionType = variable.Type as Types.Collection;
if (variable.Value != EFSSystem.EmptyValue)
{
ListValue val = variable.Value as ListValue;
int i = 1;
foreach (IValue subVal in val.Val)
{
Variables.Variable tmp = new Variables.Variable();
tmp.Name = variable.Name + '[' + i + ']';
tmp.Type = collectionType.Type;
tmp.Value = subVal;
EvaluateVariable(priority, activations, tmp);
i = i + 1;
}
}
}
}
}
/// <summary>
/// Try to find a rule, in this state machine, or in a sub state machine
/// which
/// </summary>
/// <param name="ruleConditions"></param>
/// <param name="priority"></param>
/// <param name="currentStateVariable">The variable which holds the current state of the procedure</param>
private void EvaluateStateMachine(List <Rules.RuleCondition> ruleConditions, Generated.acceptor.RulePriority priority, Variables.IVariable currentStateVariable)
{
if (currentStateVariable != null)
{
Constants.State currentState = currentStateVariable.Value as Constants.State;
Types.StateMachine currentStateMachine = currentState.StateMachine;
while (currentStateMachine != null)
{
foreach (Rule rule in currentStateMachine.Rules)
{
rule.Evaluate(this, priority, currentStateVariable, ruleConditions);
}
currentStateMachine = currentStateMachine.EnclosingStateMachine;
}
}
}
/// <summary>
/// Evaluates the rule and its sub rules
/// </summary>
/// <param name="runner"></param>
/// <param name="priority">the priority level : a rule can be activated only if its priority level == priority</param>
/// <param name="instance">The instance on which the rule must be evaluated</param>
/// <param name="ruleConditions">the rule conditions to be activated</param>
/// <returns>the number of actions that were activated during this evaluation</returns>
public bool Evaluate(Tests.Runner.Runner runner, Generated.acceptor.RulePriority priority, Utils.IModelElement instance, List <RuleCondition> ruleConditions)
{
bool retVal = false;
Interpreter.InterpretationContext context = new Interpreter.InterpretationContext(instance);
retVal = EvaluatePreConditions(context);
if (retVal)
{
foreach (Rule subRule in SubRules)
{
subRule.Evaluate(runner, priority, instance, ruleConditions);
}
if (EnclosingRule.getPriority() == priority)
{
ruleConditions.Add(this);
}
}
return(retVal);
}
