org.apache.lucene.search.comparators

## Class DoubleComparator.DoubleLeafComparator

- java.lang.Object
- - org.apache.lucene.search.comparators.NumericComparator.NumericLeafComparator
  - - org.apache.lucene.search.comparators.DoubleComparator.DoubleLeafComparator

All Implemented Interfaces:
  LeafFieldComparator

Enclosing class:
  DoubleComparator

    public class DoubleComparator.DoubleLeafComparator
    extends NumericComparator.NumericLeafComparator

Leaf comparator for `DoubleComparator` that provides skipping functionality

### Field Summary

### Fields inherited from class org.apache.lucene.search.comparators.NumericComparator.NumericLeafComparator

`docValues`

### Constructor Summary

Constructors
Constructor and Description
`DoubleLeafComparator(LeafReaderContext context)`

### Method Summary

All Methods Instance Methods Concrete Methods
`int` `compareBottom(int doc)` Compare the bottom of the queue with this doc.
`int` `compareTop(int doc)` Compare the top value with this doc.
`void` `copy(int slot, int doc)` This method is called when a new hit is competitive.
`protected void` `encodeBottom(byte[] packedValue)`
`protected void` `encodeTop(byte[] packedValue)`
`protected boolean` `isMissingValueCompetitive()`
`void` `setBottom(int slot)` Set the bottom slot, ie the "weakest" (sorted last) entry in the queue.

### Methods inherited from class org.apache.lucene.search.comparators.NumericComparator.NumericLeafComparator

`competitiveIterator, getNumericDocValues, getPointValues, setHitsThresholdReached, setScorer`

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

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

### Constructor Detail

#### DoubleLeafComparator

    public DoubleLeafComparator(LeafReaderContext context)
                         throws IOException

Throws:
  `IOException`

### Method Detail

#### setBottom

    public void setBottom(int slot)
                   throws IOException

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`
Overrides:
  `setBottom` in class `NumericComparator.NumericLeafComparator`
Parameters:
  `slot` - the currently weakest (sorted last) slot in the queue
Throws:
  `IOException`

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

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`

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

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`

#### 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`
Overrides:
  `copy` in class `NumericComparator.NumericLeafComparator`
Parameters:
  `slot` - which slot to copy the hit to
  `doc` - docID relative to current reader
Throws:
  `IOException`

#### isMissingValueCompetitive

    protected boolean isMissingValueCompetitive()

Specified by:
  `isMissingValueCompetitive` in class `NumericComparator.NumericLeafComparator`

#### encodeBottom

    protected void encodeBottom(byte[] packedValue)

Specified by:
  `encodeBottom` in class `NumericComparator.NumericLeafComparator`

#### encodeTop

    protected void encodeTop(byte[] packedValue)

Specified by:
  `encodeTop` in class `NumericComparator.NumericLeafComparator`