FieldComparator.RelevanceComparator (Lucene 10.5.0 core API)
Description: declaration: package: org.apache.lucene.search, class: FieldComparator, class: RelevanceComparator

Package org.apache.lucene.search

# Class FieldComparator.RelevanceComparator

java.lang.Object
org.apache.lucene.search.FieldComparator<Float>
org.apache.lucene.search.FieldComparator.RelevanceComparator

All Implemented Interfaces:
  `LeafFieldComparator`

Enclosing class:
  `FieldComparator<T>`

public static final class FieldComparator.RelevanceComparator extends FieldComparator<Float> implements LeafFieldComparator
Sorts by descending relevance. NOTE: if you are sorting only by descending relevance and then secondarily by ascending docID, performance is faster using `TopScoreDocCollector` directly (which `IndexSearcher.search(Query, int)` uses when no `Sort` is specified).

- ## Nested Class Summary

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

  `FieldComparator.RelevanceComparator, FieldComparator.TermValComparator`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `RelevanceComparator(int numHits)`
  Creates a new comparator based on relevance for `numHits`.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `int`
  `compare(int slot1, int slot2)`
  Compare hit at slot1 with hit at slot2.
  `int`
  `compareBottom(int doc)`
  Compare the bottom of the queue with this doc.
  `int`
  `compareTop(int doc)`
  Compare the top value with this doc.
  `int`
  `compareValues(Float first, Float second)`
  Returns a negative integer if first is less than second, 0 if they are equal and a positive integer otherwise.
  `void`
  `copy(int slot, int doc)`
  This method is called when a new hit is competitive.
  `LeafFieldComparator`
  `getLeafComparator(LeafReaderContext context)`
  Get a per-segment `LeafFieldComparator` to collect the given `LeafReaderContext`.
  `void`
  `setBottom(int bottom)`
  Set the bottom slot, ie the "weakest" (sorted last) entry in the queue.
  `void`
  `setScorer(Scorable scorer)`
  Sets the Scorer to use in case a document's score is needed.
  `void`
  `setTopValue(Float value)`
  Record the top value, for future calls to `LeafFieldComparator.compareTop(int)`.
  `Float`
  `value(int slot)`
  Return the actual value in the slot.

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

  `disableSkipping, setSingleSort`

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

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

  ### Methods inherited from interface org.apache.lucene.search.LeafFieldComparator

  `competitiveIterator, setHitsThresholdReached`

- ## Constructor Details

  - ### RelevanceComparator

    public RelevanceComparator(int numHits)
    Creates a new comparator based on relevance for `numHits`.

- ## Method Details

  - ### compare

    public int compare(int slot1, int slot2)
    Description copied from class: `FieldComparator`
    Compare hit at slot1 with hit at slot2.
    Specified by:
      `compare` in class `FieldComparator<Float>`
    Parameters:
      `slot1` - first slot to compare
      `slot2` - second slot to compare
    Returns:
      any `N < 0` if slot2's value is sorted after slot1, any `N > 0` if the slot2's value is sorted before slot1 and `0` if they are equal

  - ### compareBottom

    public int compareBottom(int doc) throws IOException
    Description copied from interface: `LeafFieldComparator`
    Compare the bottom of the queue with this doc. This will only invoked after setBottom has been called. This should return the same result as `FieldComparator.compare(int,int)`} as if bottom were slot1 and the new document were slot 2.

    For a search that hits many results, this method will be the hotspot (invoked by far the most frequently).

    Specified by:
      `compareBottom` in interface `LeafFieldComparator`
    Parameters:
      `doc` - that was hit
    Returns:
      any `N < 0` if the doc's value is sorted after the bottom entry (not competitive), any `N > 0` if the doc's value is sorted before the bottom entry and `0` if they are equal.
    Throws:
      `IOException`

  - ### copy

    public void copy(int slot, int doc) throws IOException
    Description copied from interface: `LeafFieldComparator`
    This method is called when a new hit is competitive. You should copy any state associated with this document that will be required for future comparisons, into the specified slot.
    Specified by:
      `copy` in interface `LeafFieldComparator`
    Parameters:
      `slot` - which slot to copy the hit to
      `doc` - docID relative to current reader
    Throws:
      `IOException`

  - ### getLeafComparator

    public LeafFieldComparator getLeafComparator(LeafReaderContext context)
    Description copied from class: `FieldComparator`
    Get a per-segment `LeafFieldComparator` to collect the given `LeafReaderContext`. All docIDs supplied to this `LeafFieldComparator` are relative to the current reader (you must add docBase if you need to map it to a top-level docID).
    Specified by:
      `getLeafComparator` in class `FieldComparator<Float>`
    Parameters:
      `context` - current reader context
    Returns:
      the comparator to use for this segment

  - ### setBottom

    public void setBottom(int bottom)
    Description copied from interface: `LeafFieldComparator`
    Set the bottom slot, ie the "weakest" (sorted last) entry in the queue. When `LeafFieldComparator.compareBottom(int)` is called, you should compare against this slot. This will always be called before `LeafFieldComparator.compareBottom(int)`.
    Specified by:
      `setBottom` in interface `LeafFieldComparator`
    Parameters:
      `bottom` - the currently weakest (sorted last) slot in the queue

  - ### setTopValue

    public void setTopValue(Float value)
    Description copied from class: `FieldComparator`
    Record the top value, for future calls to `LeafFieldComparator.compareTop(int)`. This is only called for searches that use searchAfter (deep paging), and is called before any calls to `FieldComparator.getLeafComparator(LeafReaderContext)`.
    Specified by:
      `setTopValue` in class `FieldComparator<Float>`

  - ### setScorer

    public void setScorer(Scorable scorer)
    Description copied from interface: `LeafFieldComparator`
    Sets the Scorer to use in case a document's score is needed.
    Specified by:
      `setScorer` in interface `LeafFieldComparator`
    Parameters:
      `scorer` - Scorer instance that you should use to obtain the current hit's score, if necessary.

  - ### value

    public Float value(int slot)
    Description copied from class: `FieldComparator`
    Return the actual value in the slot.
    Specified by:
      `value` in class `FieldComparator<Float>`
    Parameters:
      `slot` - the value
    Returns:
      value in this slot

  - ### compareValues

    public int compareValues(Float first, Float second)
    Description copied from class: `FieldComparator`
    Returns a negative integer if first is less than second, 0 if they are equal and a positive integer otherwise. Default impl to assume the type implements Comparable and invoke .compareTo; be sure to override this method if your FieldComparator's type isn't a Comparable or if your values may sometimes be null
    Overrides:
      `compareValues` in class `FieldComparator<Float>`

  - ### compareTop

    public int compareTop(int doc) throws IOException
    Description copied from interface: `LeafFieldComparator`
    Compare the top value with this doc. This will only invoked after setTopValue has been called. This should return the same result as `FieldComparator.compare(int,int)`} as if topValue were slot1 and the new document were slot 2. This is only called for searches that use searchAfter (deep paging).
    Specified by:
      `compareTop` in interface `LeafFieldComparator`
    Parameters:
      `doc` - that was hit
    Returns:
      any `N < 0` if the doc's value is sorted after the top entry (not competitive), any `N > 0` if the doc's value is sorted before the top entry and `0` if they are equal.
    Throws:
      `IOException`