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)); }