public WhereClauseVisitor(MemberFilterAggregator aggregator, FilterGroup filter) { _aggregator = aggregator; _filter = filter; }
public static Expression Visit(Expression expression, MemberFilterAggregator aggregator, FilterGroup filter = null) { return new WhereClauseVisitor(aggregator, filter).Visit(expression); }
private void ProcessValue(ConstantExpression item, FilterGroup root) { if (root == null) throw new ArgumentException("the filter should be of specific type"); var filter = root.Filters.Peek() as Filter; if (filter == null) return; switch (filter.FilterBy) { case FilterBy.NotSet: root.Filters.Pop(); break; case FilterBy.BindingFlags: var intValue = (int)item.Value; filter.BindingFlags = BindingFlagsMappinsg[intValue - 1]; break; case FilterBy.Name: filter.Name = item.Value.ToString(); break; case FilterBy.Type: filter.Type = item.Value as Type; break; case FilterBy.MemberType: filter.MemberTypes = (MemberTypes)item.Value; break; default: root.Filters.Pop(); break; } }
private MemberCacheDescriptor ToDescriptor(FilterGroup group) { var descriptors = new List<MemberCacheDescriptor>(); while (group.Filters.Any()) { var filter = group.Filters.Pop(); switch (filter.FilterType) { case FilterType.Group: descriptors.Add(ToDescriptor((FilterGroup)filter)); break; case FilterType.Filter: descriptors.Add(ToDescriptor((Filter)filter)); break; default: throw new ArgumentOutOfRangeException(); } } switch (group.GroupKind) { case FilterGroupKind.And: case FilterGroupKind.Root: return MergeDescriptorsUsingAnd(descriptors); case FilterGroupKind.Or: return MergeDescriptorsUsingOr(descriptors); default: throw new ArgumentOutOfRangeException(); } }
private FilterGroup ProcessOr(FilterGroup root) { var group = new FilterGroup {GroupKind = FilterGroupKind.Or}; root.Filters.Push(group); return group; }
private void ProcessMember(MemberExpression expression, FilterGroup root) { var filterBy = ResolvePropertyType(expression.Member); if (filterBy == FilterBy.Unknown && root.Filters.Peek() is Filter) root.Filters.Pop(); var filter = (Filter)root.Filters.Peek(); filter.FilterBy = filterBy; }
private void ProcessCondition(FilterExpression filterExpression, FilterGroup root) { var filter = new Filter(); root.Filters.Push(filter); filter.FilterExpression = filterExpression; }
private MemberCacheDescriptor ParseFilterTree(FilterGroup root) { return ToDescriptor(root); }
public virtual FilterGroup Push(Expression item, FilterGroup root = null) { root = root ?? _filterRoot; switch (item.NodeType) { case ExpressionType.Or: case ExpressionType.OrElse: return ProcessOr(root); case ExpressionType.NotEqual: case ExpressionType.Equal: ProcessCondition((FilterExpression)(int)item.NodeType, root); break; case ExpressionType.MemberAccess: ProcessMember(item as MemberExpression, root); break; case ExpressionType.Constant: ProcessValue(item as ConstantExpression, root); break; } return root; }