Struct automaat_processor_string_regex::StringRegex

pub struct StringRegex {
    pub input: String,
    pub regex: String,
    pub mismatch_error: Option<String>,
    pub replace: Option<String>,
}

The processor configuration.

Fields

input: String

The string that will be matched against the provided regex, and optionally replaced by the replace pattern.

regex: String

The regular expression used to match the input. See the regex crate syntax documentation for more details.

mismatch_error: Option<String>

If the regex pattern does not match the input value, an error is returned. By default, a generic mismatch error is returned.

You can set this value to have it be returned as the error instead.

replace: Option<String>

Optionally use the regex pattern and the input to construct a replacement string to return as this processors output.

You can use variables such as $1 and $2 to match against the patterns in the regex.

Trait Implementations

impl Eq for StringRegex

impl PartialEq<StringRegex> for StringRegex

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

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

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

This method tests for !=.

impl Clone for StringRegex

fn clone(&self) -> StringRegex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StringRegex

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

Formats the value using the given formatter.

impl<'a> Processor<'a> for StringRegex

const NAME: &'static str

The human-formatted name of the processor, used to visually identify this processor amongst others.

type Error = Error

If a processor fails its intended purpose, the returned error is turned into a string, and shown in the automaat-web-client application.

type Output = String

The processor can return any (successful) output it wants, as long as that type implements the [std::fmt::Display] trait.

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

Validate that the provided regex pattern is valid.

Errors

If the regex syntax is invalid, the Error::Syntax error variant is returned.

If the regex pattern is too big (highly unlikely), the Error::CompiledTooBig error variant is returned.

Both variants wrap the original Regex crate errors.

fn run(&self, _context: &Context) -> Result<Option<Self::Output>, Self::Error>

Do a regex match (and replace), based on the processor configuration.

Output

If replace is set to None, the output of the processor will be Ok(None) if no error occurred.

If replace is set to Some, then Some is returned, matching the final replaced output value in Processor::Output.

Errors

If the regex pattern does not match the input input, the Error::Match error variant is returned. If mismatch_error is set, the error will contain the provided message. If not, a default message is provided.

If the regex pattern is invalid, the same errors are returned as validate.

impl<'de> Deserialize<'de> for StringRegex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for StringRegex

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.