public void EncapsulateNoValue(string convertMethod, LogicalExpression logicalExpression) { //Result.AppendFormat("{0}(", convertMethod); if (logicalExpression != null) logicalExpression.Accept(this); //EncapsulateNoValue(logicalExpression); //Result.Append(")"); }
public Expression(LogicalExpression expression, EvaluateOptions options) { if (expression == null) throw new ArgumentException("Expression can't be null", "expression"); ParsedExpression = expression; Options = options; }
protected void EncapsulateNoValue(LogicalExpression expression) { if (expression is ValueExpression) { expression.Accept(this); } else { Result.Append("("); expression.Accept(this); // trim spaces before adding a closing paren while (Result[Result.Length - 1] == ' ') { Result.Remove(Result.Length - 1, 1); } Result.Append(") "); } }
protected async Task EncapsulateNoValueAsync(LogicalExpression expression) { //value expressions are syncronous if (expression is ValueExpression) { expression.Accept(this); } else { Result.Append("("); await expression.AcceptAsync(this); // trim spaces before adding a closing paren while (Result[Result.Length - 1] == ' ') { Result.Remove(Result.Length - 1, 1); } Result.Append(") "); } }
public BinaryExpression RightShift(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.RightShift, this, operand); }
public BinaryExpression NotEqual(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.NotEqual, this, operand); }
public BinaryExpression Modulo(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.Modulo, this, operand); }
public BinaryExpression GreaterOrEqualThan(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.GreaterOrEqual, this, operand)); }
public BinaryExpression DividedBy(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.Div, this, operand)); }
public BinaryExpression(BinaryExpressionType type, LogicalExpression leftExpression, LogicalExpression rightExpression) { Type = type; LeftExpression = leftExpression; RightExpression = rightExpression; }
/// <summary> /// Pre-compiles the expression in order to check syntax errors. /// If errors are detected, the Error property contains the message. /// </summary> /// <returns>True if the expression syntax is correct, otherwiser False</returns> public bool HasErrors() { try { if (ParsedExpression == null) { ParsedExpression = Compile(OriginalExpression, (Options & EvaluateOptions.NoCache) == EvaluateOptions.NoCache); } // In case HasErrors() is called multiple times for the same expression return ParsedExpression != null && Error != null; } catch(Exception e) { Error = e.Message; return true; } }
public object Evaluate() { if (HasErrors()) { throw new EvaluationException(Error); } if (ParsedExpression == null) { ParsedExpression = Compile(OriginalExpression, (Options & EvaluateOptions.NoCache) == EvaluateOptions.NoCache); } var visitor = new EvaluationVisitor(Options); visitor.EvaluateFunction += EvaluateFunction; visitor.EvaluateParameter += EvaluateParameter; visitor.Parameters = Parameters; // if array evaluation, execute the same expression multiple times if ((Options & EvaluateOptions.IterateParameters) == EvaluateOptions.IterateParameters) { int size = -1; ParametersBackup = new Dictionary<string, object>(); foreach (string key in Parameters.Keys) { ParametersBackup.Add(key, Parameters[key]); } ParameterEnumerators = new Dictionary<string, IEnumerator>(); foreach (object parameter in Parameters.Values) { if (parameter is IEnumerable) { int localsize = 0; foreach (object o in (IEnumerable)parameter) { localsize++; } if (size == -1) { size = localsize; } else if (localsize != size) { throw new EvaluationException("When IterateParameters option is used, IEnumerable parameters must have the same number of items"); } } } foreach (string key in Parameters.Keys) { var parameter = Parameters[key] as IEnumerable; if (parameter != null) { ParameterEnumerators.Add(key, parameter.GetEnumerator()); } } var results = new List<object>(); for (int i = 0; i < size; i++) { foreach (string key in ParameterEnumerators.Keys) { IEnumerator enumerator = ParameterEnumerators[key]; enumerator.MoveNext(); Parameters[key] = enumerator.Current; } ParsedExpression.Accept(visitor); results.Add(visitor.Result); } return results; } ParsedExpression.Accept(visitor); return visitor.Result; }
public TernaryExpression(LogicalExpression leftExpression, LogicalExpression middleExpression, LogicalExpression rightExpression) { this.LeftExpression = leftExpression; this.MiddleExpression = middleExpression; this.RightExpression = rightExpression; }
public override void Visit(LogicalExpression expression) { throw new NotImplementedException(); }
public void EncapsulateNoValue(string convertMethod, LogicalExpression logicalExpression) { Result.AppendFormat("{0}(", convertMethod); EncapsulateNoValue(logicalExpression); Result.Append(")"); }
public BinaryExpression BitwiseXOr(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.BitwiseXOr, this, operand); }
protected void EncapsulateNoValue(LogicalExpression expression) { if (expression is ValueExpression) { expression.Accept(this); } else { Result.Append("("); expression.Accept(this); // trim spaces before adding a closing paren while(Result[Result.Length - 1] == ' ') Result.Remove(Result.Length - 1, 1); Result.Append(") "); } }
public BinaryExpression EqualsTo(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.Equal, this, operand); }
public abstract Task VisitAsync(LogicalExpression expression);
private async Task <object> EvaluateAsync(LogicalExpression expression) { await expression.AcceptAsync(this); return(Result); }
public override void Visit(LogicalExpression expression) { //base.Visit(expression); }
private object Evaluate(LogicalExpression expression) { expression.Accept(this); return(Result); }
private void Compile() { try { _parsedExpression = Compile(OriginalExpression, true); } catch (EvaluationException ex) { ErrorException = ex; } }
public BinaryExpression And(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.And, this, operand)); }
public Expression(LogicalExpression expression) : this(expression, EvaluateOptions.None) { }
public BinaryExpression EqualsTo(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.Equal, this, operand)); }
public UnaryExpression(UnaryExpressionType type, LogicalExpression expression) { Type = type; Expression = expression; }
public BinaryExpression LesserOrEqualThan(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.LesserOrEqual, this, operand); }
public BinaryExpression Mult(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.Times, this, operand); }
public override void Visit(LogicalExpression expression) { expression.Accept(this); }
public BinaryExpression Plus(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.Plus, this, operand); }
public BinaryExpression LesserThan(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.Lesser, this, operand)); }
public BinaryExpression And(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.And, this, operand); }
public BinaryExpression Modulo(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.Modulo, this, operand)); }
public BinaryExpression DividedBy(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.Div, this, operand); }
public BinaryExpression NotEqual(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.NotEqual, this, operand)); }
public BinaryExpression GreaterThan(LogicalExpression operand) { return new BinaryExpression(BinaryExpressionType.Greater, this, operand); }
public BinaryExpression Plus(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.Plus, this, operand)); }
private object Evaluate(LogicalExpression expression) { expression.Accept(this); return Result; }
public BinaryExpression Mult(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.Times, this, operand)); }
public override Task VisitAsync(LogicalExpression expression) { throw new NotImplementedException(); }
public BinaryExpression BitwiseXOr(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.BitwiseXOr, this, operand)); }
public override void Visit(LogicalExpression expression) { throw new Exception("The method or operation is not implemented."); }
public BinaryExpression RightShift(LogicalExpression operand) { return(new BinaryExpression(BinaryExpressionType.RightShift, this, operand)); }
public abstract void Visit(LogicalExpression expression);