/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
StructureElement item = element as StructureElement;
if (item != null)
{
appendElements(item);
}
}
{
Procedure item = element as Procedure;
if (item != null)
{
appendProcedures(item);
}
}
{
Rules.Rule item = element as Rules.Rule;
if (item != null)
{
appendRules(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Add actions when leaving a state
/// </summary>
/// <param name="priority"></param>
/// <param name="updates"></param>
/// <param name="variable"></param>
/// <param name="leaveState"></param>
/// <param name="enterState"></param>
private void HandleLeaveState(acceptor.RulePriority?priority, List <VariableUpdate> updates, IVariable variable,
State leaveState, State enterState)
{
if (!_processedStates.Contains(leaveState))
{
_processedStates.Add(leaveState);
if (!leaveState.getStateMachine().Contains(leaveState, enterState))
{
if (leaveState.getLeaveAction() != null)
{
Rules.Rule rule = (Rules.Rule)leaveState.getLeaveAction();
ExplanationPart explanation = new ExplanationPart(rule, "Rule evaluation");
HashSet <Activation> newActivations = new HashSet <Activation>();
List <VariableUpdate> newUpdates = new List <VariableUpdate>();
// the priority is not specified for the rule evaluation since
// the rules of the leave states have to be executed regardless the priority
rule.Evaluate(this, null, variable, newActivations, explanation);
EvaluateActivations(newActivations, priority, newUpdates);
updates.AddRange(newUpdates);
}
if (leaveState.EnclosingState != null)
{
HandleLeaveState(priority, updates, variable, leaveState.EnclosingState, enterState);
}
}
_processedStates.Remove(leaveState);
}
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Range item = element as Range;
if (item != null)
{
appendRanges(item);
}
}
{
Enum item = element as Enum;
if (item != null)
{
appendEnumerations(item);
}
}
{
Structure item = element as Structure;
if (item != null)
{
appendStructures(item);
}
}
{
Collection item = element as Collection;
if (item != null)
{
appendCollections(item);
}
}
{
Functions.Function item = element as Functions.Function;
if (item != null)
{
appendFunctions(item);
}
}
{
Functions.Procedure item = element as Functions.Procedure;
if (item != null)
{
appendProcedures(item);
}
}
{
Rules.Rule item = element as Rules.Rule;
if (item != null)
{
appendRules(item);
}
}
{
Variables.Variable item = element as Variables.Variable;
if (item != null)
{
appendVariables(item);
}
}
}
/// <summary>
/// Indicates which rules are not active
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(Generated.Rule obj, bool visitSubNodes)
{
Rules.Rule rule = obj as Rule;
if (rule != null)
{
rule.ActivationPriorities = null;
}
base.visit(obj, visitSubNodes);
}
public override void visit(Rule obj, bool visitSubNodes)
{
Rules.Rule rule = obj as Rules.Rule;
if (rule != null)
{
rule.ExecutionCount = 0;
rule.ExecutionTimeInMilli = 0L;
}
base.visit(obj, visitSubNodes);
}
private Rules.RuleModule.RuleModule CreateRuleModule(Rules.Rule rule)
{
var ruleModule = new Rules.RuleModule.RuleModule
{
Name = "Test rule module",
Rules = new HashSet <IRuleCompilable>
{
rule
}
};
var id = this.RuleModuleService.CreateAsync(ruleModule).Result;
var createdRuleModule = this.RuleModuleService.InquireAsync(id).Result;
return(createdRuleModule);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Parameter item = element as Parameter;
if (item != null)
{
appendParameters(item);
}
}
{
Rules.Rule item = element as Rules.Rule;
if (item != null)
{
appendRules(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(Utils.IModelElement element)
{
{
Constants.State item = element as Constants.State;
if (item != null)
{
appendStates(item);
}
}
{
Rules.Rule item = element as Rules.Rule;
if (item != null)
{
appendRules(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Applies a rule defined in a procedure
/// </summary>
/// <param name="rule"></param>
/// <param name="changes"></param>
/// <param name="ctxt"></param>
private void ApplyRule(Rules.Rule rule, ChangeList changes, InterpretationContext ctxt, ExplanationPart explanation)
{
foreach (Rules.RuleCondition condition in rule.RuleConditions)
{
if (condition.EvaluatePreConditions(ctxt))
{
foreach (Rules.Action action in condition.Actions)
{
action.GetChanges(ctxt, changes, explanation, true);
}
foreach (Rules.Rule subRule in condition.SubRules)
{
ApplyRule(subRule, changes, ctxt, explanation);
}
break;
}
}
}
private Rules.Rule CreateRule()
{
var rand = new System.Random();
var rule = new Rules.Rule
{
Name = "Test rule",
SaveArguments = Enumerable.Range(0, 5)
.Select(index => new Rules.RuleArgument
{
Position = rand.Next(0, 100),
SaveValue = new string[] { "Alabama1", "Alabama2" },
ValueType = typeof(string).FullName
})
.ToList(),
RuleType = RuleType.Boolean,
Expression = "Order.TrackingNumber.IsInList(@0)"
};
return(rule);
}
/// <summary>
/// Instanciates this state machine for the instanciation of a StructureProcedure into a Procedure
/// </summary>
/// <returns></returns>
public StateMachine instanciate()
{
StateMachine retVal = (StateMachine)Generated.acceptor.getFactory().createStateMachine();
retVal.Name = Name;
retVal.setFather(getFather());
retVal.InitialState = InitialState;
foreach (Constants.State state in States)
{
Constants.State newState = state.duplicate();
retVal.appendStates(newState);
}
foreach (Rules.Rule rule in Rules)
{
Rules.Rule newRule = rule.duplicate();
retVal.appendRules(newRule);
}
return(retVal);
}
public override Generated.Rule createRule()
{
Rules.Rule retVal = new Rules.Rule();
retVal.setPriority(Generated.acceptor.RulePriority.aProcessing);
return retVal;
}
public override Generated.Rule createRule()
{
Rules.Rule retVal = new Rules.Rule();
retVal.setPriority(Generated.acceptor.RulePriority.aProcessing);
return(retVal);
}
