private static FilterBuilder <T> GetOrFilterForNumericRange <T>(ITypeSearch <T> query, IEnumerable <SelectableNumericRange> range, string fieldName, Type type) { // Appends type convention to field name (like "$$string") var client = query.Client; var fullFieldName = client.GetFullFieldName(fieldName, type); var filters = new List <Filter>(); foreach (var rangeItem in range) { var rangeFilter = RangeFilter.Create(fullFieldName, rangeItem.From ?? 0, rangeItem.To ?? double.MaxValue); rangeFilter.IncludeUpper = false; filters.Add(rangeFilter); } var orFilter = new OrFilter(filters); var filterBuilder = new FilterBuilder <T>(client, orFilter); return(filterBuilder); }
// Token: 0x06001240 RID: 4672 RVA: 0x00062F44 File Offset: 0x00061144 public static QueryFilter BuildMessageClassFilter(IList <string> supportedIpmTypes) { QueryFilter result; switch (supportedIpmTypes.Count) { case 0: result = AirSyncXsoSchemaState.FalseFilterInstance; break; case 1: result = new TextFilter(StoreObjectSchema.ItemClass, supportedIpmTypes[0], MatchOptions.PrefixOnWords, MatchFlags.IgnoreCase); break; default: { QueryFilter[] array = new QueryFilter[supportedIpmTypes.Count]; for (int i = 0; i < supportedIpmTypes.Count; i++) { array[i] = new TextFilter(StoreObjectSchema.ItemClass, supportedIpmTypes[i], MatchOptions.PrefixOnWords, MatchFlags.IgnoreCase); } result = new OrFilter(array); break; } } return(result); }
/// <summary> /// /// </summary> /// <param name="p"></param> /// <param name="filter"></param> /// <returns></returns> public string VisitOrFilter(Hashtable p, OrFilter filter) { var l = filter.Left.Accept <String, Hashtable>(this, p); var r = filter.Right.Accept <String, Hashtable>(this, p); return(string.Format("{0} -or {1}", l, r)); }
public void ShouldBeComposableWithOthersFilters() { var aFalseFilter = new FakeFalseFilter(); var sut = new OrFilter(new Filter[] { new OrFilter(new Filter[] { aFalseFilter }), new FakeTrueFilter() }); Assert.True(sut.Evaluate(null)); Assert.True(aFalseFilter.Called); }
public void ShouldFormat() { IOrFilter filter; filter = new OrFilter(JobTable.Description.IsEqualTo("test"), JobTable.Description.IsEqualTo("test")); Assert.AreEqual(2, filter.Members.Count()); Assert.AreEqual("(C1 OR C2)", filter.Format(new string[] { "C1", "C2" })); }
public void OrFilter_Constructor() { var filter = new OrFilter(new CategoryFilter("Dummy"), new CategoryFilter("Another")); Assert.False(filter.IsEmpty); Assert.That(filter.Match(dummyFixture)); Assert.That(filter.Match(anotherFixture)); }
protected Dictionary <IFilter <IIdentifiedSpectrum>, string> GetFilterMap() { Dictionary <IFilter <IIdentifiedSpectrum>, string> map = new Dictionary <IFilter <IIdentifiedSpectrum>, string>(); Regex reg = new Regex(@"\(([^()]+?)\:([^()]+?)\)"); List <IFilter <IIdentifiedSpectrum> > matchedFilters = new List <IFilter <IIdentifiedSpectrum> >(); string defaultTitle = null; Match match = reg.Match(modifiedAminoacids.Text); if (!match.Success) { throw new Exception("Couldn't recognize modification pattern, it should like \n" + DEFAULT_PATTERN); } while (match.Success) { if (match.Groups[1].Value.Trim().Equals("DEFAULT")) { defaultTitle = match.Groups[2].Value.Trim(); } else { string title = match.Groups[2].Value.Trim(); string[] parts = Regex.Split(match.Groups[1].Value, @"\s+"); List <IFilter <IIdentifiedSpectrum> > filters = new List <IFilter <IIdentifiedSpectrum> >(); foreach (string part in parts) { if (part.Length > 0) { filters.Add(new IdentifiedSpectrumSequenceFilter(part)); } } OrFilter <IIdentifiedSpectrum> filter = new OrFilter <IIdentifiedSpectrum>(filters); map[filter] = title; matchedFilters.Add(filter); } match = match.NextMatch(); } if (defaultTitle == null) { throw new Exception("No default name defined, the pattern should like \n" + DEFAULT_PATTERN); } NotFilter <IIdentifiedSpectrum> notFilter = new NotFilter <IIdentifiedSpectrum>(new OrFilter <IIdentifiedSpectrum>(matchedFilters)); map[notFilter] = defaultTitle; return(map); }
private static TestFilter FromXml(TNode node) { switch (node.Name) { case "filter": case "and": var andFilter = new AndFilter(); foreach (var childNode in node.ChildNodes) { andFilter.Add(FromXml(childNode)); } return(andFilter); case "or": var orFilter = new OrFilter(); foreach (var childNode in node.ChildNodes) { orFilter.Add(FromXml(childNode)); } return(orFilter); case "not": return(new NotFilter(FromXml(node.FirstChild))); case "id": var idFilter = new IdFilter(); if (node.Value != null) { foreach (string id in node.Value.Split(COMMA)) { idFilter.Add(id); } } return(idFilter); case "tests": var testFilter = new SimpleNameFilter(); foreach (var childNode in node.SelectNodes("test")) { testFilter.Add(childNode.Value); } return(testFilter); case "cat": var catFilter = new CategoryFilter(); if (node.Value != null) { foreach (string cat in node.Value.Split(COMMA)) { catFilter.AddCategory(cat); } } return(catFilter); default: throw new ArgumentException("Invalid filter element: " + node.Name, "xmlNode"); } }
public void TestSingleLine7() { var filter = new OrFilter(new[] { new SubstringFilter("foo", false), new SubstringFilter("bar", false) }); filter.PassesFilter(new LogEntry(Core.Columns.RawContent) { RawContent = "FOOBAR" }).Should().BeFalse(); }
public void TestToString() { var filter = new OrFilter(new[] { new SubstringFilter("foo", true) }); filter.ToString().Should().Be("message.Contains(foo, InvariantCultureIgnoreCase)"); filter = new OrFilter(new ILogEntryFilter[] { new SubstringFilter("foo", true), new LevelFilter(LevelFlags.Info) }); filter.ToString().Should().Be("message.Contains(foo, InvariantCultureIgnoreCase) || level == Info"); }
internal static IEnumerable <ExtendedOrganizationalUnit> FindSubTreeChildOrganizationalUnit(bool includeContainers, IConfigurationSession session, ADObjectId rootId, QueryFilter preFilter) { QueryFilter queryFilter = new OrFilter(new QueryFilter[] { new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.ObjectCategory, ADOrganizationalUnit.MostDerivedClass), new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.ObjectCategory, ADDomain.MostDerivedClass) }); if (!ExtendedOrganizationalUnit.IsTenant(session)) { IList <QueryFilter> list = new List <QueryFilter>(); IList <QueryFilter> list2 = new List <QueryFilter>(); IEnumerable <ADDomain> enumerable = ADForest.GetLocalForest(session.DomainController).FindDomains(); foreach (ADDomain addomain in enumerable) { ExchangeOrganizationalUnit exchangeOrganizationalUnit = session.ResolveWellKnownGuid <ExchangeOrganizationalUnit>(WellKnownGuid.DomainControllersWkGuid, addomain.Id); if (exchangeOrganizationalUnit != null) { list.Add(new ComparisonFilter(ComparisonOperator.NotEqual, ADObjectSchema.Id, exchangeOrganizationalUnit.Id)); } ExchangeOrganizationalUnit exchangeOrganizationalUnit2 = session.ResolveWellKnownGuid <ExchangeOrganizationalUnit>(WellKnownGuid.UsersWkGuid, addomain.Id); if (exchangeOrganizationalUnit2 != null) { list2.Add(new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Id, exchangeOrganizationalUnit2.Id)); } } foreach (QueryFilter queryFilter2 in list) { queryFilter = new AndFilter(new QueryFilter[] { queryFilter, queryFilter2 }); } if (includeContainers) { foreach (QueryFilter queryFilter3 in list2) { queryFilter = new OrFilter(new QueryFilter[] { queryFilter, queryFilter3 }); } } } if (preFilter != null) { queryFilter = new AndFilter(new QueryFilter[] { preFilter, queryFilter }); } return(session.FindPaged <ExtendedOrganizationalUnit>(rootId, QueryScope.SubTree, queryFilter, null, 0)); }
public void IsMatchCombinations(bool expectedMatch, bool[] states) { Filter<object>[] filters = GenericCollectionUtils.ConvertAllToArray<bool, Filter<object>>(states, delegate(bool state) { return state ? (Filter<object>)new AnyFilter<object>() : new NoneFilter<object>(); }); OrFilter<object> combinator = new OrFilter<object>(filters); Assert.AreEqual(expectedMatch, combinator.IsMatch(null)); }
internal static List <RetentionPolicyTag> FindRetentionPolicyTag(IConfigurationSession session, Guid tagGuid) { OrFilter filter = new OrFilter(new QueryFilter[] { new ComparisonFilter(ComparisonOperator.Equal, RetentionPolicyTagSchema.RetentionId, tagGuid), new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Guid, tagGuid) }); return(ELCTaskHelper.FindElcObject <RetentionPolicyTag>(session, null, filter)); }
internal static QueryFilter MailboxPlanReleaseFilterBuilder(SinglePropertyFilter filter) { if (!(filter is ComparisonFilter)) { throw new ADFilterException(DirectoryStrings.ExceptionUnsupportedFilterForProperty(filter.Property.Name, filter.GetType(), typeof(ComparisonFilter))); } ComparisonFilter comparisonFilter = (ComparisonFilter)filter; if (comparisonFilter.ComparisonOperator != ComparisonOperator.Equal && ComparisonOperator.NotEqual != comparisonFilter.ComparisonOperator) { throw new ADFilterException(DirectoryStrings.ExceptionUnsupportedOperatorForProperty(comparisonFilter.Property.Name, comparisonFilter.ComparisonOperator.ToString())); } if (!(comparisonFilter.PropertyValue is MailboxPlanRelease)) { throw new ArgumentException("filter.PropertyValue"); } MailboxPlanRelease mailboxPlanRelease = (MailboxPlanRelease)comparisonFilter.PropertyValue; if (mailboxPlanRelease != MailboxPlanRelease.AllReleases) { if (mailboxPlanRelease != MailboxPlanRelease.CurrentRelease) { if (mailboxPlanRelease != MailboxPlanRelease.NonCurrentRelease) { throw new ArgumentException("filter.PropertyValue"); } if (comparisonFilter.ComparisonOperator == ComparisonOperator.Equal) { return(Microsoft.Exchange.Data.Directory.Management.MailboxPlan.NonCurrentReleaseFilter); } return(new NotFilter(Microsoft.Exchange.Data.Directory.Management.MailboxPlan.NonCurrentReleaseFilter)); } else { if (comparisonFilter.ComparisonOperator == ComparisonOperator.Equal) { return(Microsoft.Exchange.Data.Directory.Management.MailboxPlan.CurrentReleaseFilter); } return(new NotFilter(Microsoft.Exchange.Data.Directory.Management.MailboxPlan.CurrentReleaseFilter)); } } else { QueryFilter queryFilter = new OrFilter(new QueryFilter[] { Microsoft.Exchange.Data.Directory.Management.MailboxPlan.CurrentReleaseFilter, Microsoft.Exchange.Data.Directory.Management.MailboxPlan.NonCurrentReleaseFilter }); if (ComparisonOperator.NotEqual == comparisonFilter.ComparisonOperator) { return(queryFilter); } return(new NotFilter(queryFilter)); } }
public void MulitpleTestCaseIdMatch() { OrFilter filter = new OrFilter(CreateIdFilter(_mock1), CreateIdFilter(_mock3)); Assert.IsTrue(filter.Pass(_mock1), "Filter did not pass MockTest1"); Assert.IsFalse(filter.Pass(_mock2), "Filter should not have passed MockTest2"); Assert.IsTrue(filter.Pass(_mock3), "Filter did not pass MockTest3"); Assert.IsFalse(filter.Pass(_explicitTest), "Filter should not have passed ExplicitlyRunTest"); Assert.IsTrue(filter.Pass(_fixture), "Filter did not pass MockTestFixture"); Assert.IsTrue(filter.Pass(_suite), "Filter did not pass TopLevelSuite"); }
public void TestMultiLine2() { var filter = new OrFilter(new[] { new SubstringFilter("foo", true) }); var lines = new[] { new LogLine(0, 0, "fo", LevelFlags.All), new LogLine(0, 0, "obar", LevelFlags.All) }; filter.PassesFilter(lines).Should().BeFalse("because substring filters shouldn't be matched across lines"); }
public void TestMultiLine1() { var filter = new OrFilter(new[] { new SubstringFilter("foo", true) }); var lines = new[] { new LogLine(0, 0, "bar", LevelFlags.All), new LogLine(0, 0, "foo", LevelFlags.All) }; filter.PassesFilter(lines).Should().BeTrue("because it should be enough to have a hit on one line of a multi line entry"); }
public void TestSingleLine3() { var filter = new OrFilter(new[] { new SubstringFilter("foo", true) }); var line = new LogLine(0, 0, "bar", LevelFlags.All); filter.PassesFilter(line).Should().BeFalse(); var matches = filter.Match(line); matches.Should().NotBeNull(); matches.Should().BeEmpty(); }
public void IsMatchCombinations(bool expectedMatch, bool[] states) { Filter <object>[] filters = GenericCollectionUtils.ConvertAllToArray <bool, Filter <object> >(states, delegate(bool state) { return(state ? (Filter <object>) new AnyFilter <object>() : new NoneFilter <object>()); }); OrFilter <object> combinator = new OrFilter <object>(filters); Assert.AreEqual(expectedMatch, combinator.IsMatch(null)); }
private static bool EvaluateOrFilter(OrFilter filterOr, IReadOnlyPropertyBag propertyBag, bool shouldThrow) { foreach (QueryFilter filter in filterOr.Filters) { if (EvaluatableFilter.Evaluate(filter, propertyBag, shouldThrow)) { return(true); } } return(false); }
private static string CreateOrFilter(OrFilter orFilter, IList <Field> availableFields) { string result = null; if (orFilter.ChildFilters != null) { var childExpressions = orFilter.ChildFilters.Select(q => GetFilterExpressionRecursive(q, availableFields)).ToArray(); result = AzureSearchHelper.JoinNonEmptyStrings(" or ", true, childExpressions); } return(result); }
public Dictionary <string, object> VisitOrFilter(Hashtable p, OrFilter filter) { var dic = new Dictionary <String, Object> { { Not, false }, { Left, filter.Left.Accept <Dictionary <String, Object>, Hashtable>(this, p) }, { Right, filter.Right.Accept <Dictionary <String, Object>, Hashtable>(this, p) }, { Operation, Or } }; return(dic); }
public void TestOrFilter() { ContainsFilter left1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo", "bar")); ContainsFilter right1 = new ContainsFilter(ConnectorAttributeBuilder.Build("foo2", "bar2")); OrFilter v1 = new OrFilter(left1, right1); OrFilter v2 = (OrFilter)CloneObject(v1); ContainsFilter left2 = (ContainsFilter)v2.Left; ContainsFilter right2 = (ContainsFilter)v2.Right; Assert.AreEqual(left1.GetAttribute(), left2.GetAttribute()); Assert.AreEqual(right1.GetAttribute(), right2.GetAttribute()); }
private static Filter CreateOrFilter(OrFilter orFilter, ICollection <string> availableFields) { Filter result = null; if (orFilter?.ChildFilters != null) { var childFilters = orFilter.ChildFilters.Select(filter => GetFilterRecursive(filter, availableFields)); result = JoinNonEmptyFilters(childFilters, Occur.SHOULD); } return(result); }
private static TestFilter FromXml(XmlNode xmlNode) { switch (xmlNode.Name) { case "filter": case "and": var andFilter = new AndFilter(); foreach (XmlNode childNode in xmlNode.ChildNodes) { andFilter.Add(FromXml(childNode)); } return(andFilter); case "or": var orFilter = new OrFilter(); foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes) { orFilter.Add(FromXml(childNode)); } return(orFilter); case "not": return(new NotFilter(FromXml(xmlNode.FirstChild))); case "id": var idFilter = new IdFilter(); foreach (string id in xmlNode.InnerText.Split(COMMA)) { idFilter.Add(int.Parse(id)); } return(idFilter); case "tests": var testFilter = new SimpleNameFilter(); foreach (XmlNode childNode in xmlNode.SelectNodes("test")) { testFilter.Add(childNode.InnerText); } return(testFilter); case "cat": var catFilter = new CategoryFilter(); foreach (string cat in xmlNode.InnerText.Split(COMMA)) { catFilter.AddCategory(cat); } return(catFilter); default: throw new ArgumentException("Invalid filter element: " + xmlNode.Name, "xmlNode"); } }
public void OrAndMinusCombined() { CategoryExpression expr = new CategoryExpression("A|B-C-D|E"); OrFilter orFilter = (OrFilter)expr.Filter; Assert.AreEqual(orFilter.Filters.Length, 3); AndFilter andFilter = (AndFilter)orFilter.Filters[1]; Assert.AreEqual(andFilter.Filters.Length, 3); Assert.AreEqual(andFilter.Filters[0], typeof(CategoryFilter)); Assert.AreEqual(andFilter.Filters[1], typeof(NotFilter)); Assert.AreEqual(andFilter.Filters[2], typeof(NotFilter)); }
public void OrAndMinusCombined() { CategoryExpression expr = new CategoryExpression("A|B-C-D|E"); OrFilter orFilter = (OrFilter)expr.Filter; Assert.That(orFilter.Filters.Length, Is.EqualTo(3)); AndFilter andFilter = (AndFilter)orFilter.Filters[1]; Assert.That(andFilter.Filters.Length, Is.EqualTo(3)); Assert.That(andFilter.Filters[0], Is.TypeOf(typeof(CategoryFilter))); Assert.That(andFilter.Filters[1], Is.TypeOf(typeof(NotFilter))); Assert.That(andFilter.Filters[2], Is.TypeOf(typeof(NotFilter))); }
private static QueryContainer CreateOrFilter(OrFilter orFilter, Properties <IProperties> availableFields) { QueryContainer result = null; if (orFilter?.ChildFilters != null) { foreach (var childQuery in orFilter.ChildFilters) { result |= GetFilterQueryRecursive(childQuery, availableFields); } } return(result); }
public void TestSingleLine3() { var filter = new OrFilter(new[] { new SubstringFilter("foo", true) }); var line = new LogEntry(Core.Columns.RawContent) { RawContent = "bar" }; filter.PassesFilter(line).Should().BeFalse(); var matches = filter.Match(line); matches.Should().NotBeNull(); matches.Should().BeEmpty(); }
public void CanParseMultipleAlternatives() { CategoryExpression expr = new CategoryExpression("One|Two|Three"); OrFilter orFilter = (OrFilter)expr.Filter; Assert.AreEqual(orFilter.Filters.Length, 3); CategoryFilter catFilter = (CategoryFilter)orFilter.Filters[0]; Assert.AreEqual(catFilter.Categories, new string[] { "One" }); catFilter = (CategoryFilter)orFilter.Filters[1]; Assert.AreEqual(catFilter.Categories, new string[] { "Two" }); catFilter = (CategoryFilter)orFilter.Filters[2]; Assert.AreEqual(catFilter.Categories, new string[] { "Three" }); }
private void wrapIntoAnySubfiltersToolStripMenuItem_Click(object sender, EventArgs e) { if (FilterTree.Nodes.Count == 0) { return; } TreeNode selected_node = FilterTree.SelectedNode; if (selected_node == null) { return; } OrFilter fl = new OrFilter(); TreeNode or_node = new TreeNode() { Text = fl.ToString(), Tag = fl }; // check if the node is the root if (selected_node.Parent == null) { FilterTree.Nodes.Clear(); FilterTree.Nodes.Add(or_node); SearchFilter = fl; } else { TreeNode pt = selected_node.Parent; pt.Nodes.Insert(pt.Nodes.IndexOf(selected_node), or_node); pt.Nodes.Remove(selected_node); if (pt.Tag is OrFilter) { ((OrFilter)pt.Tag).Filters.Add(fl); ((OrFilter)pt.Tag).Filters.Remove((BaseFilter)selected_node.Tag); } else if (pt.Tag is AndFilter) { ((AndFilter)pt.Tag).Filters.Add(fl); ((AndFilter)pt.Tag).Filters.Remove((BaseFilter)selected_node.Tag); } } fl.Filters.Add((BaseFilter)selected_node.Tag); or_node.Nodes.Add(selected_node); FilterTree.SelectedNode = selected_node; ShowFilterProperties((BaseFilter)selected_node.Tag); }
static ItemFilter ParseCategory(string category) { string[] filters = category.Split(','); var itemFilters = new ItemFilter[filters.Length]; for (int i = 0; i < filters.Length; i++) { string[] orParts = filters[i].Split('|'); ItemFilter orFilter = null; for (int j = 0; j < orParts.Length; j++) { ItemFilter filter; if (orParts[j].StartsWith("$$")) { filter = ParseSpecialCategory(orParts[j]); } else if (orParts[j].StartsWith("!")) { filter = new NotFilter(Identifier.Get(orParts[j].Substring(1))); } else { filter = new CategoryFilter(Identifier.Get(orParts[j])); } if (orFilter == null) { orFilter = filter; } else { orFilter = new OrFilter(orFilter, filter); } } itemFilters[i] = orFilter; } if (itemFilters.Length == 1) { return itemFilters[0]; } else { return new AndFilter(itemFilters); } }