Struct Regex 

pub struct Regex { /* private fields */ }

compiled regex backed by a lazy DFA.

uses a Mutex for mutable DFA state.

Implementations

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: EngineOptions) -> Result<Regex, Error>

compile a pattern with custom EngineOptions.

use resharp::{Regex, EngineOptions};

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

pub fn from_node( b: RegexBuilder, node: NodeId, opts: EngineOptions, ) -> Result<Regex, Error>

build from a pre-constructed AST node.

pub fn is_hardened(&self) -> bool

whether hardened linear-scan mode is enabled

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));

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.