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

Methods
`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(AtomicReaderContext context)` Called before collecting from each `AtomicReaderContext`.
`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 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 `IndexSearcher.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:
  `IOException`

#### setNextReader

    public void setNextReader(AtomicReaderContext context)
                       throws IOException

Description copied from class: `Collector`
Called before collecting from each `AtomicReaderContext`. All doc ids in `Collector.collect(int)` will correspond to `IndexReaderContext.reader()`. Add `AtomicReaderContext.docBase` to the current `IndexReaderContext.reader()`'s internal document id to re-base ids in `Collector.collect(int)`.

Specified by:
  `setNextReader` in class `Collector`
Parameters:
  `context` - next atomic reader context
Throws:
  `IOException`

#### setScorer

    public void setScorer(Scorer scorer)
                   throws 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:
  `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`