Trait Collector 

pub trait Collector {
    // Required method
    fn collect(
        &mut self,
        doc_id: DocId,
        score: Score,
        positions: &[(u32, Vec<ScoredPosition>)],
    );

    // Provided methods
    fn collect_count(&mut self, _count: u64) -> bool { ... }
    fn ranked_count_limit(&self) -> Option<usize> { ... }
    fn collect_omitted_count(&mut self, _count: u64) { ... }
    fn supports_score_blocks(&self) -> bool { ... }
    fn collect_score_block(
        &mut self,
        base: DocId,
        scores: &[Score; 64],
        bits: u64,
    ) { ... }
    fn would_collect(&self, _doc_id: DocId, _score: Score) -> bool { ... }
    fn collect_owned(
        &mut self,
        doc_id: DocId,
        score: Score,
        positions: MatchedPositions,
    ) { ... }
    fn needs_scores(&self) -> bool { ... }
    fn needs_positions(&self) -> bool { ... }
}

Trait for search result collectors

Implement this trait to create custom collectors that can be combined and passed to query execution.

Required Methods

fn collect( &mut self, doc_id: DocId, score: Score, positions: &[(u32, Vec<ScoredPosition>)], )

Called for each matching document positions: Vec of (field_id, scored_positions)

Provided Methods

fn collect_count(&mut self, _count: u64) -> bool

Accept a known exact number of matches without visiting documents. Return false without changing state to request ordinary collection. This is only offered to score- and position-free collectors.

fn ranked_count_limit(&self) -> Option<usize>

Opt into exact counting separately from ranked collection. A finite limit promises that retaining this many highest ranked matches is enough. Custom collectors keep exhaustive callbacks by default.

fn collect_omitted_count(&mut self, _count: u64)

Account for exact matches omitted by the ranked path. Called only after ranked_count_limit opts in; must preserve every count/total_seen field.

fn supports_score_blocks(&self) -> bool

Opt into bounded score blocks when positions and per-hit deadline checks are unnecessary. Custom collectors retain per-document calls. Tuple children opting in permit calls to be grouped by collector.

fn collect_score_block(&mut self, base: DocId, scores: &[Score; 64], bits: u64)

Collect set bits in increasing document order, with scores[i] for document base + i. Set bits must address valid document IDs. The driver calls this only after supports_score_blocks returns true.

fn would_collect(&self, _doc_id: DocId, _score: Score) -> bool

Whether this score can enter the collector’s retained result set.

The scorer still calls collect when this returns false so counters and other side effects remain exact; it only skips materializing positions.

fn collect_owned( &mut self, doc_id: DocId, score: Score, positions: MatchedPositions, )

Collect already-owned positions. Position-aware collectors can override this to move the nested vectors instead of cloning them.

fn needs_scores(&self) -> bool

Whether this collector consumes scores. Returning false permits the driver to pass 0.0 without evaluating BM25. Position consumers still force scoring; custom collectors retain the previous behavior by default.

fn needs_positions(&self) -> bool

Whether this collector needs position information

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A: Collector, B: Collector, C: Collector> Collector for (&mut A, &mut B, &mut C)

fn ranked_count_limit(&self) -> Option<usize>

fn collect_omitted_count(&mut self, count: u64)

fn supports_score_blocks(&self) -> bool

fn collect_score_block(&mut self, base: DocId, scores: &[Score; 64], bits: u64)

fn needs_scores(&self) -> bool

fn collect( &mut self, doc_id: DocId, score: Score, positions: &[(u32, Vec<ScoredPosition>)], )

fn needs_positions(&self) -> bool

fn would_collect(&self, doc_id: DocId, score: Score) -> bool

fn collect_owned( &mut self, doc_id: DocId, score: Score, positions: MatchedPositions, )

impl<A: Collector, B: Collector> Collector for (&mut A, &mut B)

fn ranked_count_limit(&self) -> Option<usize>

fn collect_omitted_count(&mut self, count: u64)

fn supports_score_blocks(&self) -> bool

fn collect_score_block(&mut self, base: DocId, scores: &[Score; 64], bits: u64)

fn needs_scores(&self) -> bool

fn collect( &mut self, doc_id: DocId, score: Score, positions: &[(u32, Vec<ScoredPosition>)], )

fn needs_positions(&self) -> bool

fn would_collect(&self, doc_id: DocId, score: Score) -> bool

fn collect_owned( &mut self, doc_id: DocId, score: Score, positions: MatchedPositions, )

Implementors

impl Collector for CountCollector

impl Collector for TopKCollector