private Filter <T> MatchAndFilter(FilterLexer lexer) { var filters = new List <Filter <T> >(); Filter <T> firstFilter = MatchNegationFilter(lexer); filters.Add(firstFilter); FilterToken nextToken = LookAhead(lexer, 1); while (nextToken != null && nextToken.Type == FilterTokenType.And) { GetNextToken(lexer); filters.Add(MatchNegationFilter(lexer)); nextToken = LookAhead(lexer, 1); } if (filters.Count > 1) { return(new AndFilter <T>(filters)); } else { return(firstFilter); } }
private static Filter <string> MatchValue(FilterLexer lexer) { FilterToken nextToken = LookAhead(lexer, 1); if (nextToken != null) { if (nextToken.Type == FilterTokenType.RegexWord) { GetNextToken(lexer); RegexOptions options = RegexOptions.CultureInvariant; FilterToken caseInsensitiveToken = LookAhead(lexer, 1); if (caseInsensitiveToken != null && caseInsensitiveToken.Type == FilterTokenType.CaseInsensitiveModifier) { options |= RegexOptions.IgnoreCase; GetNextToken(lexer); } return(new RegexFilter(new Regex(nextToken.Text, options))); } else if (IsWord(nextToken)) { GetNextToken(lexer); return(new EqualityFilter <string>(nextToken.Text)); } } throw new FilterParseException(Resources.FilterParser_ValueExpected); }
private static FilterToken LookAhead(FilterLexer lexer, int index) { FilterToken token = lexer.LookAhead(index); if (token != null && token.Type == FilterTokenType.Error) { throw new FilterParseException(token.Text); } return(token); }
private static void MatchRightBracket(FilterLexer lexer) { FilterToken nextToken = LookAhead(lexer, 1); if (nextToken == null || nextToken.Type != FilterTokenType.RightBracket) { throw new FilterParseException(Resources.FilterParser_RightBracketExpected); } GetNextToken(lexer); }
private static void MatchComma(FilterLexer lexer) { FilterToken nextToken = LookAhead(lexer, 1); if (nextToken == null || nextToken.Type != FilterTokenType.Comma) { // Should never happen because we call this method when we know a comma // token is next throw new FilterParseException(Resources.FilterParser_CommaExpected); } GetNextToken(lexer); }
private Filter <T> MatchNegationFilter(FilterLexer lexer) { FilterToken nextToken = LookAhead(lexer, 1); if (nextToken != null && nextToken.Type == FilterTokenType.Not) { GetNextToken(lexer); return(new NotFilter <T>(MatchNegationFilter(lexer))); } return(MatchParenthesizedFilter(lexer)); }
private static string MatchKey(FilterLexer lexer) { FilterToken nextToken = LookAhead(lexer, 1); if (nextToken == null || IsNotWord(nextToken)) { // Should never happen because we call this method when we know a word // token is next throw new FilterParseException(Resources.FilterParser_StringLiteralExpected); } GetNextToken(lexer); return(nextToken.Text); }
private Filter <T> MatchParenthesizedFilter(FilterLexer lexer) { Filter <T> filter = null; FilterToken nextToken = LookAhead(lexer, 1); if (nextToken != null) { if (nextToken.Type == FilterTokenType.LeftBracket) { GetNextToken(lexer); filter = MatchOrFilter(lexer); MatchRightBracket(lexer); } else { filter = MatchSimpleFilter(lexer); } } return(filter); }
private Filter <T> MatchSimpleFilter(FilterLexer lexer) { FilterToken nextToken = LookAhead(lexer, 1); if (nextToken != null) { if (nextToken.Type == FilterTokenType.Star) { GetNextToken(lexer); return(new AnyFilter <T>()); } if (IsWord(nextToken)) { string key = MatchKey(lexer); MatchColon(lexer); Filter <string> valueFilter = MatchMatchSequence(lexer); return(factory.CreateFilter(key, valueFilter)); } } throw new FilterParseException(Resources.FilterParser_FilterExpressionExpected); }
private FilterSet <T> MatchFilterSet(FilterLexer lexer) { var filterRules = new List <FilterRule <T> >(); FilterToken nextToken = LookAhead(lexer, 1); while (nextToken != null) { FilterRuleType filterRuleType; if (nextToken.Type == FilterTokenType.Include) { filterRuleType = FilterRuleType.Inclusion; GetNextToken(lexer); } else if (nextToken.Type == FilterTokenType.Exclude) { filterRuleType = FilterRuleType.Exclusion; GetNextToken(lexer); } else if (filterRules.Count == 0) { // default to include for first filter filterRuleType = FilterRuleType.Inclusion; } else { throw new FilterParseException(Resources.FilterParser_RulesNotSeperated); } Filter <T> filter = MatchOrFilter(lexer); filterRules.Add(new FilterRule <T>(filterRuleType, filter)); nextToken = LookAhead(lexer, 1); } return(new FilterSet <T>(filterRules)); }
private static Filter <string> MatchMatchSequence(FilterLexer lexer) { var valueFilters = new List <Filter <string> >(); valueFilters.Add(MatchValue(lexer)); FilterToken nextToken = LookAhead(lexer, 1); while (nextToken != null && nextToken.Type == FilterTokenType.Comma) { MatchComma(lexer); valueFilters.Add(MatchValue(lexer)); nextToken = LookAhead(lexer, 1); } if (valueFilters.Count == 1) { return(valueFilters[0]); } else { return(new OrFilter <string>(valueFilters)); } }
private static bool IsNotWord(FilterToken token) { return(!IsWord(token)); }
private static bool IsWord(FilterToken token) { return(token.Type == FilterTokenType.Word || token.Type == FilterTokenType.RegexWord); }