public static BasicFilterBase Clone(this BasicFilterBase filter)
{
if (filter == null)
{
return(null);
}
var criteria = filter as BasicFilter;
if (criteria != null)
{
return(Clone(criteria));
}
return(Clone((BasicFilterGroup)filter));
}
public BaseCriteria Convert(BasicFilterBase node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
var sub = node as BasicFilterGroup;
if (sub != null)
{
return(Convert(sub));
}
else
{
return(Convert((BasicFilter)node));
}
}
public static void ForEach(this BasicFilterBase filter,
Action <BasicFilterBase> handler)
{
if (filter == null)
{
return;
}
var c = filter as BasicFilterGroup;
if (c != null)
{
foreach (var g in c.Nodes)
{
ForEach(g, handler);
}
}
else
{
handler(filter);
}
}
public static void ForEachCriteria(this BasicFilterBase filter,
Action <BasicFilter> handler)
{
if (filter == null)
{
return;
}
var c = filter as BasicFilter;
if (c != null)
{
handler(c);
}
else
{
foreach (var g in ((BasicFilterGroup)filter).Nodes)
{
ForEachCriteria(g, handler);
}
}
}
public static SqlQuery ApplyFilters(this SqlQuery query,
BasicFilterBase filter,
IList <FilterLine> filterLines,
Row row,
Func <BasicFilter, BaseCriteria> processCriteria,
FilterFields filterFields)
{
if (Object.ReferenceEquals(filter, null) &&
(filterLines == null ||
filterLines.Count == 0))
{
return(query);
}
var converter = new BasicFilterStringConverter(query, row, processCriteria, filterFields);
BaseCriteria where;
if (!Object.ReferenceEquals(filter, null))
{
where = converter.Convert(filter);
if (!where.IsEmpty)
{
query.Where(where);
}
}
if (filterLines != null &&
filterLines.Count > 0)
{
var linesFilter = filterLines.ToBasicFilter();
where = converter.Convert(linesFilter);
if (!where.IsEmpty)
{
query.Where(where);
}
}
return(query);
}
public static BasicFilterBase Merge(this BasicFilterBase left, LogicalOp op, BasicFilterBase right)
{
var leftCriteria = left as BasicFilter;
var rightCriteria = right as BasicFilter;
var leftGroup = left as BasicFilterGroup;
var rightGroup = right as BasicFilterGroup;
if (left == null ||
right == null)
{
return(left ?? right);
}
else if (leftCriteria != null &&
rightCriteria != null)
{
return(new BasicFilterGroup(op, leftCriteria, rightCriteria));
}
else if (leftCriteria != null)
{
if (op == rightGroup.Operator)
{
rightGroup.Nodes.Insert(0, leftCriteria);
return(rightGroup);
}
else
{
return(new BasicFilterGroup(op, leftCriteria, rightGroup));
}
}
else if (rightCriteria != null)
{
if (leftGroup.Operator == op)
{
leftGroup.Nodes.Add(rightCriteria);
return(leftGroup);
}
else
{
return(new BasicFilterGroup(op, leftGroup, rightCriteria));
}
}
else
{
if (leftGroup.Operator == rightGroup.Operator &&
op == leftGroup.Operator)
{
leftGroup.Nodes.AddRange(rightGroup.Nodes);
return(leftGroup);
}
else if (leftGroup.Operator == op)
{
leftGroup.Nodes.Add(rightGroup);
return(leftGroup);
}
else if (rightGroup.Operator == op)
{
rightGroup.Nodes.Insert(0, leftGroup);
return(rightGroup);
}
else
{
return(new BasicFilterGroup(op, leftGroup, rightGroup));
}
}
}
public static bool IsSame(this BasicFilterBase filter, BasicFilterBase other)
{
if (filter == null)
{
return(other == null);
}
var g = filter as BasicFilterGroup;
if (g != null)
{
var go = other as BasicFilterGroup;
if (go == null)
{
return(false);
}
if (g.Nodes.Count != go.Nodes.Count)
{
return(false);
}
for (var i = 0; i < g.Nodes.Count; i++)
{
if (!IsSame(g.Nodes[i], go.Nodes[i]))
{
return(false);
}
}
}
else
{
BasicFilter c = (BasicFilter)filter;
BasicFilter co = other as BasicFilter;
if (co == null)
{
return(false);
}
if (c.Field != co.Field)
{
return(false);
}
if (c.Operator != co.Operator)
{
return(false);
}
if (c.Value != co.Value)
{
return(false);
}
if (c.Value2 != co.Value2)
{
return(false);
}
if ((c.Values == null) != (co.Values == null))
{
return(false);
}
if (c.Values != null)
{
if (c.Values.Length != co.Values.Length)
{
return(false);
}
for (var i = 0; i < c.Values.Length; i++)
{
if (c.Values[i] != co.Values[i])
{
return(false);
}
}
}
}
return(true);
}
public static BasicFilterBase ToBasicFilter(this IList <FilterLine> lines)
{
if (lines == null)
{
throw new ArgumentNullException("lines");
}
if (lines.Count == 0)
{
return(null);
}
bool inParens = false;
// http://en.wikipedia.org/wiki/Shunting_yard_algorithm
// http://en.wikipedia.org/wiki/Reverse_Polish_Notation
List <BasicFilter> filters = new List <BasicFilter>(lines.Count);
List <int> rpnOutput = new List <int>(lines.Count * 2); // will contain negative or indexes of items
Stack <int> rpnStack = new Stack <int>(lines.Count * 2);
int intLeftParen = -1;
int intAnd = -2;
int intOr = -3;
int index = 0;
foreach (FilterLine line in lines)
{
if (inParens &&
(line.RightParen || line.LeftParen))
{
while (true)
{
var token = rpnStack.Pop();
if (token == intLeftParen)
{
break;
}
rpnOutput.Add(token);
}
inParens = false;
}
if (index > 0)
{
var token = line.OR ? intOr : intAnd;
while (true)
{
if (rpnStack.Count == 0)
{
break;
}
var topToken = rpnStack.Peek();
if (topToken < intLeftParen &&
token <= topToken)
{
rpnOutput.Add(rpnStack.Pop());
}
else
{
break;
}
}
rpnStack.Push(token);
}
if (line.LeftParen)
{
rpnStack.Push(intLeftParen);
}
rpnOutput.Add(index);
index++;
}
if (inParens)
{
while (true)
{
var token = rpnStack.Pop();
if (token == intLeftParen)
{
break;
}
rpnOutput.Add(token);
}
}
while (rpnStack.Count > 0)
{
var token = rpnStack.Pop();
if (token == intLeftParen)
{
throw new InvalidOperationException("mismatched leftParen in RPN stack!");
}
rpnOutput.Add(token);
}
var evaluationStack = new Stack <BasicFilterBase>();
foreach (var input in rpnOutput)
{
if (input >= 0)
{
BasicFilter item = new BasicFilter();
var line = lines[input];
item.Field = line.Field;
item.Operator = line.Op;
item.Value = line.Value;
item.Values = line.Values;
evaluationStack.Push(item);
}
else
{
if (evaluationStack.Count < 2)
{
throw new InvalidOperationException("RPN evaluation stack has less than two items!");
}
LogicalOp op = input == intAnd ? LogicalOp.And : LogicalOp.Or;
var right = evaluationStack.Pop();
var left = evaluationStack.Pop();
BasicFilterBase result = left.Merge(op, right);
evaluationStack.Push(result);
}
}
if (evaluationStack.Count > 1)
{
throw new InvalidOperationException("RPN evaluation stack has more than one item!");
}
return(evaluationStack.Pop());
}
protected virtual BasicFilterBase VisitBinary(BinaryExpression b)
{
if (b.Left == null || b.Right == null)
{
throw new NotSupportedException("Left or Right is null!");
}
if (b.Conversion != null)
{
throw new NotSupportedException("Expression has conversion!");
}
switch (b.NodeType)
{
case ExpressionType.And:
case ExpressionType.AndAlso:
case ExpressionType.Or:
case ExpressionType.OrElse:
BasicFilterBase leftNode = this.Visit(b.Left);
BasicFilterBase rightNode = this.Visit(b.Right);
LogicalOp logical;
switch (b.NodeType)
{
case ExpressionType.And:
case ExpressionType.AndAlso: logical = LogicalOp.And; break;
case ExpressionType.Or:
case ExpressionType.OrElse: logical = LogicalOp.Or; break;
default: throw new NotSupportedException("Unexpected Node Type Error!");
}
return(leftNode.Merge(logical, rightNode));
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.Equal:
case ExpressionType.NotEqual:
var left = b.Left as MemberExpression;
if (left == null)
{
//bool isValid = false;
var methodCall = b.Left as MethodCallExpression;
if (methodCall != null)
{
var member = IsStaticStringCompare(methodCall);
if (member != null)
{
}
}
throw new NotSupportedException("Left must be a MemberExpression!");
}
var right = b.Right as ConstantExpression;
if (right == null)
{
throw new NotSupportedException("Right must be a ConstantExpression!");
}
var op = FilterOp.EQ;
switch (b.NodeType)
{
case ExpressionType.LessThan: op = FilterOp.LT; break;
case ExpressionType.LessThanOrEqual: op = FilterOp.LE; break;
case ExpressionType.GreaterThan: op = FilterOp.GT; break;
case ExpressionType.GreaterThanOrEqual: op = FilterOp.GE; break;
case ExpressionType.Equal: op = FilterOp.EQ; break;
case ExpressionType.NotEqual: op = FilterOp.NE; break;
default: throw new NotSupportedException("Unexpected Node Type Error!");
}
return(new BasicFilter()
{
Field = "Dummy",
Operator = op,
Value = "Dummy"
});
default:
throw new NotSupportedException("Unsupported expression type: " + b.NodeType.ToString());
}
}
