@Override
public <T> void queryTerms(
        @NonNull Collection<? super T> result,
        @NullAllowed Term start,
        @NonNull StoppableConvertor<Term, T> filter,
        @NullAllowed AtomicBoolean cancel) throws IOException, InterruptedException {
    Parameters.notNull("result", result);   //NOI18N
    Parameters.notNull("filter", filter); //NOI18N
    
    lock.readLock().lock();
    try {
        final IndexReader in = getReader();
        if (in == null) {
            return;
        }
        final TermEnum terms = start == null ? in.terms () : in.terms (start);
        try {
            do {
                if (cancel != null && cancel.get()) {
                    throw new InterruptedException ();
                }
                final Term currentTerm = terms.term();
                if (currentTerm != null) {                    
                    final T vote = filter.convert(currentTerm);
                    if (vote != null) {
                        result.add(vote);
                    }
                }
            } while (terms.next());
        } catch (StoppableConvertor.Stop stop) {
            //Stop iteration of TermEnum
        } finally {
            terms.close();
        }
    } finally {
        lock.readLock().unlock();
    }
}
 

@Override
public T convert(@NonNull final TermEnum terms) throws StoppableConvertor.Stop {
    final Term currentTerm = terms.term();
    if (currentTerm == null) {
        return null;
    }
    return delegate.convert(currentTerm);
}
 

@Override
public T convert(TermEnum terms) throws StoppableConvertor.Stop {
    final Term currentTerm = terms.term();
    if (currentTerm == null) {
        return null;
    }
    final int freq = terms.docFreq();
    return delegate.convert(accessor.setTermFreq(tf, currentTerm, freq));
}
 

static LuceneUnsortedIntTermDocIterator create(final IndexReader r, final String field) throws IOException {
    final TermEnum terms = r.terms(new Term(field, ""));
    final TermDocs termDocs;
    try {
        termDocs = r.termDocs();
    } catch (IOException e) {
        try {
            terms.close();
        } catch (IOException e1) {
            log.error("error closing TermEnum", e1);
        }
        throw e;
    }
    return new LuceneUnsortedIntTermDocIterator(field, terms, termDocs);
}
 

private TermEnum getTermEnum(@NonNull final IndexReader reader) {
    return new TermEnum () {
        private Iterator<String> pkgsIt = pkgs.iterator();
        private String current;
        {
            next();
        }

        @Override
        public boolean next() {
            if (pkgsIt == null) {
                throw new IllegalStateException("Already closed."); //NOI18N
            }
            if (pkgsIt.hasNext()) {
                current = pkgsIt.next();
                return true;
            } else {
                current = null;
                return false;
            }
        }

        @Override
        public Term term() {
            return current == null ?
                null :
                new Term (DocumentUtil.FIELD_PACKAGE_NAME, current);
        }

        @Override
        public int docFreq() {
            return current == null ?
                -1 :
                 0;
        }

        @Override
        public void close() throws IOException {
            pkgsIt = null;
        }
    };
}
 

static <T> StoppableConvertor<TermEnum,T> newTermEnumToTermConvertor(
    @NonNull StoppableConvertor<Term,T> delegate) {
    return new TermEnumToTerm<T>(delegate);
}
 

static <T> StoppableConvertor<TermEnum,T> newTermEnumToFreqConvertor(
    @NonNull StoppableConvertor<Index.WithTermFrequencies.TermFreq,T> delegate) {
    return new TermEnumToFreq<T>(delegate);
}
 

public void seek(TermEnum termEnum) throws IOException
{
    // Seek is left to the base implementation
    in.seek(termEnum);
}
 

public void seek(TermEnum termEnum) throws IOException
{
   throw new UnsupportedOperationException();
}
 

@Override
public TermEnum termEnum() {
    sanityCheck();
    return prefixQueue.element().termEnum;
}
 

LuceneUnsortedIntTermDocIterator(String field, TermEnum terms, TermDocs termDocs) {
    this.field = field.intern();
    this.terms = terms;
    this.termDocs = termDocs;
}
 

@Override
public TermEnum termEnum() {
    sanityCheck();
    return termEnum;
}
 

public TermEnum termEnum();