Struct fst_subseq_ascii_caseless::SubseqAsciiCaseless

pub struct SubseqAsciiCaseless<'a> { /* fields omitted */ }

An automaton that matches if the input contains a specific subsequence ignoring ASCII case.

It is similar to fst::automaton::Subsequence, and can be used to build a simple fuzzy-finder for ASCII-only content.

Methods

impl<'a> SubseqAsciiCaseless<'a>

pub fn new(subseq: &'a str) -> Self

Constructs automaton that matches input containing the specified subsequence ignoring ASCII case.

Panics

Panics if subseq contains any ASCII uppercase character.

pub fn new_unchecked(subseq: &'a str) -> Self

Same as new() but don't check the string.

It would never match if the subseq contains any ASCII uppercase character.

Trait Implementations

impl<'a> Clone for SubseqAsciiCaseless<'a>

fn clone(&self) -> SubseqAsciiCaseless<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SubseqAsciiCaseless<'a>

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

Formats the value using the given formatter.

impl<'a> Automaton for SubseqAsciiCaseless<'a>

type State = usize

The type of the state used in the automaton.

fn start(&self) -> usize

Returns a single start state for this automaton.

fn is_match(&self, state: &usize) -> bool

Returns true if and only if state is a match state.

fn can_match(&self, _: &usize) -> bool

Returns true if and only if state can lead to a match in zero or more steps.

fn will_always_match(&self, state: &usize) -> bool

Returns true if and only if state matches and must match no matter what steps are taken.

fn accept(&self, state: &usize, byte: u8) -> usize

Return the next state given state and an input.

fn starts_with(self) -> StartsWith<Self>

Returns an automaton that matches the strings that start with something this automaton matches.

fn union<Rhs>(self, rhs: Rhs) -> Union<Self, Rhs> where     Rhs: Automaton,

Returns an automaton that matches the strings matched by either this or the other automaton.

fn intersection<Rhs>(self, rhs: Rhs) -> Intersection<Self, Rhs> where     Rhs: Automaton,

Returns an automaton that matches the strings matched by both this and the other automaton.

fn complement(self) -> Complement<Self>

Returns an automaton that matches the strings not matched by this automaton.