Package 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 | Description
    --- | ---
    `DoubleLeafComparator​(LeafReaderContext context)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `int` | `compareBottom​(int doc)` | Compare the bottom of the queue with this doc.
    `protected int` | `compareMissingValueWithBottomValue()` |
    `protected int` | `compareMissingValueWithTopValue()` | in ascending sort, missing value is competitive when it is less or equal(maybe there are two or more comparators) than bottom value.
    `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)` |
    `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, 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`

    - #### compareMissingValueWithBottomValue

          protected int compareMissingValueWithBottomValue()

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

    - #### compareMissingValueWithTopValue

          protected int compareMissingValueWithTopValue()

      Description copied from class: `NumericComparator.NumericLeafComparator`
      in ascending sort, missing value is competitive when it is less or equal(maybe there are two or more comparators) than bottom value. if there is only one comparator(See `Pruning.GREATER_THAN_OR_EQUAL_TO`), missing value is competitive only when it is less than bottom value. vice versa in descending sort.
      Specified by:
        `compareMissingValueWithTopValue` 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`