Review

class MultiTermQuery.RewriteMethod {
    public abstract Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException;
}

class MultiTermQuery.ConstantScoreFilterRewrite {
    public Query rewrite(IndexReader reader, MultiTermQuery query) {
      Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query));
      result.setBoost(query.getBoost());
      return result;
    }
}

class MultiTermQuery.ScoringBooleanQueryRewrite {
    public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {

      FilteredTermEnum enumerator = query.getEnum(reader);
      BooleanQuery result = new BooleanQuery(true);
      int count = 0;
      try {
        do {
          Term t = enumerator.term();
          if (t != null) {
            TermQuery tq = new TermQuery(t); // found a match
            tq.setBoost(query.getBoost() * enumerator.difference()); // set the boost
            result.add(tq, BooleanClause.Occur.SHOULD); // add to query
            count++;
          }
        } while (enumerator.next());    
      } finally {
        enumerator.close();
      }
      query.incTotalNumberOfTerms(count);
      return result;
    }
}

class MultiTermQuery.ConstantScoreBooleanQueryRewrite {
    public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {
      // strip the scores off
      Query result = new ConstantScoreQuery(new QueryWrapperFilter(super.rewrite(reader, query)));
      result.setBoost(query.getBoost());
      return result;
    }
}

class MultiTermQuery.ConstantScoreAutoRewrite {
    public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException {
      // Get the enum and start visiting terms.  If we
      // exhaust the enum before hitting either of the
      // cutoffs, we use ConstantBooleanQueryRewrite; else,
      // ConstantFilterRewrite:
      final Collection pendingTerms = new ArrayList();
      final int docCountCutoff = (int) ((docCountPercent / 100.) * reader.maxDoc());
      final int termCountLimit = Math.min(BooleanQuery.getMaxClauseCount(), termCountCutoff);
      int docVisitCount = 0;

      FilteredTermEnum enumerator = query.getEnum(reader);
      try {
        while(true) {
          Term t = enumerator.term();
          if (t != null) {
            pendingTerms.add(t);
            // Loading the TermInfo from the terms dict here
            // should not be costly, because 1) the
            // query/filter will load the TermInfo when it
            // runs, and 2) the terms dict has a cache:
            docVisitCount += reader.docFreq(t);
          }

          if (pendingTerms.size() >= termCountLimit || docVisitCount >= docCountCutoff) {
            // Too many terms -- make a filter.
            Query result = new ConstantScoreQuery(new MultiTermQueryWrapperFilter(query));
            result.setBoost(query.getBoost());
            return result;
          } else  if (!enumerator.next()) {
            // Enumeration is done, and we hit a small
            // enough number of terms & docs -- just make a
            // BooleanQuery, now
            Iterator it = pendingTerms.iterator();
            BooleanQuery bq = new BooleanQuery(true);
            while(it.hasNext()) {
              TermQuery tq = new TermQuery((Term) it.next());
              bq.add(tq, BooleanClause.Occur.SHOULD);
            }
            // Strip scores
            Query result = new ConstantScoreQuery(new QueryWrapperFilter(bq));
            result.setBoost(query.getBoost());
            query.incTotalNumberOfTerms(pendingTerms.size());
            return result;
          }
        }
      } finally {
        enumerator.close();
      }
    }

}