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 and Description
    `ConstantBulkScorer(BulkScorer bulkScorer, Weight weight, float theScore)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and 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 org.apache.lucene.search.BulkScorer

      `score`

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

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

- - ### Constructor Detail

    - #### ConstantBulkScorer

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

  - ### Method Detail

    - #### 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`

Copyright © 2000-2019 Apache Software Foundation. All Rights Reserved.