protected override DataObject OnEvaluate(IExpressionEvaluator evaluator)
{
var result = evaluator.Evaluate(Test).ToBoolean();
if (result == true)
return evaluator.Evaluate(IfTrue);
if (IfFalse != null)
return evaluator.Evaluate(IfFalse);
throw new InvalidOperationException();
}
protected override DataObject OnEvaluate(IExpressionEvaluator evaluator)
{
var result = evaluator.Evaluate(Test).ToBoolean();
if (result == true)
{
return(evaluator.Evaluate(IfTrue));
}
if (IfFalse != null)
{
return(evaluator.Evaluate(IfFalse));
}
throw new InvalidOperationException();
}
public void Evaluate(ICollection <T> list, BitArray matches)
{
BitArray perItemResult = null;
int i = 0;
foreach (T item in list)
{
// Convert the set of values for this item to a List
ICollection <U> values = _getter(item).ToList();
// Build a BitArray to match each of those value
if (perItemResult == null || perItemResult.Length < values.Count)
{
perItemResult = new BitArray(values.Count);
}
// Ask the inner evaluator to check each value as if the values were the set of rows
_innerEvaluator.Evaluate(values, perItemResult);
// Make this item included if any of the values matched
bool isAnySet = false;
for (int j = 0; j < values.Count; ++j)
{
if (perItemResult[j])
{
isAnySet = true;
break;
}
}
matches.Set(i, isAnySet);
i++;
}
}
private void Transform(SourceContext sourceContext, TransformationMap transformationMap)
{
if (transformationMap.MappingType == MappingType.Field)
{
if (!sourceContext.Source.ContainsKey(transformationMap.KeyExpression))
{
SetEmptyOutput(sourceContext, transformationMap);
sourceContext.AddErrorForDestinationColumn(transformationMap.Output,
$"Source key {transformationMap.KeyExpression} is missed",
SourceContext.ErrorTypeTransformation);
}
else
{
if (transformationMap.TransformOnlyIfColumnExists &&
sourceContext.ListOfSchemaMissedColumns.Contains(transformationMap.KeyExpression))
{
sourceContext.Destination.Remove(transformationMap.Output);
}
else
{
sourceContext.Destination[transformationMap.Output] =
sourceContext.Source[transformationMap.KeyExpression];
}
}
}
else if (transformationMap.MappingType == MappingType.Expression)
{
sourceContext.Destination[transformationMap.Output] =
_expressionEvaluator.Evaluate(transformationMap.Expression);
}
else if (transformationMap.MappingType == MappingType.DataMapping)
{
}
}
public void Evaluate(ICollection <T> list, BitArray matches)
{
BitArray termMatches = new BitArray(list.Count);
for (int i = 0; i < Terms.Count; ++i)
{
IExpressionEvaluator <T> term = Terms[i];
// Get matches for the term
termMatches.SetAll(false);
term.Evaluate(list, termMatches);
// Intersect with matches so far
if (i == 0)
{
matches.Or(termMatches);
}
else
{
matches.And(termMatches);
}
// Stop if no matches remain
if (matches.TrueCount() == 0)
{
break;
}
}
}
/// <inheritdoc/>
public Task <Uri> CreateAsync(ProxyContext context, CancellationToken cancellationToken)
{
var toExpression = context.ProxySettings.To;
var to = evaluator.Evaluate(context, toExpression);
string scheme;
HostString host;
PathString toPath;
QueryString toQueryString;
FragmentString fragment;
try
{
UriHelper.FromAbsolute(
to,
out scheme,
out host,
out toPath,
out toQueryString,
out fragment);
}
catch (FormatException ufe)
{
var message = $"Using '{context.ProxySettings.To}' expression to rewrite request URL '{context.Request.Path}'. However, the rewritten URL is not a valid URL format.";
logger.LogError(ufe, message);
throw new UriFormatException(message, ufe);
}
if (!Uri.CheckSchemeName(scheme))
{
throw new UriFormatException($"The HTTP scheme '{scheme}' specified by '{toExpression}' expression is invalid.");
}
if (!host.HasValue || Uri.CheckHostName(GetHostValue(host.Value)) == UriHostNameType.Unknown)
{
throw new UriFormatException($"The URL host '{host}' specified by '{toExpression}' expression is invalid.");
}
var path = ConcatPathWithSuffix(toPath, context.Route.PathSuffix);
var queryString = toQueryString + context.Request.QueryString;
var url = UriHelper.BuildAbsolute(
scheme,
host,
PathString.Empty,
path,
queryString,
fragment);
if (Uri.TryCreate(url, UriKind.Absolute, out var uri))
{
return(Task.FromResult(uri));
}
throw new UriFormatException($"The URL '{url}' specified by '{toExpression}' expression is an invalid absolute HTTP URL.");
}
public void Evaluate_Returns_Result_Of_ExpressionEvaluator_Evaluate()
{
var tokenizer = Substitute.For <ITokenizer>();
var modelBuilderResult = new Constant();
mModelBuilder.BuildFrom(tokenizer.Tokens).Returns(modelBuilderResult);
mExpressionEvaluator.Evaluate(modelBuilderResult, null).Returns(17M);
mUnderTest.Evaluate(tokenizer, null).Should().Be(17M);
}
private void Apply(CleanupRule rule, SourceContext sourceContext, SingleCleanupRuleResult result)
{
var capturedValue = sourceContext.Source[rule.ColumnName];
var stringValue = capturedValue != null?capturedValue.ToString() : "";
EnrichContextByRow(sourceContext);
Lazy <string> evaluation = new Lazy <string>(() =>
{
var evaluatedResult = _expressionEvaluator.Evaluate(rule.Expression).ToString();
return(evaluatedResult);
});
EvaluatedValue evaluatedValue = new EvaluatedValue(evaluation);
if (CheckCondition(rule, sourceContext, capturedValue, stringValue, evaluatedValue))
{
ApplyConditionalCleanup(rule, sourceContext, stringValue, result, evaluatedValue);
}
ApplyNonConditionalCleanup(rule, sourceContext, stringValue, result, evaluatedValue);
}
public override Expression Expand(MethodCallExpression methodCallExpression, IExpressionEvaluator evaluator)
{
// The first argument of any 'Eval' call is always the expression to be evaluated.
// Its retrival must not throw exceptions (unless in an invalid subtree).
var lambda = (LambdaExpression)evaluator.Evaluate(methodCallExpression.Arguments[0]);
var substituted = ParameterSubstituter.SubstituteParameter(
lambda,
methodCallExpression.Arguments.Skip(1));
return(substituted);
}
private void OnEvaluateClick(object sender, EventArgs e)
{
EvaluatorParameters parameters = evaluator.CreateEmptyParameters();
this.SetParameters(currentExpressionValue, parameters);
this.resultLabel.Text = evaluator.Evaluate(parameters).ToString();
Graphics graphics = resultLabel.CreateGraphics();
SizeF resultSizeF = graphics.MeasureString(resultLabel.Text, resultLabel.Font);
Size resultSize = Size.Truncate(resultSizeF);
this.resultLabel.Width = resultSize.Width + 1;
this.ResizePanel();
}
private static void Run <T>(int expectedCount, string query, IList <T> values, Func <TermExpression, IExpressionEvaluator <T> > converter)
{
// Parse the Query
IExpression expression = ExpressionParser.ParseExpression(query);
// Build an Evaluator against the int array
IExpressionEvaluator <T> evaluator = expression.ToEvaluator <T>(converter);
// Ask for matches from the array
BitArray matches = new BitArray(values.Count);
evaluator.Evaluate(values, matches);
// Verify the match count is correct
Assert.Equal(expectedCount, matches.TrueCount());
}
public void Simple_expression_evaluation_works()
{
//Arrange
var expression = "1+1";
//Act
var result = _expressionEvaluator.Evaluate <int>(expression);
//Assert
result.Should().Be(2);
}
protected override DataObject OnEvaluate(IExpressionEvaluator evaluator)
{
var sortedEval = new[] {
new SortedEvalInfo(0, Left),
new SortedEvalInfo(1, Right)
}
.OrderByDescending(x => x.Precedence)
.ToArray();
foreach (var evalInfo in sortedEval) {
evalInfo.Result = evaluator.Evaluate(evalInfo.Expression);
}
var results = sortedEval
.OrderBy(x => x.Offset)
.Select(x => x.Result)
.ToArray();
return EvaluateBinary(results[0], results[1], evaluator.Context);
}
public override Expression Visit(Expression exp)
{
if (exp == null)
{
return(null);
}
if (candidates.Contains(exp))
{
if (exp is ConstantExpression)
{
return(exp);
}
try {
return(Expression.Constant(evaluator.Evaluate(exp), exp.Type));
} catch (Exception exception) {
return(ExceptionClosure.MakeExceptionClosureCall(exception, exp.Type));
}
}
return(base.Visit(exp));
}
protected override DataObject OnEvaluate(IExpressionEvaluator evaluator)
{
var sortedEval = new[] {
new SortedEvalInfo(0, Left),
new SortedEvalInfo(1, Right)
}
.OrderByDescending(x => x.Precedence)
.ToArray();
foreach (var evalInfo in sortedEval)
{
evalInfo.Result = evaluator.Evaluate(evalInfo.Expression);
}
var results = sortedEval
.OrderBy(x => x.Offset)
.Select(x => x.Result)
.ToArray();
return(EvaluateBinary(results[0], results[1], evaluator.Context));
}
private Dictionary <ExpressReportParameter, object> GetParameters(ExpressReport.ExpressReport expressReport, string parametersString, IEntity entity)
{
var parameters = expressReport.FakeReportEntity.GetParametersValues();
if (!parametersString.IsNullOrEmpty() && entity != null)
{
var paramsPairs = parametersString.Split(';');
foreach (var paramPair in paramsPairs)
{
var pair = paramPair.Split(':');
if (pair.Length == 2)
{
string paramName = pair[0];
string paramValue = pair[1].Replace("<colon>", ":").Replace("<semicolon>", ";");
if (paramValue.IsNullOrEmpty())
{
continue;
}
Expression paramExpression = _expressionParsing.Parse(paramValue);
if (paramExpression == null || paramExpression == Expression.Empty)
{
continue;
}
string errorMessage;
parameters[parameters.FirstOrDefault(p => p.Key.Key == paramName).Key] =
_expressionEvaluator.Evaluate(paramExpression, entity, out errorMessage);
}
}
}
return(parameters);
}
public IActionResult Post([FromBody] EvalExpression expression) => Ok(new ExpressionWithResult
{
Expression = expression.Expression,
Result = evaluator.Evaluate(expression.Expression)
});
/// <summary>
/// A simple expression evaluator without context. Works for simple expressions like "1+1"
/// </summary>
/// <param name="evaluator">IExpressionEvaluator instance</param>
/// <param name="expression">Expression to be evaluated</param>
/// <typeparam name="T">Return type</typeparam>
/// <example>
/// var s = evaluator.Evaluate("1+1");
/// </example>
/// <returns>The result. Warning: this can be null. </returns>
public static T Evaluate <T>(this IExpressionEvaluator evaluator, string expression)
=> evaluator.Evaluate <T>(expression, new Dictionary <string, object>());
protected override DataObject OnEvaluate(IExpressionEvaluator evaluator)
{
var ob = evaluator.Evaluate(Operand);
return EvaluateUnary(ob, evaluator.Context);
}
public void TestConstantExpression()
{
Expression <Func <bool> > expr = () => true;
Assert.AreEqual(expected: true, actual: evaluator.Evaluate(expr.Body));
}
public decimal Evaluate(ITokenizer token, IApplicationArguments args)
{
var expression = mModelBuilder.BuildFrom(token.Tokens);
return(mExpressionEvaluator.Evaluate(expression, args));
}
internal string?Evaluate(string?expression) => evaluator.Evaluate(this, expression);
public int RunWithoutCatch(QueryOptions options)
{
bool valid = DriverUtilities.ReportWhetherOutputFileCanBeCreated(options.OutputFilePath, options.Force, _fileSystem);
if (!valid)
{
return(FAILURE);
}
Stopwatch w = Stopwatch.StartNew();
int originalTotal = 0;
int matchCount = 0;
// Parse the Query and create a Result evaluator for it
IExpression expression = ExpressionParser.ParseExpression(options.Expression);
IExpressionEvaluator <Result> evaluator = expression.ToEvaluator <Result>(SarifEvaluators.ResultEvaluator);
// Read the log
SarifLog log = ReadSarifFile <SarifLog>(_fileSystem, options.InputFilePath);
foreach (Run run in log.Runs)
{
if (run.Results == null)
{
continue;
}
run.SetRunOnResults();
originalTotal += run.Results.Count;
// Find matches for Results in the Run
BitArray matches = new BitArray(run.Results.Count);
evaluator.Evaluate(run.Results, matches);
// Count the new matches
matchCount += matches.TrueCount();
// Filter the Run.Results to the matches
run.Results = matches.MatchingSubset <Result>(run.Results);
// Write to console, if caller requested
if (options.WriteToConsole)
{
foreach (Result result in run.Results)
{
Console.WriteLine(result.FormatForVisualStudio());
}
}
}
// Remove any Runs with no remaining matches
log.Runs = log.Runs.Where(r => (r?.Results?.Count ?? 0) > 0).ToList();
w.Stop();
Console.WriteLine($"Found {matchCount:n0} of {originalTotal:n0} results matched in {w.Elapsed.TotalSeconds:n1}s.");
// Write to Output file, if caller requested
if (!string.IsNullOrEmpty(options.OutputFilePath) && (options.Force || !_fileSystem.FileExists(options.OutputFilePath)))
{
Console.WriteLine($"Writing matches to {options.OutputFilePath}.");
WriteSarifFile <SarifLog>(_fileSystem, log, options.OutputFilePath, (options.PrettyPrint ? Formatting.Indented : Formatting.None));
}
// Return exit code based on configuration
if (options.ReturnCount)
{
return(matchCount);
}
else if (options.NonZeroExitCodeIfCountOver >= 0 && matchCount > options.NonZeroExitCodeIfCountOver)
{
return(TOO_MANY_RESULTS);
}
else
{
return(SUCCESS);
}
}
private string EvaluateBasicExpressionAndReplace(string expression, Match m)
{
var simpleExpression = new BasicMathExpression(m.Groups[0].ToString());
return($"{expression.Substring(0, m.Groups[0].Index)}{_expressionEvaluator.Evaluate(simpleExpression)}{expression.Substring(m.Groups[0].Index + m.Groups[0].Length)}");
}
public void Evaluate(ICollection <T> list, BitArray matches)
{
_inner.Evaluate(list, matches);
matches.Not();
}
public int RunWithoutCatch(QueryOptions options)
{
Stopwatch w = Stopwatch.StartNew();
int originalTotal = 0;
int matchCount = 0;
// Parse the Query and create a Result evaluator for it
IExpression expression = ExpressionParser.ParseExpression(options.Expression);
IExpressionEvaluator <Result> evaluator = expression.ToEvaluator <Result>(SarifEvaluators.ResultEvaluator);
// Read the log
SarifLog log = ReadSarifFile <SarifLog>(_fileSystem, options.InputFilePath);
foreach (Run run in log.Runs)
{
if (run.Results == null)
{
continue;
}
originalTotal += run.Results.Count;
// Find matches for Results in the Run
BitArray matches = new BitArray(run.Results.Count);
evaluator.Evaluate(run.Results, matches);
// Count the new matches
matchCount += matches.TrueCount();
// Filter the Run.Results to the matches
run.Results = matches.MatchingSubset <Result>(run.Results);
// Write to console, if caller requested
if (options.WriteToConsole)
{
foreach (Result result in run.Results)
{
Console.WriteLine(result.FormatForVisualStudio(result.GetRule(run)));
}
}
}
w.Stop();
Console.WriteLine($"Found {matchCount:n0} of {originalTotal:n0} results matched in {w.Elapsed.TotalSeconds:n1}s.");
// Write to Output file, if caller requested
if (!String.IsNullOrEmpty(options.OutputFilePath) && (options.Force || !_fileSystem.FileExists(options.OutputFilePath)))
{
Console.WriteLine($"Writing matches to {options.OutputFilePath}.");
WriteSarifFile <SarifLog>(_fileSystem, log, options.OutputFilePath, (options.PrettyPrint ? Formatting.Indented : Formatting.None));
}
// Return exit code based on configuration
if (options.ReturnCount)
{
return(matchCount);
}
else if (options.NonZeroExitCodeIfCountOver >= 0 && matchCount > options.NonZeroExitCodeIfCountOver)
{
return(2);
}
else
{
return(0);
}
}
public void Calculate()
{
var result = _expEvaluator.Evaluate(_resultView.Text);
_resultView.Text = result.ToString();
}
public override bool Evaluate(IExpressionEvaluator evaluator)
{
return(evaluator.Evaluate(this));
}
protected ValueReference <SoftEvaluationContext, TypeMirror, Value> Evaluate(string expression)
{
return(myExpressionEvaluator.Evaluate(Context, expression));
}
protected override DataObject OnEvaluate(IExpressionEvaluator evaluator)
{
var ob = evaluator.Evaluate(Operand);
return(EvaluateUnary(ob, evaluator.Context));
}