Struct elipdotter::index::Lossless

pub struct Lossless { /* private fields */ }

Index which keeps track of all occurrences of all words.

Much (10x) faster than Simple, but memory usage grows linearly with content added. Simples memory usage grows only with word count & document count. If you have relatively short documents, this doesn’t take up a lot more memory (only about 2-4x).

Implementations

impl Lossless

pub fn new( proximity_threshold: f32, proximity_algorithm: Algorithm, word_count_limit: usize ) -> Self

proximity_threshold is the threshold where alike words are also accepted. It uses the range [0..1], where values nearer 0 allow more words. The default is 0.9.

proximity_threshold is the algorithm used for proximity checking of words.

word_count_limit is the number of words in this index where only words with the first character is used for approximate matching. Default is 2_500.

pub fn ingest(&mut self, other: Self)

Merges other with self.

Trait Implementations

impl Clone for Lossless

fn clone(&self) -> Lossless

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Lossless

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Lossless

Self::new with proximity_threshold set to 0.85.

fn default() -> Self

Returns the “default value” for a type.

impl<'a> Provider<'a> for Lossless

fn insert_word(&mut self, word: impl AsRef<str>, document: Id, index: usize)

O(log n log n)

fn remove_document(&mut self, document: Id)

O(n log n)

fn contains_word(&self, word: impl AsRef<str>, document: Id) -> bool

O(log n log n)

fn documents_with_word( &'a self, word: impl AsRef<str> ) -> Option<Self::DocumentIter>

O(log n)

Iterator is O(1) - running this and consuming the iterator is O(n log n).

You can get the length of the list using the ExactSizeIterator trait.

type DocumentIter = Copied<Keys<'a, Id, LosslessDocOccurrences>>

type WordIter = Keys<'a, Arc<Alphanumeral<StrPtr>>, LosslessDocMap>

type WordFilteredIter = Map<Range<'a, Arc<Alphanumeral<StrPtr>>, LosslessDocMap>, fn(_: (&'a Arc<Alphanumeral<StrPtr>>, &'a LosslessDocMap)) -> &'a Arc<Alphanumeral<StrPtr>>>

fn size(&self) -> usize

Estimate of the number of bytes this index uses in memory, specifically the heap.

fn word_count_upper_limit(&self) -> usize

fn word_count_limit(&self) -> usize

The limit of Self::word_count_upper_limit where Self::words_starting_with is used instead of Self::words.

fn words(&'a self) -> Self::WordIter

fn words_starting_with(&'a self, c: char) -> Self::WordFilteredIter

fn word_proximity_threshold(&self) -> f32

fn word_proximity_algorithm(&self) -> Algorithm

fn digest_document(&mut self, id: Id, content: &str)

Only adds words which are alphanumeric.