org.apache.lucene.search

## Class PositiveScoresOnlyCollector

- java.lang.Object
- - org.apache.lucene.search.Collector
  - - org.apache.lucene.search.PositiveScoresOnlyCollector

-     public class PositiveScoresOnlyCollector
      extends Collector

  A `Collector` implementation which wraps another `Collector` and makes sure only documents with scores > 0 are collected.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `PositiveScoresOnlyCollector(Collector c)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `acceptsDocsOutOfOrder()` Return `true` if this collector does not require the matching docIDs to be delivered in int sort order (smallest to largest) to `Collector.collect(int)`.
    `void` | `collect(int doc)` Called once for every document matching a query, with the unbased document number.
    `void` | `setNextReader(IndexReader reader, int docBase)` Called before collecting from each IndexReader.
    `void` | `setScorer(Scorer scorer)` Called before successive calls to `Collector.collect(int)`.

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

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

- - ### Constructor Detail

    - #### PositiveScoresOnlyCollector

          public PositiveScoresOnlyCollector(Collector c)

  - ### Method Detail

    - #### collect

          public void collect(int doc)
                       throws java.io.IOException

      Description copied from class: `Collector`
      Called once for every document matching a query, with the unbased document number.

      Note: This is called in an inner search loop. For good search performance, implementations of this method should not call `Searcher.doc(int)` or `IndexReader.document(int)` on every hit. Doing so can slow searches by an order of magnitude or more.

      Specified by:
        `collect` in class `Collector`
      Throws:
        `java.io.IOException`

    - #### setNextReader

          public void setNextReader(IndexReader reader,
                                    int docBase)
                             throws java.io.IOException

      Description copied from class: `Collector`
      Called before collecting from each IndexReader. All doc ids in `Collector.collect(int)` will correspond to reader. Add docBase to the current IndexReaders internal document id to re-base ids in `Collector.collect(int)`.
      Specified by:
        `setNextReader` in class `Collector`
      Parameters:
        `reader` - next IndexReader
      Throws:
        `java.io.IOException`

    - #### setScorer

          public void setScorer(Scorer scorer)
                         throws java.io.IOException

      Description copied from class: `Collector`
      Called before successive calls to `Collector.collect(int)`. Implementations that need the score of the current document (passed-in to `Collector.collect(int)`), should save the passed-in Scorer and call scorer.score() when needed.
      Specified by:
        `setScorer` in class `Collector`
      Throws:
        `java.io.IOException`

    - #### acceptsDocsOutOfOrder

          public boolean acceptsDocsOutOfOrder()

      Description copied from class: `Collector`
      Return `true` if this collector does not require the matching docIDs to be delivered in int sort order (smallest to largest) to `Collector.collect(int)`.

      Most Lucene Query implementations will visit matching docIDs in order. However, some queries (currently limited to certain cases of `BooleanQuery`) can achieve faster searching if the `Collector` allows them to deliver the docIDs out of order.

      Many collectors don't mind getting docIDs out of order, so it's important to return `true` here.

      Specified by:
        `acceptsDocsOutOfOrder` in class `Collector`

Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.