Struct Regex 

pub struct Regex { /* private fields */ }

Lazily compiled regex instance. Uses Mutex for interior mutability.

Implementations

impl Regex

pub fn stream(&self, input: &[u8]) -> Result<Vec<Match>, Error>

Shortest matches, left-to-right. State resets after each match.

pub fn stream_with<F: FnMut(Match)>( &self, input: &[u8], on_match: F, ) -> Result<(), Error>

Shortest matches; callback variant of Regex::stream.

pub fn stream_first(&self, input: &[u8]) -> Result<Option<Match>, Error>

Shortest match starting earliest in input, or None.

impl Regex

pub fn stream_ends(&self, input: &[u8]) -> Result<Vec<usize>, Error>

Shortest match ends only; skips the rev pass.

pub fn stream_ends_with<F: FnMut(usize)>( &self, input: &[u8], on_match: F, ) -> Result<(), Error>

Shortest match ends; callback variant of Regex::stream_ends.

impl Regex

pub const SEEK_INITIAL: u32 = 0

Initial state for Regex::seek_fwd / Regex::seek_rev cursors.

pub fn stream_chunk<F: FnMut(usize)>( &self, chunk: &[u8], state: StreamState, on_match: F, ) -> Result<StreamState, Error>

Feed one chunk, resuming from state. Emits shortest match ends in absolute offsets. Pass StreamState::new() for the first chunk.

pub fn seek_fwd( &self, input: &[u8], state: u32, pos: usize, ) -> Result<Option<(u32, usize)>, Error>

Forward cursor scan; returns the next shortest match end as (resume_state, end). First call: state = SEEK_INITIAL, pos = 0. Subsequent calls: pass back the returned values.

pub fn seek_rev( &self, input: &[u8], state: u32, pos: usize, ) -> Result<Option<(u32, usize)>, Error>

Reverse cursor scan over input[..pos] using rev LDFA on _*·rev(node). Returns the next shortest match start (rightmost-first) as (resume_state, start). First call: state = SEEK_INITIAL, pos = input.len().

impl Regex

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

compile a pattern with default options.

let re = resharp::Regex::new(r"\b\w+\b").unwrap();

pub fn with_options(pattern: &str, opts: RegexOptions) -> Result<Regex, Error>

compile a pattern with custom RegexOptions.

use resharp::{Regex, RegexOptions};

let re = Regex::with_options(
    r"hello",
    RegexOptions::default().case_insensitive(true),
).unwrap();
assert!(re.is_match(b"HELLO").unwrap());

pub fn find_all(&self, input: &[u8]) -> Result<Vec<Match>, Error>

all non-overlapping leftmost-first matches as [start, end) byte ranges.

let re = resharp::Regex::new(r"\d+").unwrap();
let m = re.find_all(b"abc 123 def 456").unwrap();
assert_eq!(m.len(), 2);
assert_eq!((m[0].start, m[0].end), (4, 7));

impl Regex

pub fn find_anchored(&self, input: &[u8]) -> Result<Option<Match>, Error>

longest match anchored at position 0.

returns None if the pattern does not match at position 0.

pub fn is_match(&self, input: &[u8]) -> Result<bool, Error>

whether the pattern matches anywhere in the input.

faster than find_all when you only need a yes/no answer.