Struct porigon::Searchable

pub struct Searchable { /* fields omitted */ }

Main entry point to building and querying FSTs.

This is a thin wrapper around fst::Map, providing easy access to querying it in various ways (exact_match, starts_with, levenshtein, ...).

NOTE: this struct is serializable

Methods

impl Searchable

pub fn starts_with<'a>(&'a self, query: &'a str) -> SearchStream<'a>

Creates a SearchStream from a StartsWith matcher for the given query.

Example

use fst::Streamer;
use porigon::Searchable;

let items = vec!(
    ("bar".as_bytes(), 1),
    ("foo".as_bytes(), 2),
    ("foo_bar".as_bytes(), 3)
);
let searchable = Searchable::build_from_iter(items).unwrap();

let mut strm = searchable.starts_with("foo");
assert_eq!(strm.next(), Some(("foo".as_bytes(), 2, 0)));
assert_eq!(strm.next(), Some(("foo_bar".as_bytes(), 3, 0)));
assert_eq!(strm.next(), None);

pub fn exact_match<'a>(&'a self, query: &'a str) -> SearchStream<'a>

Creates a SearchStream from an ExactMatch matcher for the given query.

Example

use fst::Streamer;
use porigon::Searchable;

let items = vec!(
    ("bar".as_bytes(), 1),
    ("foo".as_bytes(), 2),
    ("foo_bar".as_bytes(), 3)
);
let searchable = Searchable::build_from_iter(items).unwrap();

let mut strm = searchable.exact_match("foo");
assert_eq!(strm.next(), Some(("foo".as_bytes(), 2, 0)));
assert_eq!(strm.next(), None);

pub fn levenshtein<'a, D>(&'a self, dfa: D) -> SearchStream<'a> where
    D: Into<MaybeOwned<'a, DFA>>, 

Creates a SearchStream from a levenshtein_automata::DFA matcher.

This method supports both moving the DFA or passing a reference to it.

Example

use fst::Streamer;
use porigon::{LevenshteinAutomatonBuilder, Searchable};

let items = vec!(
    ("bar".as_bytes(), 1),
    ("fob".as_bytes(), 2),
    ("foo".as_bytes(), 3),
    ("foo_bar".as_bytes(), 4)
);
let searchable = Searchable::build_from_iter(items).unwrap();
let levenshtein_builder = LevenshteinAutomatonBuilder::new(1, false);

let dfa = levenshtein_builder.build_dfa("foo");
let mut strm = searchable.levenshtein(&dfa);
assert_eq!(strm.next(), Some(("fob".as_bytes(), 2, 0)));
assert_eq!(strm.next(), Some(("foo".as_bytes(), 3, 0)));
assert_eq!(strm.next(), None);

pub fn levenshtein_exact_match<'a>(
    &'a self,
    builder: &LevenshteinAutomatonBuilder,
    query: &'a str
) -> SearchStream<'a>

Creates a SearchStream for a LevenshteinAutomatonBuilder and the given query.

Example

use fst::Streamer;
use porigon::{LevenshteinAutomatonBuilder, Searchable};

let items = vec!(
    ("bar".as_bytes(), 1),
    ("fob".as_bytes(), 2),
    ("foo".as_bytes(), 3),
    ("foo_bar".as_bytes(), 4)
);
let searchable = Searchable::build_from_iter(items).unwrap();
let levenshtein_builder = LevenshteinAutomatonBuilder::new(1, false);

let dfa = levenshtein_builder.build_dfa("foo");
let mut strm = searchable.levenshtein_exact_match(&levenshtein_builder, "foo");
assert_eq!(strm.next(), Some(("fob".as_bytes(), 2, 0)));
assert_eq!(strm.next(), Some(("foo".as_bytes(), 3, 0)));
assert_eq!(strm.next(), None);

pub fn levenshtein_starts_with<'a>(
    &'a self,
    builder: &LevenshteinAutomatonBuilder,
    query: &'a str
) -> SearchStream<'a>

Creates a SearchStream for a LevenshteinAutomatonBuilder and the given query.

Example

use fst::Streamer;
use porigon::{LevenshteinAutomatonBuilder, Searchable};

let items = vec!(
    ("bar".as_bytes(), 1),
    ("fob".as_bytes(), 2),
    ("foo".as_bytes(), 3),
    ("foo_bar".as_bytes(), 4)
);
let searchable = Searchable::build_from_iter(items).unwrap();
let levenshtein_builder = LevenshteinAutomatonBuilder::new(1, false);

let dfa = levenshtein_builder.build_dfa("foo");
let mut strm = searchable.levenshtein_starts_with(&levenshtein_builder, "foo");
assert_eq!(strm.next(), Some(("fob".as_bytes(), 2, 0)));
assert_eq!(strm.next(), Some(("foo".as_bytes(), 3, 0)));
assert_eq!(strm.next(), Some(("foo_bar".as_bytes(), 4, 0)));
assert_eq!(strm.next(), None);

pub fn subsequence<'a>(&'a self, query: &'a str) -> SearchStream<'a>

Creates a SearchStream from a Subsequence matcher for the given query.

Example

use fst::Streamer;
use porigon::Searchable;

let items = vec!(("bar_foo".as_bytes(), 2), ("foo".as_bytes(), 0), ("foo_bar".as_bytes(), 1));
let searchable = Searchable::build_from_iter(items).unwrap();

let mut strm = searchable.subsequence("fb");
assert_eq!(strm.next(), Some(("foo_bar".as_bytes(), 1, 0)));
assert_eq!(strm.next(), None);

pub fn build_from_iter<'a, I>(iter: I) -> Result<Searchable, Error> where
    I: IntoIterator<Item = (&'a [u8], u64)>, 

Construct a Searchable from an Iterator<Item=(&[u8], u64)>.

Example

use porigon::Searchable;

let searchable = Searchable::build_from_iter(vec!(
    ("bar".as_bytes(), 1),
    ("foo".as_bytes(), 2),
)).unwrap();

Trait Implementations

impl<'de> Deserialize<'de> for Searchable

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Searchable

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.