Struct hyperscan::expression::Expression

pub struct Expression(/* private fields */);

Available on crate feature compiler only.

Hyperscan regex pattern string.

Hyperscan itself supports a subset of PCRE syntax in the pattern string; see Pattern Support for reference. The use of unsupported constructs will result in compilation errors.

Note that as the underlying hyperscan library interprets pattern strings as essentially null-terminated CStr pointers, null bytes are not supported within Expression strings. Use a Literal or LiteralSet database if you need to match against patterns with null bytes.

Instances can be created equivalently with Self::new() or str::parse() via the str::FromStr impl:

 use hyperscan::expression::Expression;

 let e1: Expression = "asdf+".parse()?;
 let e2 = Expression::new("asdf+")?;
 assert_eq!(e1, e2);

Implementations

impl Expression

pub fn as_bytes(&self) -> &[u8]

Reference the underlying bytes, without the trailing null terminator.

 let e = hyperscan::expression::Expression::new("asdf")?;
 assert_eq!(e.as_bytes(), b"asdf");

pub fn new(x: impl Into<Vec<u8>>) -> Result<Self, HyperscanCompileError>

Produce a NULL-terminated C-style wrapper for the given pattern string.

This will fail if the string contains any internal NULL bytes, as those are not supported by the hyperscan regex compiler:

 use hyperscan::{expression::*, error::*};

 let pat = "as\0df";
 let e = match Expression::new(pat) {
    Err(HyperscanCompileError::NullByte(e)) => e,
    _ => unreachable!(),
 };
 assert_eq!(e.nul_position(), 2);

pub fn info(&self, flags: Flags) -> Result<ExprInfo, HyperscanCompileError>

Utility function providing information about a regular expression. The information provided in info::ExprInfo includes the minimum and maximum width of a pattern match.

Note: successful analysis of an expression with this function does not imply that compilation of the same expression (via Database::compile() or Database::compile_multi()) would succeed. This function may return Ok for regular expressions that Hyperscan cannot compile.

Note: some per-pattern flags (such as Flags::ALLOWEMPTY and Flags::SOM_LEFTMOST) are accepted by this call, but as they do not affect the properties returned in the info::ExprInfo structure, they will not affect the outcome of this function.

 use hyperscan::{expression::{*, info::*}, flags::Flags};

 let expr: Expression = "(he)llo".parse()?;

 let info = expr.info(Flags::default())?;

 assert_eq!(info, ExprInfo {
   min_width: ExprWidth(5),
   max_width: Some(ExprWidth(5)),
   unordered_matches: UnorderedMatchBehavior::OnlyOrdered,
   matches_at_eod: MatchAtEndBehavior::WillNeverMatchAtEOD,
 });

pub fn ext_info( &self, flags: Flags, ext_flags: &ExprExt ) -> Result<ExprInfo, HyperscanCompileError>

Utility function providing information about a regular expression, with extended parameter support. The information provided in info::ExprInfo includes the minimum and maximum width of a pattern match.

Note: successful analysis of an expression with this function does not imply that compilation of the same expression (via Database::compile() or Database::compile_multi()) would succeed. This function may return Ok for regular expressions that Hyperscan cannot compile.

Note: some per-pattern flags (such as Flags::ALLOWEMPTY and Flags::SOM_LEFTMOST) are accepted by this call, but as they do not affect the properties returned in the info::ExprInfo structure, they will not affect the outcome of this function.

 use hyperscan::{expression::{*, info::*}, flags::Flags};

 let expr: Expression = ".*lo".parse()?;

 let ext = ExprExt::from_min_length(4);

 let info = expr.ext_info(Flags::default(), &ext)?;

 assert_eq!(info, ExprInfo {
   min_width: ExprWidth(4),
   max_width: None,
   unordered_matches: UnorderedMatchBehavior::OnlyOrdered,
   matches_at_eod: MatchAtEndBehavior::WillNeverMatchAtEOD,
 });

pub fn compile( &self, flags: Flags, mode: Mode ) -> Result<Database, HyperscanCompileError>

Call Database::compile() with None for the platform.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Display for Expression

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

Formats the value using the given formatter.

impl FromStr for Expression

type Err = HyperscanCompileError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Expression

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Expression

fn cmp(&self, other: &Expression) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Expression

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Expression

fn partial_cmp(&self, other: &Expression) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Expression

impl StructuralEq for Expression

impl StructuralPartialEq for Expression