public Compiler(ConditionExpressionEvaluator conditionExpressionEvaluator, InExpressionEvaluator inExpressionEvaluator, ObjectMemberExpressionEvaluator objectMemberExpressionEvaluator, FunctionEvaluator functionEvaluator)
{
this.conditionExpressionEvaluator = conditionExpressionEvaluator;
this.inExpressionEvaluator = inExpressionEvaluator;
this.objectMemberExpressionEvaluator = objectMemberExpressionEvaluator;
this.functionEvaluator = functionEvaluator;
}
static string DoCalcution(string warewolfAtomToString)
{
string cleanExpression;
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(warewolfAtomToString, out cleanExpression);
if (isCalcEvaluation)
{
var functionEvaluator = new FunctionEvaluator();
string eval;
string error;
var tryEvaluateFunction = functionEvaluator.TryEvaluateFunction(cleanExpression, out eval, out error);
warewolfAtomToString = eval;
if (eval == cleanExpression.Replace("\"", "") && cleanExpression.Contains("\""))
{
try
{
string eval2;
var b = functionEvaluator.TryEvaluateFunction(cleanExpression.Replace("\"", ""), out eval2, out error);
if (b)
{
warewolfAtomToString = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Log.Warn(err);
}
}
if (!tryEvaluateFunction)
{
throw new Exception(error);
}
}
return(warewolfAtomToString);
}
static string PerformCalcForAtom(DataStorage.WarewolfAtom warewolfAtom, FunctionEvaluator functionEvaluator)
{
var calcExpression = ExecutionEnvironment.WarewolfAtomToString(warewolfAtom);
DataListUtil.IsCalcEvaluation(calcExpression, out string exp);
var res = functionEvaluator.TryEvaluateFunction(exp, out string eval, out string error);
if (eval == exp.Replace("\"", "") && exp.Contains("\""))
{
try
{
var b = functionEvaluator.TryEvaluateFunction(exp.Replace("\"", ""), out string eval2, out error);
if (b)
{
eval = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Warn(err, "Warewolf Warn");
}
}
if (!res)
{
throw new Exception(ErrorResource.InvalidCalculate);
}
return(eval);
}
string DoCalcution(string argWarewolfAtomToString)
{
if (argWarewolfAtomToString == null)
{
return(null);
}
var warewolfAtomToString = argWarewolfAtomToString;
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(warewolfAtomToString, out string cleanExpression);
if (isCalcEvaluation)
{
var functionEvaluator = new FunctionEvaluator(_functionEvaluatorOption);
var tryEvaluateFunction = functionEvaluator.TryEvaluateFunction(cleanExpression, out string eval, out string error);
warewolfAtomToString = eval;
if (eval == cleanExpression.Replace("\"", "") && cleanExpression.Contains("\""))
{
TryEvalAsFunction(ref warewolfAtomToString, cleanExpression, functionEvaluator, ref error);
}
if (!tryEvaluateFunction)
{
if (error == ErrorResource.IncorrectOperandType)
{
error += string.Format("Unable to calculate: '{0}'. Try rewriting the expression.", cleanExpression);
}
throw new Exception(error);
}
}
return(warewolfAtomToString);
}
public IMember Call(IArgumentSet args, IPythonType self)
{
if (!_fromAnnotation)
{
// First try supplied specialization callback.
var rt = _returnValueProvider?.Invoke(args.Eval?.Module, this, args, default);
if (!rt.IsUnknown())
{
return(rt);
}
if (StaticReturnValue == null && !string.IsNullOrEmpty(_returnDocumentation) && FunctionDefinition?.ReturnAnnotation != null)
{
// There is return documentation but no static return value.
// This may happen if function is inside module circular
// dependency loop. Try and re-evaluate now.
var returnValue = FunctionEvaluator.GetReturnValueFromAnnotation(args.Eval as ExpressionEval, FunctionDefinition.ReturnAnnotation);
if (returnValue != null)
{
SetReturnValue(returnValue, true);
return(returnValue);
}
}
}
return(GetSpecificReturnType(self as IPythonClassType, args));
}
private void DoCalculation(IExecutionEnvironment environment, string fieldName, string cleanExpression, int update)
{
var functionEvaluator = new FunctionEvaluator();
var warewolfEvalResult = environment.Eval(cleanExpression, update);
if (warewolfEvalResult.IsWarewolfAtomResult)
{
var result = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (result != null)
{
var eval = PerformCalcForAtom(result.Item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update);
}
}
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var result = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (result != null)
{
var counter = 1;
foreach (var item in result.Item)
{
var eval = PerformCalcForAtom(item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update == 0 ? counter : update);
counter++;
}
}
}
}
public void TryEvaluateAtomicFunction_InvalidFunction_Expected_EvaluatioReturnsCorrectResult()
{
string expression = @"abcdefg";
string result = string.Empty;
string error = string.Empty;
bool hasSucceeded = new FunctionEvaluator().TryEvaluateAtomicFunction(expression, out result, out error);
Assert.IsTrue(!string.IsNullOrEmpty(error));
}
AssignValue DoCalculation(IExecutionEnvironment environment, string fieldName, string cleanExpression)
{
var functionEvaluator = new FunctionEvaluator();
var warewolfEvalResult = environment.Eval(cleanExpression);
if (warewolfEvalResult.IsWarewolfAtomResult)
{
var result = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (result != null)
{
var calcExpression = ExecutionEnvironment.WarewolfAtomToString(result.Item);
string exp;
DataListUtil.IsCalcEvaluation(calcExpression, out exp);
string eval;
string error;
var res = functionEvaluator.TryEvaluateFunction(exp, out eval, out error);
if (eval == exp.Replace("\"", "") && exp.Contains("\""))
{
try
{
string eval2;
var b = functionEvaluator.TryEvaluateFunction(exp.Replace("\"", ""), out eval2, out error);
if (b)
{
eval = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Log.Warn(err);
}
}
if (!res)
{
throw new Exception("Invalid Calculate");
}
return(new AssignValue(fieldName, eval));
}
}
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var result = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult;
if (result != null)
{
}
}
return(null);
}
public void TryEvaluateAtomicFunction_ComplexCalculation_Expected_EvaluatioReturnsCorrectResult()
{
string expression = @"Sum(Average(Abs(-100), Min(10,20,2,30,200)), Max(200,300,400)) + 250";
string result = string.Empty;
string error = string.Empty;
bool hasSucceeded = new FunctionEvaluator().TryEvaluateAtomicFunction(expression, out result, out error);
if (hasSucceeded)
{
Assert.AreEqual("701", result);
}
else
{
Assert.Fail("Oct2Dec did not evaluate correctly");
}
}
public void TryEvaluateFunction_DateFunction_Expected_EvaluationOfDateCorrect_DotnetFormat()
{
var date = new DateTime(2012, 2, 2);
const string expression = @"Date(2012,2,2)";
var expected = date.ToString(GlobalConstants.Dev2DotNetDefaultDateTimeFormat);
var eval = new FunctionEvaluator(Common.Interfaces.Diagnostics.Debug.FunctionEvaluatorOption.DotNetDateTimeFormat);
var hasSucceeded = eval.TryEvaluateFunction(expression, out string actual, out string error);
if (hasSucceeded)
{
Assert.IsTrue(actual.StartsWith(expected));
}
else
{
Assert.Fail("Date Calculation not being performed as expected");
}
}
static string DoCalcution(string warewolfAtomToString)
{
if (warewolfAtomToString == null)
{
return(null);
}
string cleanExpression;
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(warewolfAtomToString, out cleanExpression);
if (isCalcEvaluation)
{
var functionEvaluator = new FunctionEvaluator();
string eval;
string error;
var tryEvaluateFunction = functionEvaluator.TryEvaluateFunction(cleanExpression, out eval, out error);
warewolfAtomToString = eval;
if (eval == cleanExpression.Replace("\"", "") && cleanExpression.Contains("\""))
{
try
{
string eval2;
var b = functionEvaluator.TryEvaluateFunction(cleanExpression.Replace("\"", ""), out eval2, out error);
if (b)
{
warewolfAtomToString = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Warn(err);
}
}
if (!tryEvaluateFunction)
{
if (error == ErrorResource.IncorrectOperandType)
{
error += string.Format("Unable to calculate: '{0}'. Try rewriting the expression.", cleanExpression);
}
throw new Exception(error);
}
}
return(warewolfAtomToString);
}
void DoCalculation(IExecutionEnvironment environment, string fieldName, string cleanExpression, int update)
{
var functionEvaluator = new FunctionEvaluator(FunctionEvaluatorOption.DotNetDateTimeFormat);
var warewolfEvalResult = environment.Eval(cleanExpression, update);
if (warewolfEvalResult.IsWarewolfAtomResult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult atomResult)
{
var eval = PerformCalcForAtom(atomResult.Item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update);
}
if (warewolfEvalResult.IsWarewolfAtomListresult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult atomListResult)
{
var counter = 1;
foreach (var item in atomListResult.Item)
{
var eval = PerformCalcForAtom(item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update == 0 ? counter : update);
counter++;
}
}
}
/// <summary>
/// Adds a function to the composer.
/// </summary>
/// <typeparam name="T">The type of elements the resulting formatter will support.</typeparam>
/// <param name="composer">The <see cref="IFormatterComposer{T}"/> being extended.</param>
/// <param name="name">The name of the function.</param>
/// <param name="evaluator">The method used to evaluate the function.</param>
/// <returns>A <see cref="IFunctionComposer{T}"/> for further configuration.</returns>
public static IFunctionComposer <T> WithFunction <T>(this IFormatterComposer <T> composer, string name, FunctionEvaluator <T> evaluator)
{
return(composer.With(new Function <T>(name, evaluator)));
}
static string DoCalcution(string warewolfAtomToString)
{
string cleanExpression;
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(warewolfAtomToString, out cleanExpression);
if(isCalcEvaluation)
{
var functionEvaluator = new FunctionEvaluator();
string eval;
string error;
var tryEvaluateFunction = functionEvaluator.TryEvaluateFunction(cleanExpression, out eval, out error);
warewolfAtomToString = eval;
if (eval == cleanExpression.Replace("\"", "") && cleanExpression.Contains("\""))
{
try
{
string eval2;
var b = functionEvaluator.TryEvaluateFunction(cleanExpression.Replace("\"", ""), out eval2, out error);
if (b)
{
warewolfAtomToString = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Log.Warn(err);
}
}
if (!tryEvaluateFunction)
{
throw new Exception(error);
}
}
return warewolfAtomToString;
}
static string DoCalcution(string warewolfAtomToString)
{
if(warewolfAtomToString == null)
{
return null;
}
string cleanExpression;
var isCalcEvaluation = DataListUtil.IsCalcEvaluation(warewolfAtomToString, out cleanExpression);
if (isCalcEvaluation)
{
var functionEvaluator = new FunctionEvaluator();
string eval;
string error;
var tryEvaluateFunction = functionEvaluator.TryEvaluateFunction(cleanExpression, out eval, out error);
warewolfAtomToString = eval;
if (eval == cleanExpression.Replace("\"", "") && cleanExpression.Contains("\""))
{
try
{
string eval2;
var b = functionEvaluator.TryEvaluateFunction(cleanExpression.Replace("\"", ""), out eval2, out error);
if (b)
{
warewolfAtomToString = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Log.Warn(err);
}
}
if (!tryEvaluateFunction)
{
if (error == "Incorrect type of argument or operand.")
error += string.Format(" Unable to calculate: '{0}'. Try rewriting the expression.", cleanExpression);
throw new Exception(error);
}
}
return warewolfAtomToString;
}
public void TryEvaluateAtomicFunction_InvalidFunction_Expected_EvaluatioReturnsCorrectResult()
{
string expression = @"abcdefg";
string result;
string error;
bool hasSucceeded = new FunctionEvaluator().TryEvaluateAtomicFunction(expression, out result, out error);
Assert.IsTrue(!string.IsNullOrEmpty(error));
}
private static void TryEvalAsFunction(ref string warewolfAtomToString, string cleanExpression, FunctionEvaluator functionEvaluator, ref string error)
{
try
{
var b = functionEvaluator.TryEvaluateFunction(cleanExpression.Replace("\"", ""), out string eval2, out error);
if (b)
{
warewolfAtomToString = eval2;
}
}
catch (Exception err)
{
Dev2Logger.Warn(err, "Warewolf Warn");
}
}
public void TryEvaluateAtomicFunction_ComplexCalculation_Expected_EvaluatioReturnsCorrectResult()
{
const string expression = @"Sum(Average(Abs(-100), Min(10,20,2,30,200)), Max(200,300,400)) + 250";
string result;
string error;
bool hasSucceeded = new FunctionEvaluator().TryEvaluateAtomicFunction(expression, out result, out error);
if(hasSucceeded)
{
Assert.AreEqual("701", result);
}
else
{
Assert.Fail("Oct2Dec did not evaluate correctly");
}
}
/// <summary>
/// Retrieves the value of the expression
/// </summary>
/// <param name="evalContext">Evaluation context</param>
/// <returns>Evaluated expression value</returns>
public override ExpressionValue Evaluate(IEvaluationContext evalContext)
{
// --- Evaluate all arguments from left to right
var argValues = new List <ExpressionValue>();
var errorMessage = new StringBuilder(1024);
var index = 0;
var errCount = 0;
foreach (var expr in ArgumentExpressions)
{
index++;
var argValue = expr.Evaluate(evalContext);
if (argValue == null)
{
errCount++;
errorMessage.AppendLine($"Arg #{index}: {expr.EvaluationError}");
}
else
{
argValues.Add(argValue);
}
}
// --- Check for evaluation errors
if (errCount > 0)
{
EvaluationError = $"Function argument evaluation failed:\n {errorMessage}";
return(ExpressionValue.Error);
}
// --- Function must be defined
if (!s_Evaluators.TryGetValue(FunctionName, out var evaluator))
{
EvaluationError = $"Unknown function '{FunctionName}'";
return(ExpressionValue.Error);
}
// --- Find the apropriate signature
FunctionEvaluator evaluatorFound = null;
foreach (var evalOption in evaluator)
{
if (evalOption.ArgTypes.Length != ArgumentExpressions.Count)
{
continue;
}
// --- A viable option found
var match = true;
for (var i = 0; i < evalOption.ArgTypes.Length; i++)
{
var type = argValues[i].Type;
switch (evalOption.ArgTypes[i])
{
case ExpressionValueType.Bool:
match = type == ExpressionValueType.Bool;
break;
case ExpressionValueType.Integer:
match = type == ExpressionValueType.Bool ||
type == ExpressionValueType.Integer;
break;
case ExpressionValueType.Real:
match = type == ExpressionValueType.Bool ||
type == ExpressionValueType.Integer ||
type == ExpressionValueType.Real;
break;
case ExpressionValueType.String:
match = type == ExpressionValueType.String;
break;
default:
return(ExpressionValue.Error);
}
// --- Abort search if the current argumernt type does not match
if (!match)
{
break;
}
}
if (match)
{
// --- We have found a matching signature
evaluatorFound = evalOption;
break;
}
}
// --- Check whether we found an option
if (evaluatorFound == null)
{
EvaluationError = $"The arguments of '{FunctionName}' do not match any acceptable signatures";
return(ExpressionValue.Error);
}
// --- Now, it is time to evaluate the function
try
{
var functionValue = evaluatorFound.EvaluateFunc(argValues);
return(functionValue);
}
catch (Exception e)
{
EvaluationError = $"Exception while evaluating '{FunctionName}': {e.Message}";
return(ExpressionValue.Error);
}
}
/// <summary>
/// Initializes a new function overload.
/// </summary>
/// <param name="name">The name of the function, as used in a format.</param>
/// <param name="evaluator">The method used for evaluation of the function.</param>
public Function(string name, FunctionEvaluator <T> evaluator)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Evaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
}
