public object Execute(VariableContext context = null)
{
var funcName = _function.Execute(context);
if (funcName is Variable outFuncVar && outFuncVar.ValueType == DataTypeEnum.Function)
{
if (_parameters is PositionalParameters)
{
var lVars = RetrieveListOfParameters(context);
return(outFuncVar.UserFunction.Execute(lVars, context));
}
if (_parameters is NamedParameters nParams)
{
return(outFuncVar.UserFunction.Execute(null, context, nParams));
}
}
if (funcName is Variable outFuncName && outFuncName.ValueType == DataTypeEnum.String)
{
List <Variable> lVars = new List <Variable> ();
if (_parameters is PositionalParameters)
{
lVars = RetrieveListOfParameters(context);
if (VariableContextHelper.RetrieveBkm(outFuncName, context, out var bkmMeta))
{
return(DMNDoerHelper.EvalBkm(bkmMeta.BKMModel, context, lVars));
}
if (context.DecisionServiceMetaByName.TryGetValue(outFuncName, out var decisionService))
{
return(DMNDoerHelper.EvalDecisionService(decisionService, context, lVars));
}
}
if (_parameters is NamedParameters namedParam)
{
if (VariableContextHelper.RetrieveBkm(outFuncName, context, out var bkmMeta))
{
lVars = BKMConvertNamedParameter(namedParam, bkmMeta.BKMModel, context);
return(DMNDoerHelper.EvalBkm(bkmMeta.BKMModel, context, lVars));
}
if (context.DecisionServiceMetaByName.TryGetValue(outFuncName, out var decisionService))
{
lVars = DecisionServiceConvertNamedParameter(namedParam, decisionService, context);
return(DMNDoerHelper.EvalDecisionService(decisionService, context, lVars));
}
}
var funcMeta = BuiltInFactory.GetFunc(outFuncName);
if (_parameters is NamedParameters nParam)
{
lVars = BuiltInFactory.ConvertNamedParameter(nParam, funcMeta.Item2, context);
}
return(funcMeta.Item1.Execute(lVars));
}
throw new FEELException("Function name is not a variable of string type");
}
public Variable Execute(List <Variable> inputParams, VariableContext mainContext, NamedParameters nParams = null)
{
if (_isExternal)
{
//TODO: add error logging for no support for external java/PMML function types
return(new Variable());
}
var context = mainContext ?? new VariableContext();
if (nParams != null)
{
inputParams = BuiltInFactory.ConvertNamedParameter(nParams, _formalParams.Select(v => v.TwoTuple.a.StringVal).ToArray(), context);
}
if (inputParams != null && _formalParams.Count > 0)
{
if (_formalParams.Count != inputParams.Count)
{
//TODO: Add to error logging for missmatch expected input
return(new Variable());
}
for (int i = _formalParams.Count - 1; i >= 0; i--)
{
context.AddToFunctionInputs(_formalParams[i].TwoTuple.a.StringVal, inputParams[i]);
}
}
try {
return((Variable)_body.Execute(context));
} catch (Exception) {
return(new Variable());
}
}
public void ConvertNamedParameters_Failed()
{
var funcMeta = BuiltInFactory.GetFunc(NotFunc.FuncName);
var namedP = new NamedParameters(null);
var err = Assert.Throws <FEELException> (() => BuiltInFactory.ConvertNamedParameter(namedP, funcMeta.Item2, null));
Assert.Equal("Failed coverting named parameters", err.Message);
}
public void Function_Found()
{
var lVars = new List <Variable> ();
lVars.Add(true);
var funcMeta = BuiltInFactory.GetFunc(NotFunc.FuncName);
var boolVar = funcMeta.Item1.Execute(lVars);
Assert.False(boolVar);
}
public void ConvertNamedParameters_Names_Matched()
{
var funcMeta = BuiltInFactory.GetFunc(NotFunc.FuncName);
var nParamDict = new Dictionary <string, IExpression> ()
{
{ "negand", new BooleanLiteral("true") }
};
var namedP = new NamedParameters(nParamDict);
var lParams = BuiltInFactory.ConvertNamedParameter(namedP, funcMeta.Item2, null);
var boolVar = funcMeta.Item1.Execute(lParams);
Assert.False(boolVar);
}
public void Function_NotFound_Error()
{
Assert.Throws <FEELException> (() => BuiltInFactory.GetFunc("x"));
}
