Trait tantivy::collector::Collector

pub trait Collector: Sync {
    type Fruit: Fruit;
    type Child: SegmentCollector<Fruit = Self::Fruit>;
    fn for_segment(
        &self, 
        segment_local_id: SegmentLocalId, 
        segment: &SegmentReader
    ) -> Result<Self::Child>;
    fn requires_scoring(&self) -> bool;
    fn merge_fruits(
        &self, 
        segment_fruits: Vec<Self::Fruit>
    ) -> Result<Self::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.

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<Fruit = Self::Fruit>

Type of the SegmentCollector associated to this collector.

Loading content...

Required methods

fn for_segment(
    &self,
    segment_local_id: SegmentLocalId,
    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::Fruit>) -> Result<Self::Fruit>

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

Loading content...

Implementations on Foreign Types

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

type Fruit = (Left::Fruit, Right::Fruit)

type Child = (Left::Child, Right::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<(Left::Fruit, Right::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::Fruit, Two::Fruit, Three::Fruit)

type Child = (One::Child, Two::Child, Three::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::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::Fruit, Two::Fruit, Three::Fruit, Four::Fruit)

type Child = (One::Child, Two::Child, Three::Child, Four::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::Fruit>) -> Result<Self::Fruit>

Loading content...

Implementors

impl Collector for Count

type Fruit = usize

type Child = SegmentCountCollector

fn for_segment(
    &self,
    _: SegmentLocalId,
    _: &SegmentReader
) -> Result<SegmentCountCollector>

fn requires_scoring(&self) -> bool

fn merge_fruits(&self, segment_counts: Vec<usize>) -> Result<usize>

impl Collector for FacetCollector

type Fruit = FacetCounts

type Child = FacetSegmentCollector

fn for_segment(
    &self,
    _: SegmentLocalId,
    reader: &SegmentReader
) -> Result<FacetSegmentCollector>

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    segments_facet_counts: Vec<FacetCounts>
) -> Result<FacetCounts>

impl Collector for TopDocs

type Fruit = Vec<(Score, DocAddress)>

type Child = TopScoreSegmentCollector

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

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    child_fruits: Vec<Vec<(Score, DocAddress)>>
) -> Result<Self::Fruit>

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

type Fruit = MultiFruit

type Child = MultiCollectorChild

fn for_segment(
    &self,
    segment_local_id: SegmentLocalId,
    segment: &SegmentReader
) -> Result<MultiCollectorChild>

fn requires_scoring(&self) -> bool

fn merge_fruits(
    &self,
    segments_multifruits: Vec<MultiFruit>
) -> Result<MultiFruit>

Loading content...