Trait Pattern

pub trait Pattern {
    // Required method
    fn eval(&self, input: &[u8]) -> Option<usize>;

    // Provided methods
    fn then<P>(self, other: P) -> Sequence<Self, P>
       where Self: Sized,
             P: Pattern { ... }
    fn and<P>(self, other: P) -> Composition<Self, P>
       where Self: Sized,
             P: Pattern { ... }
    fn or<P>(self, other: P) -> Choice<Self, P>
       where Self: Sized,
             P: Pattern { ... }
}

Expresses that the implementing can be used to match a slice of bytes.

Required Methods

fn eval(&self, input: &[u8]) -> Option<usize>

Evaluates the pattern against a slice of bytes. If the pattern matches, the length of matching bytes should be returned. Otherwise, None should be returned.

It is assumed that the pattern begins matching from the beining of the slice.

Provided Methods

fn then<P>(self, other: P) -> Sequence<Self, P>

where Self: Sized, P: Pattern,

Returns a new pattern that will match if self and other match in sequence.

use bparse::Pattern;

let pattern = "a".then("b");
assert_eq!(pattern.eval(b"abc"), Some(2));

fn and<P>(self, other: P) -> Composition<Self, P>

where Self: Sized, P: Pattern,

Returns a new pattern that will match if both self and other match.

Unlike Pattern::then, self and other are evaluated against the same input.

use bparse::{Pattern, hex, alpha};

let pattern = hex().and(alpha());
assert_eq!(pattern.eval(b"a"), Some(1));
assert_eq!(pattern.eval(b"3"), None);

fn or<P>(self, other: P) -> Choice<Self, P>

where Self: Sized, P: Pattern,

Returns a new pattern that will match if either self or other match.

use bparse::Pattern;

let pattern = "a".or("b");
assert_eq!(pattern.eval(b"ba"), Some(1));

Implementations on Foreign Types

impl Pattern for &str

fn eval(&self, input: &[u8]) -> Option<usize>

Implementors

impl Pattern for Any

impl Pattern for ByteRange

impl Pattern for ByteSlice<'_>

impl Pattern for End

impl Pattern for LookupTable

impl<P1, P2> Pattern for Choice<P1, P2>

where P1: Pattern, P2: Pattern,

impl<P1, P2> Pattern for Composition<P1, P2>

where P1: Pattern, P2: Pattern,

impl<P1, P2> Pattern for Sequence<P1, P2>

where P1: Pattern, P2: Pattern,

impl<P> Pattern for NegativeLookahead<P>

where P: Pattern,

impl<P> Pattern for Repetition<P>

where P: Pattern,