// private object EvalParameter(object item, NPathParameter parameter)
// {
// IQueryParameter value = parameter.Value as IQueryParameter;
// object res = value.Value;
//
// if (IsNumber(res))
// res = double.Parse(res.ToString());
//
// return res;
// }
protected virtual object EvalMethodCall(object item, NPathMethodCall call)
{
ArrayList parameters = new ArrayList();
foreach (IValue parameterExpression in call.Parameters)
{
object parameterValue = this.EvalValue(item, parameterExpression);
parameters.Add(parameterValue);
}
object target = item;
if (call.PropertyPath.Path != "")
{
target = EvalPropertyPath(item, call.PropertyPath);
}
if (target == null)
{
return(null);
}
string methodName = call.MethodName;
if (target is IList)
{
if (methodName == "Count")
{
methodName = "get_Count";
}
}
MethodInfo[] methods = target.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (MethodInfo method in methods)
{
if (methodName == method.Name && method.GetParameters().Length == parameters.Count)
{
object[] methodParams = new object[parameters.Count];
ParameterInfo[] paramInfo = method.GetParameters();
for (int i = 0; i < parameters.Count; i++)
{
object value = Convert.ChangeType(parameters[i], paramInfo[i].ParameterType);
methodParams[i] = value;
}
object result = method.Invoke(target, methodParams);
if (IsNumber(result))
{
result = Convert.ToDouble(result);
}
if (call.PropertyPath.IsNegative)
{
result = NegateValue(result);
}
return(result);
}
}
throw new Exception("Error");
}
private IValue ParseValue()
{
IValue operand = null;
bool isNegative = false;
if (tokenizer.GetCurrentToken().IsType("sign"))
{
if (tokenizer.GetCurrentToken().IsType("minus"))
{
isNegative = true;
}
tokenizer.MoveNext();
}
Token currentToken = tokenizer.GetCurrentToken();
#region parse value
if (currentToken.IsType("null"))
{
NPathNullValue nullOperand = new NPathNullValue();
operand = nullOperand;
tokenizer.MoveNext();
}
else if (currentToken.IsType("parameter"))
{
NPathParameter parameterOperand = new NPathParameter();
parameterOperand.Value = parameterQueue[0];
parameterQueue.RemoveAt(0);
operand = parameterOperand;
tokenizer.MoveNext();
}
else if (tokenizer.GetCurrentToken().IsType("textsearch"))
{
return(ParseSearchFunctionExpression());
}
else if (currentToken.IsType("function") && IsInSelectClause() || currentToken.IsType("isnull") || currentToken.IsType("soundex"))
{
NPathFunction functionOperand = new NPathFunction();
if (currentToken.IsType("soundex"))
{
functionOperand = new NPathSoundexStatement();
}
if (currentToken.IsType("sum"))
{
functionOperand = new NPathSumStatement();
}
if (currentToken.IsType("isnull"))
{
functionOperand = new NPathIsNullStatement();
}
if (currentToken.IsType("count"))
{
functionOperand = new NPathCountStatement();
}
if (currentToken.IsType("avg"))
{
functionOperand = new NPathAvgStatement();
}
if (currentToken.IsType("min"))
{
functionOperand = new NPathMinStatement();
}
if (currentToken.IsType("max"))
{
functionOperand = new NPathMaxStatement();
}
tokenizer.MoveNext();
tokenizer.GetCurrentToken("(", "(");
tokenizer.MoveNext();
if (tokenizer.GetCurrentToken().IsType("distinct"))
{
functionOperand.Distinct = true;
tokenizer.MoveNext();
}
functionOperand.Expression = ParseBooleanExpression();
tokenizer.GetCurrentToken(")", ")");
tokenizer.MoveNext();
operand = functionOperand;
}
else if (currentToken.IsType("date"))
{
NPathDateTimeValue dateOperand = new NPathDateTimeValue();
dateOperand.Value = DateTime.Parse(currentToken.Text);
operand = dateOperand;
tokenizer.MoveNext();
}
else if (currentToken.IsType("decimal"))
{
NPathDecimalValue decimalOperand = new NPathDecimalValue();
decimalOperand.Value = double.Parse(currentToken.Text, NumberFormatInfo.InvariantInfo);
decimalOperand.IsNegative = isNegative;
operand = decimalOperand;
tokenizer.MoveNext();
}
else if (currentToken.IsType("string"))
{
NPathStringValue stringOperand = new NPathStringValue();
string text = currentToken.Text;
text = text.Substring(1, text.Length - 2);
if (currentToken.IsType("string '")) // do not localize
{
text = text.Replace("''", "'");
}
else if (currentToken.IsType("string \""))
{
text = text.Replace("\"\"", "\""); // do not localize
}
stringOperand.Value = text;
operand = stringOperand;
tokenizer.MoveNext();
}
else if (currentToken.IsType("boolean"))
{
NPathBooleanValue booleanOperand = new NPathBooleanValue();
booleanOperand.Value = bool.Parse(currentToken.Text);
operand = booleanOperand;
tokenizer.MoveNext();
}
else if (currentToken.IsType("guid"))
{
NPathGuidValue guidOperand = new NPathGuidValue();
guidOperand.Value = currentToken.Text;
operand = guidOperand;
tokenizer.MoveNext();
}
else if (currentToken.IsType("property path")) // do not localize
{
if (tokenizer.GetNextToken().IsType("("))
{
string fullPath = currentToken.Text;
string propertyPath = "";
string methodName = "";
int lastIndexOfDot = fullPath.LastIndexOf(".");
if (lastIndexOfDot > 0)
{
propertyPath = fullPath.Substring(0, lastIndexOfDot);
methodName = fullPath.Substring(lastIndexOfDot + 1);
}
else
{
methodName = fullPath;
}
NPathMethodCall call = new NPathMethodCall();
call.MethodName = methodName;
call.PropertyPath = new NPathIdentifier();
call.PropertyPath.Path = propertyPath;
call.PropertyPath.IsNegative = isNegative;
//TODO:add method support here
tokenizer.MoveNext(); //move past "("
tokenizer.MoveNext();
while (!tokenizer.GetCurrentToken().IsType(")"))
{
IValue param = ParseExpression();
call.Parameters.Add(param);
if (tokenizer.GetCurrentToken().IsType("comma"))
{
tokenizer.MoveNext();
}
else
{
tokenizer.GetCurrentToken(")", ")");
}
}
tokenizer.MoveNext();
operand = call;
}
else if (tokenizer.GetNextToken().IsType("["))
{
CurrentPropertyPrefix = currentToken.Text + ".";
NPathBracketGroup bracketGroup = new NPathBracketGroup();
tokenizer.MoveNext();
ParseBracketGroup(bracketGroup);
CurrentPropertyPrefix = "";
NPathParenthesisGroup parens = new NPathParenthesisGroup();
parens.Expression = bracketGroup.Expression;
operand = parens;
}
else
{
NPathIdentifier propertyOperand = new NPathIdentifier();
propertyOperand.Path = CurrentPropertyPrefix + currentToken.Text;
propertyOperand.ReferenceLocation = IsInSelectClause() ? NPathPropertyPathReferenceLocation.SelectClause : NPathPropertyPathReferenceLocation.WhereClause;
//CurrentQuery.AddPropertyPathReference(propertyOperand.Path) ;
propertyOperand.IsNegative = isNegative;
operand = propertyOperand;
tokenizer.MoveNext();
}
}
else if (currentToken.IsType("("))
{
NPathParenthesisGroup parenthesisOperand = new NPathParenthesisGroup();
ParseParenthesisGroup(parenthesisOperand);
parenthesisOperand.IsNegative = isNegative;
operand = parenthesisOperand;
}
else
{
//unknown value?
throw GetUnknownTokenException();
}
#endregion
return(operand);
}
