Trait Pattern

pub trait Pattern: Clone + Copy {
    // 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 type may be used to match part of 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));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Pattern for &str

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

impl<T> Pattern for &T

where T: Pattern,

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

Implementors

impl Pattern for ByteRange

impl Pattern for ByteSlice<'_>

impl Pattern for End

impl Pattern for LookupTable

impl Pattern for SingleByte

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 Not<P>

where P: Pattern,

impl<P> Pattern for Repetition<P>

where P: Pattern,