Struct tantivy::fastfield::IntFastFieldWriter

pub struct IntFastFieldWriter { /* private fields */ }

Fast field writer for ints. The fast field writer just keeps the values in memory.

Only when the segment writer can be closed and persisted on disc, the fast field writer is sent to a FastFieldSerializer via the .serialize(...) method.

We cannot serialize earlier as the values are bitpacked and the number of bits required for bitpacking can only been known once we have seen all of the values.

Both u64, i64 and f64 use the same writer. i64 and f64 are just remapped to the 0..2^64 - 1 using common::i64_to_u64 and common::f64_to_u64.

Implementations

impl IntFastFieldWriter

pub fn new(field: Field) -> IntFastFieldWriter

Creates a new IntFastFieldWriter

pub fn mem_usage(&self) -> usize

The memory used (inclusive childs)

pub fn field(&self) -> Field

Returns the field that this writer is targetting.

pub fn add_val(&mut self, val: u64)

Records a new value.

The n-th value being recorded is implicitely associated to the document with the DocId n. (Well, n-1 actually because of 0-indexing)

pub fn add_document(&mut self, doc: &Document)

Extract the fast field value from the document (or use the default value) and records it.

Extract the value associated to the fast field for this document.

i64 and f64 are remapped to u64 using the logic in common::i64_to_u64 and common::f64_to_u64.

If the value is missing, then the default value is used instead. If the document has more than one value for the given field, only the first one is taken in account.

Values on text fast fields are skipped.

pub fn serialize(
    &self,
    serializer: &mut CompositeFastFieldSerializer,
    doc_id_map: Option<&DocIdMapping>
) -> Result<()>

Push the fast fields value to the FastFieldWriter.