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(org.apache.lucene.search.Query, int)` uses when no `Sort` is specified).

### Nested Class Summary

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

`FieldComparator.DocComparator, FieldComparator.DoubleComparator, FieldComparator.FloatComparator, FieldComparator.IntComparator, FieldComparator.LongComparator, FieldComparator.NumericComparator<T extends Number>, FieldComparator.RelevanceComparator, FieldComparator.TermOrdValComparator, FieldComparator.TermValComparator`

### Constructor Summary

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

### Method Summary

All Methods Instance Methods Concrete Methods
`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 java.lang.Object

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

### Constructor Detail

#### RelevanceComparator

    public RelevanceComparator(int numHits)

Creates a new comparator based on relevance for `numHits`.

### Method Detail

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