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()); } }