Struct Regex 

pub struct Regex { /* private fields */ }

A regular expression engine designed for use within the ad text editor.

This is a relatively naive implementation though it does have some optimisations and runs reasonably quickly. It is not at all designed to be robust against malicious input and it does not attempt to support full PCRE syntax or functionality.

Implementations

impl Regex

pub fn compile(re: impl AsRef<str>) -> Result<Self, Error>

Attempt to compile the given regular expression into its optimised VM opcode form.

This method handles pre-allocation of the memory required for running the VM so that the allocation cost is paid once up front rather than on each use of the Regex.

pub fn matches<H>(&self, haystack: &H) -> bool

where H: Haystack,

Determine whether or not this Regex matches the Haystack without searching for the leftmost-longest match and associated submatch boundaries.

pub fn matches_from<H>(&self, haystack: &H, offset: usize) -> bool

where H: Haystack,

Determine whether or not this Regex matches the Haystack from the given offset without searching for the leftmost-longest match and associated submatch boundaries.

pub fn matches_between<H>(&self, haystack: &H, from: usize, to: usize) -> bool

where H: Haystack,

Determine whether or not this Regex matches the Haystack between the given offsets without searching for the leftmost-longest match and associated submatch boundaries.

pub fn find<H>(&self, haystack: &H) -> Option<Match>

where H: Haystack,

Search the given Haystack for the leftmost longest match of this Regex and return the match position along with all submatches.

It is recommended that you call Haystack::try_make_contiguous before calling this method in order to speed up searching whenever this is possible.

pub fn find_from<H>(&self, haystack: &H, offset: usize) -> Option<Match>

where H: Haystack,

Search the given Haystack for the leftmost longest match of this Regex starting from the provided byte offset rather than the beginning of the haystack, returning the match position along with all submatches.

It is recommended that you call Haystack::try_make_contiguous before calling this method in order to speed up searching whenever this is possible.

pub fn find_between<H>( &self, haystack: &H, from: usize, to: usize, ) -> Option<Match>

where H: Haystack,

Search the given Haystack for the leftmost longest match of this Regex starting from the provided byte offset rather than the beginning of the haystack, and ending before the provided char_to, returning the match position along with all submatches.

It is recommended that you call Haystack::try_make_contiguous before calling this method in order to speed up searching whenever this is possible.

pub fn find_iter<'a, H>(&'a mut self, haystack: &'a H) -> MatchIter<'a, H>

where H: Haystack,

It is recommended that you call Haystack::try_make_contiguous before calling this method in order to speed up searching whenever this is possible.

Trait Implementations

impl Clone for Regex

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Regex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Regex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Haystack<Regex> for Buffer

fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool

Returns true if there is a match for the regex between the given byte offsets in the haystack.

fn captures_between( &self, re: &Regex, from: usize, to: usize, ) -> Option<RawCaptures>

Searches for the first match of this regex between the given byte offsets in the given haystack, returning the overall match along with the matches of each capture group in the regex. If no match is found, then None is returned.

impl<R> Haystack<Regex> for CachingStream<R>

where R: Read,

fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool

Returns true if there is a match for the regex between the given byte offsets in the haystack.

fn captures_between( &self, re: &Regex, from: usize, to: usize, ) -> Option<RawCaptures>

Searches for the first match of this regex between the given byte offsets in the given haystack, returning the overall match along with the matches of each capture group in the regex. If no match is found, then None is returned.

impl Haystack<Regex> for GapBuffer

fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool

Returns true if there is a match for the regex between the given byte offsets in the haystack.

fn captures_between( &self, re: &Regex, from: usize, to: usize, ) -> Option<RawCaptures>

Searches for the first match of this regex between the given byte offsets in the given haystack, returning the overall match along with the matches of each capture group in the regex. If no match is found, then None is returned.

impl Haystack<Regex> for str

fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool

Returns true if there is a match for the regex between the given byte offsets in the haystack.

fn captures_between( &self, re: &Regex, from: usize, to: usize, ) -> Option<RawCaptures>

Searches for the first match of this regex between the given byte offsets in the given haystack, returning the overall match along with the matches of each capture group in the regex. If no match is found, then None is returned.

impl PartialEq for Regex

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RegexEngine for Regex

type CompileError = Error

Error type that is returned by the RegexEngine::compile method when compilation of a given regular expression fails. This will be wrapped into an Error when returned from Structex::compile or StructexBuilder::build.

fn compile(re: &str) -> Result<Self, Self::CompileError>

Attempt to compile the given regular expression for use inside of a Structex.

impl Eq for Regex