AbstractAllGroupHeadsCollector (Lucene 3.6.2 API)
Keywords: org.apache.lucene.search.grouping.AbstractAllGroupHeadsCollector class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.lucene.search.grouping
Class AbstractAllGroupHeadsCollector<GH extends AbstractAllGroupHeadsCollector.GroupHead>

    java.lang.Object
      org.apache.lucene.search.Collector
          org.apache.lucene.search.grouping.AbstractAllGroupHeadsCollector<GH>

Direct Known Subclasses:
  TermAllGroupHeadsCollector

    public abstract class AbstractAllGroupHeadsCollector<GH extends AbstractAllGroupHeadsCollector.GroupHead>

extends Collector

This collector specializes in collecting the most relevant document (group head) for each group that match the query.

WARNING: This API is experimental and might change in incompatible ways in the next release.

Nested Class Summary
`static class` | `AbstractAllGroupHeadsCollector.GroupHead<GROUP_VALUE_TYPE>` Represents a group head.
`protected class` | `AbstractAllGroupHeadsCollector.TemporalResult` Contains the result of group head retrieval.

Field Summary
`protected int` | `compIDXEnd`
`protected int[]` | `reversed`
`protected AbstractAllGroupHeadsCollector.TemporalResult` | `temporalResult`

Constructor Summary
`protected` | `AbstractAllGroupHeadsCollector(int numberOfSorts)`

Method Summary
`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.
`protected abstract Collection<GH>` | `getCollectedGroupHeads()` Returns the collected group heads.
`int` | `groupHeadsSize()`
`protected abstract void` | `retrieveGroupHeadAndAddIfNotExist(int doc)` Returns the group head and puts it into `temporalResult`.
`int[]` | `retrieveGroupHeads()`
`FixedBitSet` | `retrieveGroupHeads(int maxDoc)`

Methods inherited from class org.apache.lucene.search.Collector
`setNextReader, setScorer`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### reversed

    protected final int[] reversed

### compIDXEnd

    protected final int compIDXEnd

### temporalResult

    protected final AbstractAllGroupHeadsCollector.TemporalResult temporalResult

Constructor Detail

### AbstractAllGroupHeadsCollector

    protected AbstractAllGroupHeadsCollector(int numberOfSorts)

Method Detail

### retrieveGroupHeads

    public FixedBitSet retrieveGroupHeads(int maxDoc)

  Parameters:
    `maxDoc` - The maxDoc of the top level `IndexReader`.
  Returns:
    an `FixedBitSet` containing all group heads.

### retrieveGroupHeads

    public int[] retrieveGroupHeads()

  Returns:
    an int array containing all group heads. The size of the array is equal to number of collected unique groups.

### groupHeadsSize

    public int groupHeadsSize()

  Returns:
    the number of group heads found for a query.

### retrieveGroupHeadAndAddIfNotExist

    protected abstract void retrieveGroupHeadAndAddIfNotExist(int doc)
                                                       throws IOException

  Returns the group head and puts it into `temporalResult`. If the group head wasn't encountered before then it will be added to the collected group heads.

  The `AbstractAllGroupHeadsCollector.TemporalResult.stop` property will be `true` if the group head wasn't encountered before otherwise `false`.

  Parameters:
    `doc` - The document to retrieve the group head for.
  Throws:
    `IOException` - If I/O related errors occur

### getCollectedGroupHeads

    protected abstract Collection<GH> getCollectedGroupHeads()

  Returns the collected group heads. Subsequent calls should return the same group heads.

  Returns:
    the collected group heads

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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD