internal static QueryFilter SimplifyFilter(QueryFilter filter) { if (filter == null) { return(null); } if (filter.IsAtomic) { return(filter); } if (!(filter is NotFilter) && !(filter is CompositeFilter)) { return(filter); } NotFilter notFilter = filter as NotFilter; if (notFilter != null) { QueryFilter filter2 = notFilter.Filter; if (filter2.IsAtomic) { return(filter); } if (filter2 is NotFilter) { return(QueryFilter.SimplifyFilter(((NotFilter)filter2).Filter)); } if (filter2 is CompositeFilter) { CompositeFilter compositeFilter = (CompositeFilter)filter2; QueryFilter[] array = new QueryFilter[compositeFilter.Filters.Count]; for (int i = 0; i < array.Length; i++) { array[i] = QueryFilter.NotFilter(compositeFilter.Filters[i]); } if (filter2 is AndFilter) { return(QueryFilter.SimplifyFilter(QueryFilter.OrTogether(array))); } if (filter2 is OrFilter) { return(QueryFilter.SimplifyFilter(QueryFilter.AndTogether(array))); } } if (filter2 is ComparisonFilter) { ComparisonFilter comparisonFilter = (ComparisonFilter)filter2; ComparisonOperator comparisonOperator; switch (comparisonFilter.ComparisonOperator) { case ComparisonOperator.Equal: comparisonOperator = ComparisonOperator.NotEqual; break; case ComparisonOperator.NotEqual: comparisonOperator = ComparisonOperator.Equal; break; case ComparisonOperator.LessThan: comparisonOperator = ComparisonOperator.GreaterThanOrEqual; break; case ComparisonOperator.LessThanOrEqual: comparisonOperator = ComparisonOperator.GreaterThan; break; case ComparisonOperator.GreaterThan: comparisonOperator = ComparisonOperator.LessThanOrEqual; break; case ComparisonOperator.GreaterThanOrEqual: comparisonOperator = ComparisonOperator.LessThan; break; default: return(filter); } return(new ComparisonFilter(comparisonOperator, comparisonFilter.Property, comparisonFilter.PropertyValue)); } return(QueryFilter.NotFilter(QueryFilter.SimplifyFilter(filter2))); } else { AndFilter andFilter = filter as AndFilter; if (andFilter != null) { return(QueryFilter.SimplifyCompositeFilter <AndFilter, OrFilter>(andFilter)); } OrFilter orFilter = filter as OrFilter; if (orFilter != null) { return(QueryFilter.SimplifyCompositeFilter <OrFilter, AndFilter>(orFilter)); } return(filter); } }
private static QueryFilter SimplifyCompositeFilter <TFilter, TOther>(TFilter filter) where TFilter : CompositeFilter where TOther : CompositeFilter { List <QueryFilter> list = new List <QueryFilter>(); Stack <QueryFilter> stack = new Stack <QueryFilter>(); for (int i = filter.Filters.Count - 1; i >= 0; i--) { stack.Push(filter.Filters[i]); } while (stack.Count > 0) { QueryFilter queryFilter = stack.Pop(); NotFilter notFilter = queryFilter as NotFilter; if (queryFilter.IsAtomic || (notFilter != null && notFilter.Filter.IsAtomic)) { if (!list.Contains(queryFilter)) { list.Add(queryFilter); } } else if (notFilter != null) { if (notFilter.Filter is TOther) { TOther tother = notFilter.Filter as TOther; for (int j = tother.Filters.Count - 1; j >= 0; j--) { QueryFilter filter2 = tother.Filters[j]; stack.Push(QueryFilter.NotFilter(filter2)); } } else if (notFilter.Filter is NotFilter) { stack.Push((notFilter.Filter as NotFilter).Filter); } else { QueryFilter item = QueryFilter.SimplifyFilter(queryFilter); if (!list.Contains(item)) { list.Add(item); } } } else if (queryFilter is TFilter) { TFilter tfilter = queryFilter as TFilter; for (int k = tfilter.Filters.Count - 1; k >= 0; k--) { QueryFilter item2 = tfilter.Filters[k]; stack.Push(item2); } } else { QueryFilter item3 = QueryFilter.SimplifyFilter(queryFilter); if (!list.Contains(item3)) { list.Add(item3); } } } if (typeof(TFilter).Equals(typeof(AndFilter))) { return(QueryFilter.AndTogether(list.ToArray())); } return(QueryFilter.OrTogether(list.ToArray())); }
public override bool Equals(object obj) { NotFilter notFilter = obj as NotFilter; return(notFilter != null && notFilter.GetType() == base.GetType() && notFilter.filter.Equals(this.filter)); }
private static void GenerateInfixString(QueryFilter filter, StringBuilder sb, FilterSchema filterSchema) { if (filter is CompositeFilter) { sb.Append("("); CompositeFilter compositeFilter = (CompositeFilter)filter; int filterCount = compositeFilter.FilterCount; for (int i = 0; i < filterCount - 1; i++) { sb.Append("("); QueryFilter.GenerateInfixString(compositeFilter.Filters[i], sb, filterSchema); sb.Append(") "); if (filter is AndFilter) { sb.Append(filterSchema.And); } else if (filter is OrFilter) { sb.Append(filterSchema.Or); } sb.Append(" "); } sb.Append("("); QueryFilter.GenerateInfixString(compositeFilter.Filters[filterCount - 1], sb, filterSchema); sb.Append("))"); return; } if (filter is NotFilter) { NotFilter notFilter = filter as NotFilter; sb.Append(filterSchema.Not); sb.Append("("); QueryFilter.GenerateInfixString(notFilter.Filter, sb, filterSchema); sb.Append(")"); return; } if (filter is TextFilter) { TextFilter textFilter = filter as TextFilter; string propertyName = filterSchema.GetPropertyName(textFilter.Property.Name); if (!string.IsNullOrEmpty(propertyName)) { sb.Append(propertyName); sb.Append(filterSchema.Like); } if (textFilter.MatchOptions == MatchOptions.FullString || textFilter.MatchOptions == MatchOptions.ExactPhrase || filterSchema.SupportQuotedPrefix) { sb.Append(filterSchema.QuotationMark); } if (textFilter.MatchOptions == MatchOptions.Suffix || textFilter.MatchOptions == MatchOptions.SubString) { sb.Append("*"); } sb.Append(filterSchema.EscapeStringValue(textFilter.Text)); if (textFilter.MatchOptions == MatchOptions.Prefix || textFilter.MatchOptions == MatchOptions.SubString || textFilter.MatchOptions == MatchOptions.PrefixOnWords) { sb.Append("*"); } if (textFilter.MatchOptions == MatchOptions.FullString || textFilter.MatchOptions == MatchOptions.ExactPhrase || filterSchema.SupportQuotedPrefix) { sb.Append(filterSchema.QuotationMark); return; } } else { if (filter is ComparisonFilter) { ComparisonFilter comparisonFilter = filter as ComparisonFilter; sb.Append(filterSchema.GetPropertyName(comparisonFilter.Property.Name)); sb.Append(filterSchema.GetRelationalOperator(comparisonFilter.ComparisonOperator)); sb.Append(filterSchema.QuotationMark); sb.Append(filterSchema.EscapeStringValue(comparisonFilter.PropertyValue)); sb.Append(filterSchema.QuotationMark); return; } if (filter is ExistsFilter) { sb.Append(filterSchema.GetExistsFilter(filter as ExistsFilter)); return; } if (filter is FalseFilter) { sb.Append(filterSchema.GetFalseFilter()); } } }
public static bool FilterMatches(QueryFilter filter, IReadOnlyPropertyBag obj, Func <PropertyDefinition, object> getValueDelegate) { if (filter == null) { throw new ArgumentNullException("filter"); } if (getValueDelegate == null && obj == null) { throw new ArgumentNullException("getValueDelegate && obj"); } NotFilter notFilter = filter as NotFilter; if (notFilter != null) { return(!OpathFilterEvaluator.FilterMatches(notFilter.Filter, obj, getValueDelegate)); } AndFilter andFilter = filter as AndFilter; if (andFilter != null) { foreach (QueryFilter filter2 in andFilter.Filters) { if (!OpathFilterEvaluator.FilterMatches(filter2, obj, getValueDelegate)) { return(false); } } return(true); } OrFilter orFilter = filter as OrFilter; if (orFilter != null) { foreach (QueryFilter filter3 in orFilter.Filters) { if (OpathFilterEvaluator.FilterMatches(filter3, obj, getValueDelegate)) { return(true); } } return(false); } SinglePropertyFilter singlePropertyFilter = filter as SinglePropertyFilter; if (singlePropertyFilter != null) { SimpleProviderPropertyDefinition simpleProviderPropertyDefinition = singlePropertyFilter.Property as SimpleProviderPropertyDefinition; if (simpleProviderPropertyDefinition != null && simpleProviderPropertyDefinition.IsFilterOnly) { throw new FilterOnlyAttributesException(simpleProviderPropertyDefinition.Name); } object obj2 = (obj != null) ? obj[singlePropertyFilter.Property] : getValueDelegate(singlePropertyFilter.Property); if (OpathFilterEvaluator.IsNullOrEmpty(obj2)) { return(OpathFilterEvaluator.FilterMatchesValue(singlePropertyFilter, null)); } ICollection collection = obj2 as ICollection; if (collection != null) { foreach (object value in collection) { if (OpathFilterEvaluator.FilterMatchesValue(singlePropertyFilter, value)) { return(true); } } return(false); } return(OpathFilterEvaluator.FilterMatchesValue(singlePropertyFilter, obj2)); } else { CSharpFilter <IReadOnlyPropertyBag> csharpFilter = filter as CSharpFilter <IReadOnlyPropertyBag>; if (csharpFilter != null) { if (obj == null) { throw new ArgumentNullException("obj"); } return(csharpFilter.Match(obj)); } else { if (filter is TrueFilter) { return(true); } if (filter is FalseFilter) { return(false); } throw new NotSupportedException("The specified filter type \"" + filter.GetType().Name + "\" is currently not supported."); } } bool result; return(result); }