Trait tantivy::collector::Collector

pub trait Collector: Sync + Send {
    type Fruit: Fruit;
    type Child: SegmentCollector;

    fn for_segment(
        &self, 
        segment_local_id: SegmentOrdinal, 
        segment: &SegmentReader
    ) -> Result<Self::Child>;
    fn requires_scoring(&self) -> bool;
    fn merge_fruits(
        &self, 
        segment_fruits: Vec<<Self::Child as SegmentCollector>::Fruit>
    ) -> Result<Self::Fruit>;

    fn collect_segment(
        &self, 
        weight: &dyn Weight, 
        segment_ord: u32, 
        reader: &SegmentReader
    ) -> Result<<Self::Child as SegmentCollector>::Fruit> { ... }
}

Collectors are in charge of collecting and retaining relevant information from the document found and scored by the query.

For instance,

• keeping track of the top 10 best documents
• computing a breakdown over a fast field
• computing the number of documents matching the query

Our search index is in fact a collection of segments, so a Collector trait is actually more of a factory to instance SegmentCollectors for each segments.

The collection logic itself is in the SegmentCollector.

Segments are not guaranteed to be visited in any specific order.

Required Associated Types

type Fruit: Fruit

Fruit is the type for the result of our collection. e.g. usize for the Count collector.

type Child: SegmentCollector

Type of the SegmentCollector associated to this collector.

Required Methods

fn for_segment(
    &self,
    segment_local_id: SegmentOrdinal,
    segment: &SegmentReader
) -> Result<Self::Child>

set_segment is called before beginning to enumerate on this segment.

fn requires_scoring(&self) -> bool

Returns true iff the collector requires to compute scores for documents.

fn merge_fruits(
    &self,
    segment_fruits: Vec<<Self::Child as SegmentCollector>::Fruit>
) -> Result<Self::Fruit>

Combines the fruit associated to the collection of each segments into one fruit.

Provided Methods

fn collect_segment(
    &self,
    weight: &dyn Weight,
    segment_ord: u32,
    reader: &SegmentReader
) -> Result<<Self::Child as SegmentCollector>::Fruit>

Created a segment collector and

Implementations on Foreign Types

impl<TCollector: Collector> Collector for Option<TCollector>

type Fruit = Option<<TCollector as Collector>::Fruit>

type Child = Option<<TCollector as Collector>::Child>

fn for_segment(
    &self,
    segment_local_id: SegmentOrdinal,
    segment: &SegmentReader
) -> Result<Self::Child>

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    segment_fruits: Vec<<Self::Child as SegmentCollector>::Fruit>
) -> Result<Self::Fruit>

impl<Left, Right> Collector for (Left, Right) where
    Left: Collector,
    Right: Collector, 

type Fruit = (<Left as Collector>::Fruit, <Right as Collector>::Fruit)

type Child = (<Left as Collector>::Child, <Right as Collector>::Child)

fn for_segment(
    &self,
    segment_local_id: u32,
    segment: &SegmentReader
) -> Result<Self::Child>

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    segment_fruits: Vec<<Self::Child as SegmentCollector>::Fruit>
) -> Result<(Left::Fruit, Right::Fruit)>

impl<One, Two, Three> Collector for (One, Two, Three) where
    One: Collector,
    Two: Collector,
    Three: Collector, 

type Fruit = (<One as Collector>::Fruit, <Two as Collector>::Fruit, <Three as Collector>::Fruit)

type Child = (<One as Collector>::Child, <Two as Collector>::Child, <Three as Collector>::Child)

fn for_segment(
    &self,
    segment_local_id: u32,
    segment: &SegmentReader
) -> Result<Self::Child>

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    children: Vec<<Self::Child as SegmentCollector>::Fruit>
) -> Result<Self::Fruit>

impl<One, Two, Three, Four> Collector for (One, Two, Three, Four) where
    One: Collector,
    Two: Collector,
    Three: Collector,
    Four: Collector, 

type Fruit = (<One as Collector>::Fruit, <Two as Collector>::Fruit, <Three as Collector>::Fruit, <Four as Collector>::Fruit)

type Child = (<One as Collector>::Child, <Two as Collector>::Child, <Three as Collector>::Child, <Four as Collector>::Child)

fn for_segment(
    &self,
    segment_local_id: u32,
    segment: &SegmentReader
) -> Result<Self::Child>

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    children: Vec<<Self::Child as SegmentCollector>::Fruit>
) -> Result<Self::Fruit>

Implementors

impl Collector for AggregationCollector

type Fruit = AggregationResults

type Child = AggregationSegmentCollector

impl Collector for DistributedAggregationCollector

type Fruit = IntermediateAggregationResults

type Child = AggregationSegmentCollector

impl Collector for Count

type Fruit = usize

type Child = SegmentCountCollector

impl Collector for DocSetCollector

type Fruit = HashSet<DocAddress, RandomState>

type Child = DocSetChildCollector

impl Collector for FacetCollector

type Fruit = FacetCounts

type Child = FacetSegmentCollector

impl Collector for HistogramCollector

type Fruit = Vec<u64, Global>

type Child = SegmentHistogramCollector

impl Collector for TopDocs

type Fruit = Vec<(f32, DocAddress), Global>

type Child = TopScoreSegmentCollector

impl<'a> Collector for MultiCollector<'a>

type Fruit = MultiFruit

type Child = MultiCollectorChild

impl<TCollector, TPredicate, TPredicateValue: FastValue> Collector for FilterCollector<TCollector, TPredicate, TPredicateValue> where
    TCollector: Collector + Send + Sync,
    TPredicate: 'static + Fn(TPredicateValue) -> bool + Send + Sync + Clone,
    TPredicateValue: FastValue, 

type Fruit = <TCollector as Collector>::Fruit

type Child = FilterSegmentCollector<<TCollector as Collector>::Child, TPredicate, TPredicateValue>