Struct matchers::Pattern

pub struct Pattern<S = usize, A = DenseDFA<Vec<S>, S>> where
    S: StateID,
    A: DFA<ID = S>,  { /* fields omitted */ }

A compiled match pattern that can match multipe inputs, or return a Matcher that matches a single input.

Implementations

impl Pattern

pub fn new(pattern: &str) -> Result<Self, Error>

Returns a new Pattern for the given regex, or an error if the regex was invalid.

impl<S, A> Pattern<S, A> where
    S: StateID,
    A: DFA<ID = S>,
    Self: for<'a> ToMatcher<'a, S>, 

pub fn matches(&self, s: &impl AsRef<str>) -> bool

Returns true if this pattern matches the given string.

pub fn debug_matches(&self, d: &impl Debug) -> bool

Returns true if this pattern matches the formatted output of the given type implementing fmt::Debug.

For example:

use matchers::Pattern;

#[derive(Debug)]
pub struct Hello {
    to: &'static str,
}

let pattern = Pattern::new(r#"Hello \{ to: "W[^"]*" \}"#).unwrap();

let hello_world = Hello { to: "World" };
assert!(pattern.debug_matches(&hello_world));

let hello_sf = Hello { to: "San Francisco" };
assert_eq!(pattern.debug_matches(&hello_sf), false);

let hello_washington = Hello { to: "Washington" };
assert!(pattern.debug_matches(&hello_washington));

pub fn display_matches(&self, d: &impl Display) -> bool

Returns true if this pattern matches the formatted output of the given type implementing fmt::Display.

For example:

use matchers::Pattern;

#[derive(Debug)]
pub struct Hello {
    to: &'static str,
}

impl fmt::Display for Hello {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Hello {}", self.to)
    }
}

let pattern = Pattern::new("Hello [Ww].+").unwrap();

let hello_world = Hello { to: "world" };
assert!(pattern.display_matches(&hello_world));
assert_eq!(pattern.debug_matches(&hello_world), false);

let hello_sf = Hello { to: "San Francisco" };
assert_eq!(pattern.display_matches(&hello_sf), false);

let hello_washington = Hello { to: "Washington" };
assert!(pattern.display_matches(&hello_washington));

pub fn read_matches(&self, io: impl Read) -> Result<bool>

Returns either a bool indicating whether or not this pattern matches the data read from the provided io::Read stream, or an io::Error if an error occurred reading from the stream.

Trait Implementations

impl<S: Clone, A: Clone> Clone for Pattern<S, A> where
    S: StateID,
    A: DFA<ID = S>, 

fn clone(&self) -> Pattern<S, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, A: Debug> Debug for Pattern<S, A> where
    S: StateID,
    A: DFA<ID = S>, 

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

Formats the value using the given formatter.

impl FromStr for Pattern

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<'a, S> ToMatcher<'a, S> for Pattern<S, DenseDFA<Vec<S>, S>> where
    S: StateID + 'a, 

type Automaton = DenseDFA<&'a [S], S>

fn matcher(&'a self) -> Matcher<'a, S, Self::Automaton>

impl<'a, S> ToMatcher<'a, S> for Pattern<S, SparseDFA<Vec<u8>, S>> where
    S: StateID + 'a, 

type Automaton = SparseDFA<&'a [u8], S>

fn matcher(&'a self) -> Matcher<'a, S, Self::Automaton>