Struct Templates 

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

Structure holding string templates to replace in rules. Templating mechanism allow to define once complex regex and use them at multiple places in rules, making rule maintenance easier.

Example

use gene::Compiler;

let mut c = Compiler::new();
         
/// loading template from string
c.load_templates_from_str(
    r#"
some_template: hello world
"#,
)
.unwrap();

c.load_rules_from_str(
    r#"
name: test
matches:
    $m: .data.path == '{{some_template}}'
"#,
).unwrap();

/// we verify our template has been replaced
assert_eq!(
    c.rules()
        .unwrap()
        .first()
        .unwrap()
        .matches
        .as_ref()
        .unwrap()
        .get("$m")
        .unwrap(),
    &String::from(".data.path == 'hello world'")
);

Implementations

impl Templates

pub fn new() -> Self

pub fn insert(&mut self, name: String, template: String) -> Result<(), Error>

Inserts a new string template. Under the matches section of a Rule any occurrence of {{name}} (name being the template name) will be replaced by the template.

pub fn extend(&mut self, o: &Self) -> Result<(), Error>

Extends templates from another

pub fn replace(&self, r: &mut Rule)

Replaces templates in the given Rule

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl Clone for Templates

fn clone(&self) -> Templates

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Templates

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

Formats the value using the given formatter.

impl Default for Templates

fn default() -> Templates

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Templates

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<HashMap<String, String>> for Templates

fn from(value: HashMap<String, String>) -> Self

Converts to this type from the input type.