Package org.apache.lucene.search

# Class ConstantScoreScorer

java.lang.Object
org.apache.lucene.search.Scorable
org.apache.lucene.search.Scorer
org.apache.lucene.search.ConstantScoreScorer

public final class ConstantScoreScorer extends Scorer
A constant-scoring `Scorer`.

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

- ## Nested Class Summary

  ## Nested classes/interfaces inherited from class org.apache.lucene.search.Scorable

  `Scorable.ChildScorable`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `ConstantScoreScorer(float score, ScoreMode scoreMode, DocIdSetIterator disi)`
  Constructor based on a `DocIdSetIterator` which will be used to drive iteration.
  `ConstantScoreScorer(float score, ScoreMode scoreMode, TwoPhaseIterator twoPhaseIterator)`
  Constructor based on a `TwoPhaseIterator`.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `int`
  `docID()`
  Returns the doc ID that is currently being scored.
  `float`
  `getMaxScore(int upTo)`
  Return the maximum score that documents between the last `target` that this iterator was `shallow-advanced` to included and `upTo` included.
  `DocIdSetIterator`
  `iterator()`
  Return a `DocIdSetIterator` over matching documents.
  `void`
  `nextDocsAndScores(int upTo, Bits liveDocs, DocAndFloatFeatureBuffer buffer)`
  Return a new batch of doc IDs and scores, starting at the current doc ID, and ending before `upTo`.
  `float`
  `score()`
  Returns the score of the current document matching the query.
  `void`
  `setMinCompetitiveScore(float minScore)`
  Optional method: Tell the scorer that its iterator may safely ignore all documents whose score is less than the given `minScore`.
  `TwoPhaseIterator`
  `twoPhaseIterator()`
  Optional method: Return a `TwoPhaseIterator` view of this `Scorer`.

  ### Methods inherited from class org.apache.lucene.search.Scorer

  `advanceShallow`

  ### Methods inherited from class org.apache.lucene.search.Scorable

  `getChildren, smoothingScore`

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

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

- ## Constructor Details

  - ### ConstantScoreScorer

    public ConstantScoreScorer(float score, ScoreMode scoreMode, DocIdSetIterator disi)
    Constructor based on a `DocIdSetIterator` which will be used to drive iteration. Two phase iteration will not be supported.
    Parameters:
      `score` - the score to return on each document
      `scoreMode` - the score mode
      `disi` - the iterator that defines matching documents

  - ### ConstantScoreScorer

    public ConstantScoreScorer(float score, ScoreMode scoreMode, TwoPhaseIterator twoPhaseIterator)
    Constructor based on a `TwoPhaseIterator`. In that case the `Scorer` will support two-phase iteration.
    Parameters:
      `score` - the score to return on each document
      `scoreMode` - the score mode
      `twoPhaseIterator` - the iterator that defines matching documents

- ## Method Details

  - ### getMaxScore

    public float getMaxScore(int upTo) throws IOException
    Description copied from class: `Scorer`
    Return the maximum score that documents between the last `target` that this iterator was `shallow-advanced` to included and `upTo` included.
    Specified by:
      `getMaxScore` in class `Scorer`
    Throws:
      `IOException`

  - ### setMinCompetitiveScore

    public void setMinCompetitiveScore(float minScore) throws IOException
    Description copied from class: `Scorable`
    Optional method: Tell the scorer that its iterator may safely ignore all documents whose score is less than the given `minScore`. This is a no-op by default.

    This method may only be called from collectors that use `ScoreMode.TOP_SCORES`, and successive calls may only set increasing values of `minScore`.

    Overrides:
      `setMinCompetitiveScore` in class `Scorable`
    Throws:
      `IOException`

  - ### iterator

    public DocIdSetIterator iterator()
    Description copied from class: `Scorer`
    Return a `DocIdSetIterator` over matching documents.

    The returned iterator will either be positioned on `-1` if no documents have been scored yet, `DocIdSetIterator.NO_MORE_DOCS` if all documents have been scored already, or the last document id that has been scored otherwise.

    The returned iterator is a view: calling this method several times will return iterators that have the same state.

    Specified by:
      `iterator` in class `Scorer`

  - ### twoPhaseIterator

    public TwoPhaseIterator twoPhaseIterator()
    Description copied from class: `Scorer`
    Optional method: Return a `TwoPhaseIterator` view of this `Scorer`. A return value of `null` indicates that two-phase iteration is not supported.

    Note that the returned `TwoPhaseIterator`'s `approximation` must advance synchronously with the `Scorer.iterator()`: advancing the approximation must advance the iterator and vice-versa.

    Implementing this method is typically useful on `Scorer`s that have a high per-document overhead in order to confirm matches.

    The default implementation returns `null`.

    Overrides:
      `twoPhaseIterator` in class `Scorer`

  - ### docID

    public int docID()
    Description copied from class: `Scorer`
    Returns the doc ID that is currently being scored.
    Specified by:
      `docID` in class `Scorer`

  - ### score

    public float score() throws IOException
    Description copied from class: `Scorable`
    Returns the score of the current document matching the query.
    Specified by:
      `score` in class `Scorable`
    Throws:
      `IOException`

  - ### nextDocsAndScores

    public void nextDocsAndScores(int upTo, Bits liveDocs, DocAndFloatFeatureBuffer buffer) throws IOException
    Description copied from class: `Scorer`
    Return a new batch of doc IDs and scores, starting at the current doc ID, and ending before `upTo`. Because it starts on the current doc ID, it is illegal to call this method if the `current doc ID` is `-1`.

    An empty return value indicates that there are no postings left between the current doc ID and `upTo`.

    Implementations should ideally fill the buffer with a number of entries comprised between 8 and a couple hundreds, to keep heap requirements contained, while still being large enough to enable operations on the buffer to auto-vectorize efficiently.

    The default implementation is provided below:

         int batchSize = 64; // arbitrary
         buffer.growNoCopy(batchSize);
         int size = 0;
         DocIdSetIterator iterator = iterator();
         for (int doc = docID(); doc < upTo && size < batchSize; doc = iterator.nextDoc()) {
           if (liveDocs == null || liveDocs.get(doc)) {
             buffer.docs[size] = doc;
             buffer.scores[size] = score();
             ++size;
           }
         }
         buffer.size = size;

    NOTE: The provided `DocAndFloatFeatureBuffer` should not hold references to internal data structures.

    NOTE: In case this `Scorer` exposes a `TwoPhaseIterator`, it should be positioned on a matching document before this method is called.

    Overrides:
      `nextDocsAndScores` in class `Scorer`
    Throws:
      `IOException`