protected internal virtual DmnDecisionTableImpl TransformDecisionTable(IDecisionTable decisionTable)
{
var handler =
handlerRegistry.getHandler <IDecisionTable, DmnDecisionTableImpl>(typeof(IDecisionTable));
var dmnDecisionTable = handler.HandleElement(this, decisionTable);
//TODO Input异常
foreach (var input in decisionTable.Inputs)
{
parent = dmnDecisionTable;
this.decisionTable = dmnDecisionTable;
//TODO actualNsToAlternative[actualNs]异常
var dmnInput = TransformDecisionTableInput(input);
if (dmnInput != null)
{
dmnDecisionTable.Inputs.Add(dmnInput);
NotifyTransformListeners(input, dmnInput);
}
}
//TODO OutPut异常
var needsName = decisionTable.Outputs.Count > 1;
ISet <string> usedNames = new HashSet <string>();
foreach (var output in decisionTable.Outputs)
{
parent = dmnDecisionTable;
this.decisionTable = dmnDecisionTable;
var dmnOutput = TransformDecisionTableOutput(output);
if (dmnOutput != null)
{
// validate output name
var outputName = dmnOutput.OutputName;
if (needsName && ReferenceEquals(outputName, null))
{
throw LOG.CompoundOutputsShouldHaveAnOutputName(dmnDecisionTable, dmnOutput);
}
if (usedNames.Contains(outputName))
{
throw LOG.CompoundOutputWithDuplicateName(dmnDecisionTable, dmnOutput);
}
usedNames.Add(outputName);
dmnDecisionTable.Outputs.Add(dmnOutput);
NotifyTransformListeners(output, dmnOutput);
}
}
foreach (var rule in decisionTable.Rules)
{
parent = dmnDecisionTable;
this.decisionTable = dmnDecisionTable;
var dmnRule = TransformDecisionTableRule(rule);
if (dmnRule != null)
{
dmnDecisionTable.Rules.Add(dmnRule);
NotifyTransformListeners(rule, dmnRule);
}
}
return(dmnDecisionTable);
}
public virtual DmnTransformException CompoundOutputWithDuplicateName(DmnDecisionTableImpl dmnDecisionTable,
DmnDecisionTableOutputImpl dmnOutput)
{
return
(new DmnTransformException(ExceptionMessage("009",
string.Format(
"The decision table '{0}' has a compound output but name of output '{1}' is duplicate.",
dmnDecisionTable, dmnOutput))));
}
public virtual DmnTransformException CompoundOutputsShouldHaveAnOutputName(
DmnDecisionTableImpl dmnDecisionTable, DmnDecisionTableOutputImpl dmnOutput)
{
return
(new DmnTransformException(ExceptionMessage("008",
string.Format(
"The decision table '{0}' has a compound output but output '{1}' does not have an output name.",
dmnDecisionTable, dmnOutput))));
}
protected internal virtual void SetEvaluationOutput(DmnDecisionTableImpl decisionTable,
IList <DmnDecisionTableRuleImpl> matchingRules, IVariableContext variableContext,
DmnDecisionTableEvaluationEventImpl evaluationResult)
{
var decisionTableOutputs = decisionTable.Outputs;
IList <IDmnEvaluatedDecisionRule> evaluatedDecisionRules = new List <IDmnEvaluatedDecisionRule>();
foreach (var matchingRule in matchingRules)
{
var evaluatedRule = EvaluateMatchingRule(decisionTableOutputs, matchingRule, variableContext);
evaluatedDecisionRules.Add(evaluatedRule);
}
evaluationResult.MatchingRules = evaluatedDecisionRules;
}
public virtual DmnTransformException HitPolicyNotSupported(DmnDecisionTableImpl decisionTable,
HitPolicy hitPolicy, BuiltinAggregator aggregation)
{
if (aggregation == null)
{
return
(new DmnTransformException(ExceptionMessage("007",
string.Format("The hit policy '{0}' of decision table '{1}' is not supported.", hitPolicy,
decisionTable))));
}
return
(new DmnTransformException(ExceptionMessage("007",
string.Format(
"The hit policy '{0}' with aggregation '{1}' of decision table '{2}' is not supported.",
hitPolicy,
aggregation, decisionTable))));
}
protected internal virtual void EvaluateDecisionTable(DmnDecisionTableImpl decisionTable,
IVariableContext variableContext, DmnDecisionTableEvaluationEventImpl evaluationResult)
{
var inputSize = decisionTable.Inputs.Count;
IList <DmnDecisionTableRuleImpl> matchingRules = new List <DmnDecisionTableRuleImpl>(decisionTable.Rules);
for (var inputIdx = 0; inputIdx < inputSize; inputIdx++)
{
// evaluate input
var input = decisionTable.Inputs[inputIdx];
var evaluatedInput = EvaluateInput(input, variableContext);
evaluationResult.Inputs.Add(evaluatedInput);
// compose local variable context out of global variable context enhanced with the value of the current input.
var localVariableContext = GetLocalVariableContext(input, evaluatedInput, variableContext);
// filter rules applicable with this input
matchingRules = EvaluateInputForAvailableRules(inputIdx, input, matchingRules, localVariableContext);
}
SetEvaluationOutput(decisionTable, matchingRules, variableContext, evaluationResult);
}
protected internal virtual long CalculateExecutedDecisionElements(DmnDecisionTableImpl decisionTable)
{
return((decisionTable.Inputs.Count + decisionTable.Outputs.Count) * decisionTable.Rules.Count);
}
