public static void InitCtx(TestContext testContext)
{
var dir = AppDomain.CurrentDomain.BaseDirectory;
var file = Path.Combine(dir, "dmn/dmn1.3/parallel.dmn");
def = DmnDefinitionFactory.CreateDmnDefinition(DmnParser.Parse13(file));
}
/// <summary>
/// Creates the execution context from <paramref name="sourceDefinition"/>
/// </summary>
/// <param name="sourceDefinition">Source model definition to create the execution context for</param>
/// <param name="configure">Optional configuration action</param>
/// <typeparam name="T">Type of the execution context to be created. Must be <see cref="DmnExecutionContext"/> or its descendant</typeparam>
/// <returns><paramref name="sourceDefinition"/> execution context</returns>
/// <exception cref="ArgumentNullException"><paramref name="sourceDefinition"/> is null</exception>
public static DmnExecutionContext CreateCustomExecutionContext <T>(
DmnDefinition sourceDefinition,
Action <DmnExecutionContextOptions> configure = null)
where T : DmnExecutionContext
{
if (sourceDefinition == null)
{
throw new ArgumentNullException(nameof(sourceDefinition));
}
if (sourceDefinition.Decisions == null || sourceDefinition.Decisions.Count < 1)
{
throw new ArgumentException("No decisions in the sourceDefinition definition");
}
if (sourceDefinition.Variables == null || sourceDefinition.Variables.Count < 1)
{
throw new ArgumentException("No variables in the sourceDefinition definition");
}
//Init runtime (execution) variables
var variables = sourceDefinition
.Variables
.Values
.Select(sourceVariable => new DmnExecutionVariable(sourceVariable))
.ToDictionary(variable => variable.Name);
// Decisions reference - Dictionary of available decisions by name
var decisions = sourceDefinition
.Decisions
.ToDictionary(
sourceDecision => sourceDecision.Key,
sourceDecision => sourceDecision.Value);
return((T)Activator.CreateInstance(typeof(T), sourceDefinition, variables, decisions, configure));
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="source">Source model definition to create the execution context factory for</param>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
/// <exception cref="ArgumentException">No decisions in the source definition</exception>
/// <exception cref="ArgumentException">No variables in the source definition</exception>
protected DmnExecutionContextFactory(DmnDefinition source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (source.Decisions == null || source.Decisions.Count < 1)
{
throw new ArgumentException("No decisions in the source definition");
}
if (source.Variables == null || source.Variables.Count < 1)
{
throw new ArgumentException("No variables in the source definition");
}
//Decisions reference
foreach (var sourceDecision in source.Decisions)
{
Decisions.Add(sourceDecision.Key, sourceDecision.Value);
}
//Init runtime (execution) variables
foreach (var sourceVariable in source.Variables.Values)
{
var variable = new DmnExecutionVariable(sourceVariable);
Variables.Add(variable.Name, variable);
if (variable.IsInputParameter)
{
InputData.Add(variable.Name, variable);
}
}
}
public OpenCacheExecutionContext(DmnDefinition definition,
IReadOnlyDictionary <string, DmnExecutionVariable> variables,
IReadOnlyDictionary <string, IDmnDecision> decisions,
Action <DmnExecutionContextOptions> configure = null)
: base(definition, variables, decisions, configure)
{
}
/// <summary>
/// Creates the execution context from <paramref name="sourceDefinition"/>
/// </summary>
/// <param name="sourceDefinition">Source model definition to create the execution context for</param>
/// <returns><paramref name="sourceDefinition"/> execution context</returns>
/// <exception cref="ArgumentNullException"><paramref name="sourceDefinition"/> is null</exception>
public static DmnExecutionContext CreateExecutionContext(DmnDefinition sourceDefinition)
{
if (sourceDefinition == null)
{
throw new ArgumentNullException(nameof(sourceDefinition));
}
var factory = new DmnExecutionContextFactory(sourceDefinition);
return(new DmnExecutionContext(sourceDefinition, factory.Variables, factory.InputData, factory.Decisions));
}
private OpenCacheExecutionContext Ctx(DmnDefinition def, ParsedExpressionCacheScopeEnum?cacheType)
{
if (!cacheType.HasValue) //default
{
return((OpenCacheExecutionContext)DmnExecutionContextFactory
.CreateCustomExecutionContext <OpenCacheExecutionContext>(def));
}
return((OpenCacheExecutionContext)DmnExecutionContextFactory
.CreateCustomExecutionContext <OpenCacheExecutionContext>(
def,
o => o.ParsedExpressionCacheScope = cacheType.Value));
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="definition">DMN Model definition</param>
/// <param name="variables">Variables used while executing the DMN model</param>
/// <param name="decisions">Dictionary of available decisions by name</param>
/// <param name="configure">Optional configuration action</param>
/// <exception cref="ArgumentNullException">Any of the parameters is null</exception>
public DmnExecutionContext(
DmnDefinition definition,
IReadOnlyDictionary <string, DmnExecutionVariable> variables,
IReadOnlyDictionary <string, IDmnDecision> decisions,
Action <DmnExecutionContextOptions> configure = null)
{
Id = Guid.NewGuid().ToString();
Definition = definition ?? throw Logger.Fatal <ArgumentNullException>($"{nameof(definition)} is null");
Variables = variables ?? throw Logger.Fatal <ArgumentNullException>($"{nameof(variables)} is null");
Decisions = decisions ?? throw Logger.Fatal <ArgumentNullException>($"{nameof(decisions)} is null");
configure?.Invoke(options);
}
public static void InitCtxFileOpts2(TestContext testContext)
{
defFileOpts2 = DEF("parallel.dmn", SourceEnum.File);
}
public static void InitCtxBuilder(TestContext testContext)
{
defBuilder = DEF("parallel.dmn", DmnTestBase.SourceEnum.Builder);
}
/// <summary>
/// Creates the execution context from <paramref name="sourceDefinition"/>
/// </summary>
/// <param name="sourceDefinition">Source model definition to create the execution context for</param>
/// <param name="configure">Optional configuration action</param>
/// <returns><paramref name="sourceDefinition"/> execution context</returns>
/// <exception cref="ArgumentNullException"><paramref name="sourceDefinition"/> is null</exception>
public static DmnExecutionContext CreateExecutionContext(
DmnDefinition sourceDefinition,
Action <DmnExecutionContextOptions> configure = null)
{
return(CreateCustomExecutionContext <DmnExecutionContext>(sourceDefinition, configure));
}