Struct RuleItem

pub struct RuleItem<M, T> { /* private fields */ }

Result of Ruler::add, allows customizing the position of each rule.

Implementations

impl<M: Copy, T> RuleItem<M, T>

pub fn before(&mut self, mark: M) -> &mut Self

Make sure this rule will be inserted before any rule defined by mark (if such a rule exists).

use markdown_that::common::ruler::Ruler;
let mut chain = Ruler::<&str, fn (&mut String)>::new();

chain.add("a", |s| s.push_str("bar"));
chain.add("b", |s| s.push_str("foo")).before("a");

let mut result = String::new();
for f in chain.iter() { f(&mut result); }
assert_eq!(result, "foobar");

pub fn after(&mut self, mark: M) -> &mut Self

Make sure this rule will be inserted after any rule defined by mark (if such a rule exists). Similar to RuleItem::before.

pub fn before_all(&mut self) -> &mut Self

This rule will be inserted as early as possible, while still taking into account dependencies, i.e. .after(X).before_all() causes this to be first rule after X.

use markdown_that::common::ruler::Ruler;
let mut chain = Ruler::<&str, fn (&mut String)>::new();

chain.add("a", |s| s.push_str("A"));
chain.add("c", |s| s.push_str("C")).after("a");
chain.add("b", |s| s.push_str("B")).after("a").before_all();

let mut result = String::new();
for f in chain.iter() { f(&mut result); }
// without before_all order will be ACB
assert_eq!(result, "ABC");

pub fn after_all(&mut self) -> &mut Self

This rule will be inserted as late as possible, while still taking into account dependencies, i.e. .before(X).after_all() causes this to be the last rule before X. Similar to RuleItem::before_all.

pub fn alias(&mut self, mark: M) -> &mut Self

Add another auxiliary identifier to this rule. It can be used to group together multiple rules with similar functionality.

use markdown_that::common::ruler::Ruler;
let mut chain = Ruler::<&str, fn (&mut String)>::new();

chain.add("b", |s| s.push_str("B")).alias("BorC");
chain.add("c", |s| s.push_str("C")).alias("BorC");
chain.add("a", |s| s.push_str("A")).before("BorC");

let mut result = String::new();
for f in chain.iter() { f(&mut result); }
assert_eq!(result, "ABC");

pub fn require(&mut self, mark: M) -> &mut Self

Require another rule identified by mark, panic if not found.

Trait Implementations

impl<M, T> Debug for RuleItem<M, T>

where Vec<M>: Debug, RuleItemPriority: Debug, Vec<RuleItemConstraint<M>>: Debug,

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

Formats the value using the given formatter.