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`