public bool ProcessTerm(ITokenSource source)
 {
     var term = new ArraySegmentKey<char>(source.Buffer, source.Size);
     if (_stopWords.Contains(term))
         return false;
     return true;
 }

 public List<Result> ExecuteQueryFunc(Query query, ITokenSource cancelToken)
 {
     if (QueryFunc != null) {
         return QueryFunc(query, cancelToken);
     }
     return new List<Result>();
 }

 public bool ProcessTerm(ITokenSource source)
 {
     for (int i = 0; i < source.Size; i++)
     {
         source.Buffer[i] = char.ToLowerInvariant(source.Buffer[i]);
     }
     return true;
 }

 public bool Process(string field, ITokenSource source)
 {
     for (int i = 0; i < _filters.Length; i++)
     {
         if (_filters[i].ProcessTerm(source) == false)
             return false;
     }
     return true;
 }

        //    public object Run(string parameters)//, CancellationToken ct)
        //    {
        //        for (int i = 0; i < 2; i++)
        //        {
        //            //ct.ThrowIfCancellationRequested();
        //            Thread.Sleep(5000);
        //        }
        //        return "Hello from MyCustomJob in App1";
        //    }
        public void Run(ITokenSource tokenSource)
        {
            for (int i = 0; i < 5; i++)
            {
                tokenSource.Token.ThrowIfCancellationRequested();
                Thread.Sleep(5000);
            }

            AutoMapper.Mapper.CreateMap<Class1, Class2>();
        }

 public bool ProcessTerm(ITokenSource source)
 {
     if (source.Size <= 2)
         return true;
     if (source.Buffer[source.Size - 1] == '\'') // remove "boys' ball" suffix '
     {
         source.Size--;
     }
     // remove "boy's ball" suffix 's
     else if ((source.Buffer[source.Size - 1] == 's') && source.Buffer[source.Size - 2] == '\'')
     {
         source.Size -= 2;
     }
     return true;
 }

        /// <summary>
        /// Parses the given token source using the specified grammar, starting with
        /// expression with the given name.
        /// </summary>
        /// <param name="expressionType">The type of the expression to start parsing.</param>
        /// <param name="tokenSource">The source of tokens.</param>
        public MatchResult Parse(string expressionType, ITokenSource tokenSource)
        {
            if (tokenSource == null)
            {
                throw new ArgumentNullException("tokenSource");
            }

            Expression expression = grammar.Expression(expressionType);
            ParseAttempt attempt = new ParseAttempt(this, tokenSource);
            MatchResult result = expression.Match(attempt, String.Empty);

            // check that there are no trailing tokens
            if (result.IsMatch && attempt.GetToken() != null)
            {
                result.IsMatch = false;
            }

            return result;
        }

 public CommonTokenStream(ITokenSource tokenSource, int channel)
     : base(tokenSource)
 {
     this._channel = channel;
 }

 protected internal virtual IToken ConstructToken(ITokenSource tokenSource, int expectedTokenType, string tokenText, IToken current)
 {
     ITokenFactory factory = tokenSource.TokenFactory;
     return factory.Create(Tuple.Create(tokenSource, current.TokenSource.InputStream), expectedTokenType, tokenText, TokenConstants.DefaultChannel, -1, -1, current.Line, current.Column);
 }

 public UnbufferedTokenStream(ITokenSource tokenSource, int bufferSize)
 {
     this.TokenSource = tokenSource;
     this.tokens = new IToken[bufferSize];
     n = 0;
     Fill(1);
 }

 public TokenRewriteStream(ITokenSource tokenSource, int channel)
     : base(tokenSource, channel)
     {
     Init();
     }

 public NadirTokenStream(ITokenSource tokenSource, int channel) : base(tokenSource, channel)
     {
     }

 /// <summary>
 /// Constructs a new
 /// <see cref="CommonTokenStream"/>
 /// using the specified token
 /// source and the default token channel (
 /// <see cref="TokenConstants.DefaultChannel"/>
 /// ).
 /// </summary>
 /// <param name="tokenSource">The token source.</param>
 public CommonTokenStream(ITokenSource tokenSource)
     : base(tokenSource)
 {
 }

 public TokenStreamRemovable(ITokenSource tokenSource, int channel) : base(tokenSource, channel) { }

 public LegacyCommonTokenStream(ITokenSource tokenSource)
     : this()
 {
     this._tokenSource = tokenSource;
 }

 public AntlrParserTokenStream(ITokenSource tokenSource)
     : base(tokenSource)
 {
 }

 public BufferedTokenStream(ITokenSource tokenSource)
 {
     this._tokenSource = tokenSource;
 }

 public BufferedTokenStream(ITokenSource tokenSource)
 {
     this._tokens = new List<IToken>(100);
     this._p = -1;
     this._tokenSource = tokenSource;
 }

 public SnapshotTokenFactory(ITextSnapshot snapshot, ITokenSource effectiveSource)
 {
     this.snapshot = snapshot;
     this.effectiveSource = Tuple.Create(effectiveSource, effectiveSource.InputStream);
 }

        private List<Result> Query(Query query, ITokenSource cancelToken)
        {
            if (query.KeywordComplete && query.HasArguments) {
                // check the cache for a matching result
                var cacheKey = query.Arguments;
                var cachedSuggestions = MemoryCache.Default.Get(cacheKey) as List<string>;

                // if cached result is found, return it.
                if (cachedSuggestions != null) {
                    // convert the list of suggestion strings to a List<Result>
                    if (cachedSuggestions.Any()) {
                        var results = cachedSuggestions.Select(suggestion => new Result
                        {
                            Title = suggestion,
                            Icon = _icon,
                            SubTitle = "Search google for " + suggestion,
                            Launch = query1 =>
                            {
                                Process.Start($"http://google.co.uk/search?q={suggestion}");
                                AppCommands.HideWindow();

                            }
                        }).ToList();
                        return results;
                    }
                    // no suggestions were received from the server
                    return new List<Result>
                    {
                        new Result
                        {
                            Title = "No search suggestions found.",
                            Icon = _icon
                        }
                    };
                }

                // Cache miss, begin the background query to fill the cache
                // create a local cancel token for passing to httpclient..
                var cancellable = new CancellationToken();
                cancellable.Register(() =>
                {
                    cancelToken.Cancel();
                    cancelToken.Dispose();
                });
                var x = GetSuggestionsAsync(query.Arguments, cancellable);
                return new List<Result>
                {
                    new Result
                    {
                        Title = "Retrieving search suggestions...",
                        Icon = _icon
                    }
                };
            }
            // otherwise the query has not been provided yet, running the action will autocomplete the query
            return new List<Result>
            {
                new Result
                {
                    Title = "Search Google",
                    SubTitle = "Search Google with Suggestions",
                    Icon = _icon,
                    Launch = query1 => AppCommands.RewriteQuery(Keyword + ' ')
                }
            };
        }