Package org.apache.lucene.search

# Class Weight.DefaultBulkScorer

java.lang.Object
org.apache.lucene.search.BulkScorer
org.apache.lucene.search.Weight.DefaultBulkScorer

Enclosing class:
  `Weight`

protected static class Weight.DefaultBulkScorer extends BulkScorer
Just wraps a Scorer and performs top scoring using it.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

## Constructor Summary

Constructors
Constructor
Description
`DefaultBulkScorer(Scorer scorer)`
Sole constructor.

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

### DefaultBulkScorer

public DefaultBulkScorer(Scorer scorer)
Sole constructor.

## Method Details

### cost

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

Specified by:
  `cost` in class `BulkScorer`

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