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.

The returned Pattern will match occurances of the pattern which start at any in a byte or character stream — the pattern may be preceded by any number of non-matching characters. Essentially, it will behave as though the regular expression started with a .*?, which enables a match to appear anywhere. If this is not the desired behavior, use Pattern::new_anchored instead.

For example:

use matchers::Pattern;

// This pattern matches any number of `a`s followed by a `b`.
let pattern = Pattern::new("a+b").expect("regex is not invalid");

// Of course, the pattern matches an input where the entire sequence of
// characters matches the pattern:
assert!(pattern.display_matches(&"aaaaab"));

// And, since the pattern is unanchored, it will also match the
// sequence when it's followed by non-matching characters:
assert!(pattern.display_matches(&"hello world! aaaaab"));

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

Returns a new Pattern anchored at the beginning of the input stream, or an error if the regex was invalid.

The returned Pattern will only match an occurence of the pattern in an input sequence if the first character or byte in the input matches the pattern. If this is not the desired behavior, use Pattern::new instead.

For example:

use matchers::Pattern;

// This pattern matches any number of `a`s followed by a `b`.
let pattern = Pattern::new_anchored("a+b")
    .expect("regex is not invalid");

// The pattern matches an input where the entire sequence of
// characters matches the pattern:
assert!(pattern.display_matches(&"aaaaab"));

// Since the pattern is anchored, it will *not* match an input that
// begins with non-matching characters:
assert!(!pattern.display_matches(&"hello world! aaaaab"));

// ...however, if we create a pattern beginning with `.*?`, it will:
let pattern2 = Pattern::new_anchored(".*?a+b")
    .expect("regex is not invalid");
assert!(pattern2.display_matches(&"hello world! aaaaab"));

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>