protected override object EvaluateOperation(object left, object right)
{
if (left == null)
{
return(right);
}
if (right == null)
{
return(left);
}
if ((left is string) ||
(right is string))
{
return(left.ToString() + right);
}
if (left is DateTime && right is int)
{
return(((DateTime)left).AddDays((int)right));
}
if (left is DateTime && right is TimeSpan)
{
return(((DateTime)left).Add((TimeSpan)right));
}
var nLeft = TypeNormalizer.EnsureType <double>(left);
var nRight = TypeNormalizer.EnsureType <double>(right);
return(nLeft + nRight);
}
public static object Sum(ScriptThread thread, AstNode[] childNodes)
{
double sum = 0;
var fieldName = childNodes[0].Evaluate(thread).ToString();
var dataSource = thread.GetDataSource();
var grouped = ImportAggregateHelper.IsGrouped(dataSource);
if (grouped != null)
{
foreach (var element in grouped)
{
var s = element.Sum(o => {
var v = ReadValueFromObject(fieldName, o);
return(TypeNormalizer.EnsureType <double>(v));
});
sum = sum + s;
}
}
else
{
if (ImportAggregateHelper.FieldExist(dataSource.FirstOrDefault(), fieldName))
{
sum = dataSource.Sum(o => {
var v = ReadValueFromObject(fieldName, o);
return(TypeNormalizer.EnsureType <double>(v));
});
}
}
return(sum.ToString());
}
static double TimeSpanSum(string fromField, object current)
{
var value = ReadValueFromObject(fromField, current);
var timeSpan = (TimeSpan)value;
return(TypeNormalizer.EnsureType <double>(timeSpan.Ticks));
}
protected override void AggregateValue(object value, AggregationState aggregationState, params object[] args)
{
var sum = aggregationState.GetValue <double>("value");
var nextVal = TypeNormalizer.EnsureType <double>(value);
aggregationState["value"] = sum + nextVal;
}
protected sealed override double EvaluateOperation(object left, object right)
{
var dLeft = TypeNormalizer.EnsureType <double>(left);
var dRight = TypeNormalizer.EnsureType <double>(right);
return(EvaluateOperation(dLeft, dRight));
}
protected sealed override bool EvaluateOperation(object left, object right)
{
var bLeft = TypeNormalizer.EnsureType <bool>(left);
var bRight = TypeNormalizer.EnsureType <bool>(right);
return(EvaluateOperation(bLeft, bRight));
}
protected override void AggregateValue(object value, AggregationState aggregationState, object[] args)
{
var val = TypeNormalizer.EnsureType<bool>(value);
aggregationState["value"] = val;
if (val == false)
aggregationState.CanReturn = true;
}
protected override void AggregateValue(object value, AggregationState aggregationState, params object[] args)
{
bool val = TypeNormalizer.EnsureType<bool>(value);
if (val)
{
var count = aggregationState.GetValue<int>("count");
aggregationState["count"] = count + 1;
}
}
protected override void AggregateValue(object value, AggregationState aggregationState, params object[] args)
{
var index = TypeNormalizer.EnsureType <int>(value);
if (index == aggregationState.CurrentIndex)
{
aggregationState["found"] = true;
aggregationState.CanReturn = true;
}
}
protected sealed override T EvaluateFunction(object[] args)
{
var left = args[0];
var right = args[1];
if (AutoNormalizeArguments)
{
TypeNormalizer.NormalizeTypes(ref left, ref right);
}
return(EvaluateOperation(left, right));
}
protected override void AggregateValue(object value, AggregationState aggregationState, object[] args)
{
if (!aggregationState.ContainsKey("results"))
{
aggregationState["results"] = new List <object>();
}
var pass = TypeNormalizer.EnsureType <bool>(value);
if (pass && aggregationState.DataItem != null)
{
aggregationState.GetValue <List <object> >("results").Add(aggregationState.DataItem);
}
}
protected override object EvaluateFunction(object[] args)
{
var bCondition = TypeNormalizer.EnsureType <bool>(args[0]);
if (bCondition)
{
return(args[1]);
}
if (args.Length > 2)
{
return(args[2]);
}
return(null);
}
protected override void AggregateValue(object value, AggregationState aggregationState, params object[] args)
{
var val = TypeNormalizer.EnsureType <double>(value);
if (!aggregationState.ContainsKey("value"))
{
aggregationState["value"] = val;
}
else
{
var min = aggregationState.GetValue <double>("value");
if (val < min)
{
min = val;
}
aggregationState["value"] = min;
}
}
protected override TimeSpan EvaluateFunction(object[] args)
{
args[0] = args[0] == null ? DateTime.Today : TypeNormalizer.EnsureType(args[0], typeof(DateTime));
args[1] = args[1] == null ? DateTime.Today : TypeNormalizer.EnsureType(args[1], typeof(DateTime));
var endDate = (DateTime)args[0];
if (endDate == DateTime.MinValue)
{
endDate = DateTime.Today;
}
var startDate = (DateTime)args[1];
if (startDate == DateTime.MinValue)
{
startDate = DateTime.Today;
}
return(endDate.Subtract(startDate));
}
protected override DateTime EvaluateFunction(object[] args)
{
args[0] = args[0] == null ? DateTime.Today : TypeNormalizer.EnsureType(args[0], typeof(DateTime));
args[1] = args[1].ToString().ToUpper();
args[2] = TypeNormalizer.EnsureType(args[2], typeof(Int32));
var startDate = (DateTime)args[0];
if (startDate == DateTime.MinValue)
{
startDate = DateTime.Today;
}
string code = args[1].ToString();
ValidatePeriodCode(code);
var distance = (int)args[2];
switch (code)
{
case "D":
return(startDate.AddDays(distance));
case "W":
return(startDate.AddDays(distance * 7));
case "M":
return(startDate.AddMonths(distance));
case "Y":
return(startDate.AddYears(distance));
default:
return(startDate.AddDays(distance));
}
}
protected virtual IExpression CompileExpressionNode(IExpressionNodeFactory factory, ParseNode astNode)
{
switch (astNode.Token.Type)
{
case TokenType.Atom:
if (astNode.Nodes[0].Token.Type == TokenType.BROPEN)
{
return(CompileExpressionNode(factory, astNode.Nodes[1]));
}
return(CompileExpressionNode(factory, astNode.Nodes[0]));
case TokenType.NUMBER:
case TokenType.INTEGER:
var num = TypeNormalizer.EnsureType <double>(astNode.Token.Text);
return(factory.CreateLiteral(num));
case TokenType.STRING:
var str = TypeNormalizer.EnsureType <string>(astNode.Token.Text.Replace("\"", String.Empty));
return(factory.CreateLiteral(str));
case TokenType.TRUE:
case TokenType.FALSE:
var bln = TypeNormalizer.EnsureType <bool>(astNode.Token.Text);
return(factory.CreateLiteral(bln));
case TokenType.NULL:
return(null);
case TokenType.BooleanExpr:
case TokenType.CompareExpr:
case TokenType.AddExpr:
case TokenType.MultExpr:
case TokenType.PowerExpr:
return(CompileBinaryOperator(factory, astNode));
case TokenType.QualifiedName:
return(CompileQualifiedName(factory, null, Select(astNode.Nodes, TokenType.Identifier), 0));
case TokenType.Conditional:
var pieces = Select(astNode.Nodes, TokenType.BooleanExpr);
IExpression condition = CompileExpressionNode(factory, pieces[0]);
IExpression trueExpr = CompileExpressionNode(factory, pieces[1]);
IExpression falseExpr = (pieces.Count == 3) ? CompileExpressionNode(factory, pieces[2]) : null;
var func = new IfThen();
if (falseExpr != null)
{
func.AcceptArguments(condition, trueExpr, falseExpr);
}
else
{
func.AcceptArguments(condition, trueExpr);
}
return(func);
case TokenType.UnaryExpr:
string token = astNode.Nodes[0].Token.Text;
IExpression left = CompileBinaryOperator(factory, astNode.Nodes[1]);
return(factory.CreateUnaryOperator(token, left));
}
return(null);
}
protected virtual IExpression CompileExpressionNode(IExpressionNodeFactory factory, ParseTreeNode astNode)
{
switch (astNode.Term.Name)
{
case "Number":
var num = TypeNormalizer.EnsureType <double>(astNode.Token.Value);
return(factory.CreateLiteral(num));
case "String":
var str = TypeNormalizer.EnsureType <string>(astNode.Token.Value);
return(factory.CreateLiteral(str));
case "Boolean":
var bln = TypeNormalizer.EnsureType <bool>(astNode.Token.Value);
return(factory.CreateLiteral(bln));
case "Identifier":
var variable = astNode.Token.Value;
if (variable != null)
{
return(factory.CreateVariable(variable.ToString()));
}
break;
case "Expr":
if (astNode.ChildNodes.Count == 3 &&
astNode.ChildNodes[1].Term is SymbolTerminal)
{
IExpression left = CompileExpressionNode(factory, astNode.ChildNodes[0]);
IExpression right = CompileExpressionNode(factory, astNode.ChildNodes[2]);
return(factory.CreateBinaryOperator(astNode.ChildNodes[1].Term.Name, left, right));
}
if (astNode.ChildNodes.Count == 2 &&
astNode.ChildNodes[0].Term is SymbolTerminal)
{
IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[1]);
return(factory.CreateUnaryOperator(astNode.ChildNodes[0].Term.Name, arg));
}
if (astNode.ChildNodes.Count == 2 &&
astNode.ChildNodes[1].Term is SymbolTerminal)
{
IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[0]);
return(factory.CreateUnaryOperator(astNode.ChildNodes[1].Term.Name, arg));
}
break;
case "QualifiedName":
var parts = new List <string>();
if (astNode.ChildNodes.Count == 2)
{
return(new QualifiedName(new[] { astNode.ChildNodes[1].Token.ValueString }));
}
//Condition ought to be impossible
if (astNode.ChildNodes.Count != 3)
{
throw new Exception("Malformed QualifiedName - should have 3 child nodes");
}
ExtractQualifiedName(astNode, parts);
return(new QualifiedName(parts.ToArray()));
case "FunctionExpression":
string functionName = (astNode.ChildNodes[0].Token.ValueString);
var args = new IExpression[astNode.ChildNodes[1].ChildNodes.Count];
for (int i = 0; i < astNode.ChildNodes[1].ChildNodes.Count; i++)
{
args[i] = CompileExpressionNode(factory, astNode.ChildNodes[1].ChildNodes[i]);
}
return(factory.CreateFunction(functionName, args));
case "IfThen":
IExpression condition = CompileExpressionNode(factory, astNode.ChildNodes[1]);
IExpression trueExpr = CompileExpressionNode(factory, astNode.ChildNodes[3]);
IExpression falseExpr = null;
if (astNode.ChildNodes.Count == 6)
{
falseExpr = CompileExpressionNode(factory, astNode.ChildNodes[5]);
}
var func = new IfThen();
if (falseExpr != null)
{
func.AcceptArguments(condition, trueExpr, falseExpr);
}
else
{
func.AcceptArguments(condition, trueExpr);
}
return(func);
case "ArrayExpression":
IExpression context = CompileExpressionNode(factory, astNode.ChildNodes[0]);
IExpression index = CompileExpressionNode(factory, astNode.ChildNodes[1]);
var indexer = new ItemAtIndex();
indexer.AcceptArguments(context, index);
return(indexer);
}
return(null);
}
protected override bool EvaluateOperation(object arg)
{
var val = TypeNormalizer.EnsureType <bool>(arg);
return(!val);
}
// don't call base
protected override IExpression CompileExpressionNode(IExpressionNodeFactory factory, ParseTreeNode astNode)
{
switch (astNode.Term.Name)
{
case "Number":
var num = TypeNormalizer.EnsureType <double>(astNode.Token.Value);
return(factory.CreateLiteral(num));
case "String":
var str = TypeNormalizer.EnsureType <string>(astNode.Token.Value);
return(factory.CreateLiteral(str));
case "Boolean":
var bln = TypeNormalizer.EnsureType <bool>(astNode.Token.Value);
return(factory.CreateLiteral(bln));
case "Identifier":
var variable = astNode.Token.Value;
if (variable != null)
{
return(factory.CreateVariable(variable.ToString()));
}
break;
case "Symbol":
var str_1 = TypeNormalizer.EnsureType <string>(astNode.Token.Value);
return(factory.CreateLiteral(str_1));
case "UserSectionStmt":
return(factory.CreateFunction(astNode.ChildNodes[2].Token.Text, null));
case "GlobalSectionStmt":
return(factory.CreateLiteral(this.SinglePage.EvaluatePropertyPath(astNode.ChildNodes[2].Token.Text)));
case "ParameterSectionStmt":
return(CompileExpressionNode(factory, astNode.ChildNodes[2]));
case "FieldsSectionStmt":
//return CompileExpressionNode (factory,astNode.ChildNodes[2]);
IExpression l = CompileExpressionNode(factory, astNode.ChildNodes[2]);
return(factory.CreateFunction(astNode.ChildNodes[0].Token.Text,
l));
case "ParExpr":
return(CompileExpressionNode(factory, astNode.ChildNodes[0]));
case "BinExpr":
if (astNode.ChildNodes.Count == 3 &&
astNode.ChildNodes[1].Term is SymbolTerminal)
{
IExpression left = CompileExpressionNode(factory, astNode.ChildNodes[0]);
IExpression right = CompileExpressionNode(factory, astNode.ChildNodes[2]);
return(factory.CreateBinaryOperator(astNode.ChildNodes[1].Term.Name, left, right));
}
if (astNode.ChildNodes.Count == 2 &&
astNode.ChildNodes[0].Term is SymbolTerminal)
{
IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[1]);
return(factory.CreateUnaryOperator(astNode.ChildNodes[0].Term.Name, arg));
}
if (astNode.ChildNodes.Count == 2 &&
astNode.ChildNodes[1].Term is SymbolTerminal)
{
IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[0]);
return(factory.CreateUnaryOperator(astNode.ChildNodes[1].Term.Name, arg));
}
break;
case "QualifiedName":
var parts = new List <string>();
if (astNode.ChildNodes.Count == 2)
{
return(new QualifiedName(new[] { astNode.ChildNodes[1].Token.ValueString }));
}
/*
* //Condition ought to be impossible
* if (astNode.ChildNodes.Count != 3 )
* throw new Exception("Malformed QualifiedName - should have 3 child nodes");
*/
if (astNode.ChildNodes.Count == 1)
{
return(CompileExpressionNode(factory, astNode.ChildNodes[0]));
}
SimpleExpressionLanguageCompiler.ExtractQualifiedName(astNode, parts);
return(new QualifiedName(parts.ToArray()));
case "FunctionExpression":
IExpression [] args = null;
string functionName = (astNode.ChildNodes[0].ChildNodes[0].Token.ValueString);
if (astNode.ChildNodes.Count == 1)
{
args = new IExpression[astNode.ChildNodes[0].ChildNodes[0].ChildNodes.Count];
}
else
{
args = new IExpression[astNode.ChildNodes[1].ChildNodes.Count];
for (int i = 0; i < astNode.ChildNodes[1].ChildNodes.Count; i++)
{
args[i] = CompileExpressionNode(factory, astNode.ChildNodes[1].ChildNodes[i]);
}
}
return(factory.CreateFunction(functionName, args));
case "IfThen":
IExpression condition = CompileExpressionNode(factory, astNode.ChildNodes[1].ChildNodes[0]);
IExpression trueExpr = CompileExpressionNode(factory, astNode.ChildNodes[3]);
// IExpression falseExpr = CompileExpressionNode(factory, astNode.ChildNodes[3]);
IExpression falseExpr = null;
if (astNode.ChildNodes.Count == 6)
{
falseExpr = CompileExpressionNode(factory, astNode.ChildNodes[5]);
}
var func = new IfThen();
if (falseExpr != null)
{
func.AcceptArguments(condition, trueExpr, falseExpr);
}
else
{
func.AcceptArguments(condition, trueExpr);
}
return(func);
/*
* case "ArrayExpression":
* IExpression context = CompileExpressionNode(factory, astNode.ChildNodes[0]);
* IExpression index = CompileExpressionNode(factory, astNode.ChildNodes[1]);
* var indexer = new ItemAtIndex();
* indexer.AcceptArguments(context, index);
* return indexer;
*
*/
}
return(null);
}
protected override double EvaluateOperation(object arg)
{
var val = TypeNormalizer.EnsureType <double>(arg);
return(val * -1);
}
public override T Evaluate(IExpressionContext context)
{
return(TypeNormalizer.EnsureType <T>(Root.Evaluate(context)));
}
static double SimpleSum(string fromField, object current)
{
var value = ReadValueFromObject(fromField, current);
return(TypeNormalizer.EnsureType <double>(value));
}
