/// <summary>
 /// Construtor padrão.
 /// </summary>
 /// <param name="analyzer"></param>
 /// <param name="dataRepository"></param>
 /// <param name="sortTerms">Termos que serão usados na ordenação.</param>
 /// <param name="numHits">Total de itens do resultado.</param>
 /// <param name="field">Nome do campos.</param>
 internal FullTextFieldComparator(global::Lucene.Net.Analysis.Standard.StandardAnalyzer analyzer, IDataRepository dataRepository, IList <string> sortTerms, int numHits, string field)
 {
     _analyzer       = analyzer;
     _dataRepository = dataRepository;
     _sortTerms      = sortTerms;
     _values         = new List <string> [numHits];
     _field          = field;
 }
        /// <summary>
        /// Get searchterms from examineindex
        /// </summary>
        /// <param name="rootId">Where to start from</param>
        /// <param name="minLength">Min length of words to find</param>
        /// <returns></returns>
        public TermExtractorWrapper GetTerms(int rootId = -1, int minLength = 5)
        {
            var debugTimeStart = DateTime.Now;
            var debugTimeEnd = DateTime.MinValue;
            var termsList = new List<global::Lucene.Net.Index.Term>();                       // data to return
            var indexPath = GetIndexPath();                         // path to index
            var directory = FSDirectory.Open(indexPath);            //
            var indexReader = IndexReader.Open(directory, true);    //
            var searcher = new IndexSearcher(indexReader);          //searcher for checking if the term is valid
            var analyzer = new global::Lucene.Net.Analysis.Standard.StandardAnalyzer(global::Lucene.Net.Util.Version.LUCENE_29);

            foreach (var fieldName in FieldNames)
            {
                var tEnum = indexReader.Terms(new global::Lucene.Net.Index.Term(fieldName));

                do
                {
                    var t = tEnum.Term();

                    // filter in fieldname and minlength og term
                    if (t.Field() == fieldName && t.Text().Length >= minLength)
                    {
                        var searchPhrase = t.Text();
                        var parser = new global::Lucene.Net.QueryParsers.QueryParser(global::Lucene.Net.Util.Version.LUCENE_29, fieldName, analyzer);
                        var bq = new BooleanQuery();
                        var collector = TopScoreDocCollector.create(1, true);

                        var query = parser.Parse(searchPhrase);
                        bq.Add(query, BooleanClause.Occur.MUST);

                        searcher.Search(bq, collector);
                        var hits = collector.TopDocs().ScoreDocs;

                        if (hits.Any())
                        {
                            var docId = hits[0].doc;
                            var doc = searcher.Doc(docId);

                            if (doc.Get("path").Contains("," + rootId + ","))
                            {
                                termsList.Add(t);
                            }
                        }

                    }

                } while (tEnum.Next());
            }

            debugTimeEnd = DateTime.Now;

            return new TermExtractorWrapper
            {
                QueryTime = (debugTimeEnd - debugTimeStart).Milliseconds.ToString(),
                Terms = termsList
            };
        }
 /// <summary>
 /// Construtor padrão.
 /// </summary>
 /// <param name="analyzer"></param>
 /// <param name="dataRepository">Repositorio de dados associado.</param>
 /// <param name="sortTerms">Termos que serão usados para a ordenação.</param>
 public FullTextFieldComparatorSource(global::Lucene.Net.Analysis.Standard.StandardAnalyzer analyzer, IDataRepository dataRepository, IList <string> sortTerms)
 {
     _analyzer       = analyzer;
     _dataRepository = dataRepository;
     _sortTerms      = sortTerms;
 }