Struct grep_hyperscan::RegexMatcher

pub struct RegexMatcher { /* fields omitted */ }

An implementation of the Matcher trait using hyperscan.

Methods

impl RegexMatcher

pub fn new(patterns: &[String]) -> Result<RegexMatcher, Error>

Create a new matcher from the given pattern using the default configuration.

Trait Implementations

impl Clone for RegexMatcher

A thread safe implementation of Clone for our hyperscan RegexMatcher (1 scratchpad / thread)

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RegexMatcher

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

Formats the value using the given formatter.

impl Matcher for RegexMatcher

type Captures = NoCaptures

The concrete type of capturing groups used for this matcher.

type Error = Error

The error type used by this matcher.

fn find_at(
    &self,
    haystack: &[u8],
    at: usize
) -> Result<Option<Match>, Self::Error>

Main implementation. Just try to get the current MatchData for the thread before calling the actual find_at function. Note that we don't get the thread data for the scratchpad yet, as we can still read data from hyperscan result or from the buffered results.

fn new_captures(&self) -> Result<NoCaptures, Self::Error>

Hyperscan can not match captures, hence the NoCaptures

fn capture_count(&self) -> usize

Returns the total number of capturing groups in this matcher.

fn capture_index(&self, _name: &str) -> Option<usize>

Maps the given capture group name to its corresponding capture group index, if one exists. If one does not exist, then None is returned.

fn find(&self, haystack: &[u8]) -> Result<Option<Match>, Self::Error>

Returns the start and end byte range of the first match in haystack. If no match exists, then None is returned.

fn find_iter<F>(&self, haystack: &[u8], matched: F) -> Result<(), Self::Error> where
    F: FnMut(Match) -> bool, 

Executes the given function over successive non-overlapping matches in haystack. If no match exists, then the given function is never called. If the function returns false, then iteration stops.

fn try_find_iter<F, E>(
    &self,
    haystack: &[u8],
    matched: F
) -> Result<Result<(), E>, Self::Error> where
    F: FnMut(Match) -> Result<bool, E>, 

Executes the given function over successive non-overlapping matches in haystack. If no match exists, then the given function is never called. If the function returns false, then iteration stops. Similarly, if the function returns an error then iteration stops and the error is yielded. If an error occurs while executing the search, then it is converted to E.

fn captures(
    &self,
    haystack: &[u8],
    caps: &mut Self::Captures
) -> Result<bool, Self::Error>

Populates the first set of capture group matches from haystack into caps. If no match exists, then false is returned.

fn captures_iter<F>(
    &self,
    haystack: &[u8],
    caps: &mut Self::Captures,
    matched: F
) -> Result<(), Self::Error> where
    F: FnMut(&Self::Captures) -> bool, 

Executes the given function over successive non-overlapping matches in haystack with capture groups extracted from each match. If no match exists, then the given function is never called. If the function returns false, then iteration stops.

fn try_captures_iter<F, E>(
    &self,
    haystack: &[u8],
    caps: &mut Self::Captures,
    matched: F
) -> Result<Result<(), E>, Self::Error> where
    F: FnMut(&Self::Captures) -> Result<bool, E>, 

Executes the given function over successive non-overlapping matches in haystack with capture groups extracted from each match. If no match exists, then the given function is never called. If the function returns false, then iteration stops. Similarly, if the function returns an error then iteration stops and the error is yielded. If an error occurs while executing the search, then it is converted to E.

fn captures_at(
    &self,
    _haystack: &[u8],
    _at: usize,
    _caps: &mut Self::Captures
) -> Result<bool, Self::Error>

Populates the first set of capture group matches from haystack into matches after at, where the byte offsets in each capturing group are relative to the start of haystack (and not at). If no match exists, then false is returned and the contents of the given capturing groups are unspecified.

fn replace<F>(
    &self,
    haystack: &[u8],
    dst: &mut Vec<u8>,
    append: F
) -> Result<(), Self::Error> where
    F: FnMut(Match, &mut Vec<u8>) -> bool, 

Replaces every match in the given haystack with the result of calling append. append is given the start and end of a match, along with a handle to the dst buffer provided.

fn replace_with_captures<F>(
    &self,
    haystack: &[u8],
    caps: &mut Self::Captures,
    dst: &mut Vec<u8>,
    append: F
) -> Result<(), Self::Error> where
    F: FnMut(&Self::Captures, &mut Vec<u8>) -> bool, 

Replaces every match in the given haystack with the result of calling append with the matching capture groups.

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

Returns true if and only if the matcher matches the given haystack.

fn is_match_at(&self, haystack: &[u8], at: usize) -> Result<bool, Self::Error>

Returns true if and only if the matcher matches the given haystack starting at the given position.

fn shortest_match(&self, haystack: &[u8]) -> Result<Option<usize>, Self::Error>

Returns an end location of the first match in haystack. If no match exists, then None is returned.

fn shortest_match_at(
    &self,
    haystack: &[u8],
    at: usize
) -> Result<Option<usize>, Self::Error>

Returns an end location of the first match in haystack starting at the given position. If no match exists, then None is returned.

fn non_matching_bytes(&self) -> Option<&ByteSet>

If available, return a set of bytes that will never appear in a match produced by an implementation.

fn line_terminator(&self) -> Option<LineTerminator>

If this matcher was compiled as a line oriented matcher, then this method returns the line terminator if and only if the line terminator never appears in any match produced by this matcher. If this wasn't compiled as a line oriented matcher, or if the aforementioned guarantee cannot be made, then this must return None, which is the default. It is never wrong to return None, but returning a line terminator when it can appear in a match results in unspecified behavior.

fn find_candidate_line(
    &self,
    haystack: &[u8]
) -> Result<Option<LineMatchKind>, Self::Error>

Return one of the following: a confirmed line match, a candidate line match (which may be a false positive) or no match at all (which must not be a false negative). When reporting a confirmed or candidate match, the position returned can be any position in the line.