Package org.apache.lucene.search

# Class ConstantScoreQuery.ConstantBulkScorer

java.lang.Object
org.apache.lucene.search.BulkScorer
org.apache.lucene.search.ConstantScoreQuery.ConstantBulkScorer

Enclosing class:
  `ConstantScoreQuery`

protected static class ConstantScoreQuery.ConstantBulkScorer extends BulkScorer
We return this as our `BulkScorer` so that if the CSQ wraps a query with its own optimized top-level scorer (e.g. BooleanScorer) we can use that top-level scorer.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `ConstantBulkScorer(BulkScorer bulkScorer, Weight weight, float theScore)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `long`
  `cost()`
  Same as `DocIdSetIterator.cost()` for bulk scorers.
  `int`
  `score(LeafCollector collector, Bits acceptDocs, int min, int max)`
  Collects matching documents in a range and return an estimation of the next matching document which is on or after `max`.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### ConstantBulkScorer

    public ConstantBulkScorer(BulkScorer bulkScorer, Weight weight, float theScore)

- ## Method Details

  - ### score

    public int score(LeafCollector collector, Bits acceptDocs, int min, int max) throws IOException
    Description copied from class: `BulkScorer`
    Collects matching documents in a range and return an estimation of the next matching document which is on or after `max`.

    The return value must be:

    - >= `max`,
    - `DocIdSetIterator.NO_MORE_DOCS` if there are no more matches,
    - <= the first matching document that is >= `max` otherwise.

    `min` is the minimum document to be considered for matching. All documents strictly before this value must be ignored.

    Although `max` would be a legal return value for this method, higher values might help callers skip more efficiently over non-matching portions of the docID space.

    For instance, a `Scorer`-based implementation could look like below:

         private final Scorer scorer; // set via constructor

         public int score(LeafCollector collector, Bits acceptDocs, int min, int max) throws IOException {
           collector.setScorer(scorer);
           int doc = scorer.docID();
           if (doc < min) {
             doc = scorer.advance(min);
           }
           while (doc < max) {
             if (acceptDocs == null || acceptDocs.get(doc)) {
               collector.collect(doc);
             }
             doc = scorer.nextDoc();
           }
           return doc;
         }

    Specified by:
      `score` in class `BulkScorer`
    Parameters:
      `collector` - The collector to which all matching documents are passed.
      `acceptDocs` - `Bits` that represents the allowed documents to match, or `null` if they are all allowed to match.
      `min` - Score starting at, including, this document
      `max` - Score up to, but not including, this doc
    Returns:
      an under-estimation of the next matching doc after max
    Throws:
      `IOException`

  - ### cost

    public long cost()
    Description copied from class: `BulkScorer`
    Same as `DocIdSetIterator.cost()` for bulk scorers.
    Specified by:
      `cost` in class `BulkScorer`