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 override void Visit(LogicalExpression expression)
{
throw new NotImplementedException();
}
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 override void Visit(LogicalExpression expression)
{
throw new Exception("The method or operation is not implemented.");
}
public abstract void Visit(LogicalExpression expression);
