Пример #1
0
        /// <summary>
        /// Constructs a new <see cref="IFilter{T}"/> from the include an omit configuration cards.
        /// </summary>
        /// <param name="include">the include configuration card</param>
        /// <param name="omit">the omit configuration card</param>
        /// <returns>the corresponding <see cref="IFilter{T}"/></returns>
        public IFilter <byte[]> GetFilter(string include, string omit)
        {
            IFilter <byte[]> filter;

            if (include != null && omit != null)
            {
                filter = new ConjunctionFilter <byte[]>
                {
                    Filters = new List <IFilter <byte[]> >
                    {
                        ParseFilter(include), new NegationFilter <byte[]> {
                            Filter = ParseFilter(omit)
                        }
                    }
                };
            }
            else if (include != null)
            {
                filter = ParseFilter(include);
            }
            else
            {
                filter = new NegationFilter <byte[]> {
                    Filter = ParseFilter(omit)
                };
            }
            return(filter);
        }
Пример #2
0
        /// <summary>
        /// Parses an <see cref="IFilter{T}"/>.
        /// </summary>
        /// <param name="lexer">the lexer to read the tokens from</param>
        /// <param name="defaultFormat">the default format</param>
        /// <returns>an <see cref="IFilter{T}"/></returns>
        private IFilter <byte[]> ParseFilter(Lexer lexer, string defaultFormat)
        {
            IFilter <byte[]> filter = null;

            if (lexer.MoveNext())
            {
                if (lexer.Current == OpeningPar)
                {
                    filter = ParseFilter(lexer, defaultFormat);
                    lexer.Parse(ClosingPar);
                }
                else
                {
                    string format1;
                    string format2;
                    var    leftAccessor  = ParseAccessor(lexer, defaultFormat, out format1);
                    var    op            = lexer.Parse();
                    var    rightAccessor = ParseAccessor(lexer, defaultFormat, out format2);
                    var    format        = format1 ?? format2;
                    filter = GetFilter(leftAccessor, rightAccessor, format, op);
                }

                if (lexer.Current == Or)
                {
                    var disjunction = new DisjunctionFilter <byte[]>
                    {
                        Filters = new List <IFilter <byte[]> >
                        {
                            filter, ParseFilter(lexer, defaultFormat)
                        }
                    };
                    filter = disjunction;
                }
                else if (lexer.Current == And)
                {
                    var conjunction = new ConjunctionFilter <byte[]>
                    {
                        Filters = new List <IFilter <byte[]> >
                        {
                            filter, ParseFilter(lexer, defaultFormat)
                        }
                    };
                    filter = conjunction;
                }
            }

            return(filter);
        }
Пример #3
0
 /// <summary>
 /// Constructs a new <see cref="IFilter{T}"/> from the include an omit configuration cards.
 /// </summary>
 /// <param name="include">the include configuration card</param>
 /// <param name="omit">the omit configuration card</param>
 /// <returns>the corresponding <see cref="IFilter{T}"/></returns>
 public IFilter<byte[]> GetFilter(string include, string omit)
 {
     IFilter<byte[]> filter;
     if (include != null && omit != null)
     {
         filter = new ConjunctionFilter<byte[]>
         {
             Filters = new List<IFilter<byte[]>>
             {
                 ParseFilter(include), new NegationFilter<byte[]> { Filter = ParseFilter(omit) }
             }
         };
     }
     else if (include != null)
     {
         filter = ParseFilter(include);
     }
     else
     {
         filter = new NegationFilter<byte[]> { Filter = ParseFilter(omit) };
     }
     return filter;
 }
Пример #4
0
        /// <summary>
        /// Parses an <see cref="IFilter{T}"/>.
        /// </summary>
        /// <param name="lexer">the lexer to read the tokens from</param>
        /// <param name="defaultFormat">the default format</param>
        /// <returns>an <see cref="IFilter{T}"/></returns>
        private IFilter<byte[]> ParseFilter(Lexer lexer, string defaultFormat)
        {
            IFilter<byte[]> filter = null;

            if (lexer.MoveNext())
            {
                if (lexer.Current == OpeningPar)
                {
                    filter = ParseFilter(lexer, defaultFormat);
                    lexer.Parse(ClosingPar);
                }
                else
                {
                    string format1;
                    string format2;
                    var leftAccessor = ParseAccessor(lexer, defaultFormat, out format1);
                    var op = lexer.Parse();
                    var rightAccessor = ParseAccessor(lexer, defaultFormat, out format2);
                    var format = format1 ?? format2;
                    filter = GetFilter(leftAccessor, rightAccessor, format, op);
                }

                if (lexer.Current == Or)
                {
                    var disjunction = new DisjunctionFilter<byte[]>
                    {
                        Filters = new List<IFilter<byte[]>>
                        {
                            filter, ParseFilter(lexer, defaultFormat)
                        }
                    };
                    filter = disjunction;
                }
                else if (lexer.Current == And)
                {
                    var conjunction = new ConjunctionFilter<byte[]>
                    {
                        Filters = new List<IFilter<byte[]>>
                        {
                            filter, ParseFilter(lexer, defaultFormat)
                        }
                    };
                    filter = conjunction;
                }
            }

            return filter;
        }