Struct markdown_it::common::ruler::Ruler

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

Ruler allows you to implement a plugin system with dependency management and ensure that your dependencies are called in the correct order.

You can use it like this:

use markdown_it::common::ruler::Ruler;

// this example prints "[ hello, world! ]",
// where each token is printed by separate closure
let mut chain = Ruler::<&str, fn (&mut String)>::new();

// define rules printing "hello" and "world"
chain.add("hello", |s| s.push_str("hello"));
chain.add("world", |s| s.push_str("world"));

// open bracket should be before "hello", and closing one after "world"
chain.add("open_bracket", |s| s.push_str("[ ")).before("hello");
chain.add("close_bracket", |s| s.push_str(" ]")).after("world");

// between "hello" and "world" we shall have a comma
chain.add("comma", |s| s.push_str(", ")).after("hello").before("world");

// after "world" we should have "!" as a first rule, but ensure "world" exists first
chain.add("bang", |s| s.push_str("!")).require("world").after("world").before_all();

// now we run this chain
let mut result = String::new();
for f in chain.iter() { f(&mut result); }
assert_eq!(result, "[ hello, world! ]");

This data structure contains any number of elements (M, T), where T is any type and M (mark) is its identifier.

• M is used for ordering and dependency checking, it must implement Eq + Copy + Hash + Debug . Common choices for M are u32, &'static str, or a special Symbol type designed for this purpose.

• T is any user-defined type. It’s usually a function or boxed trait.

Implementations

impl<M, T> Ruler<M, T>

pub fn new() -> Self

impl<M: Eq + Hash + Copy + Debug, T: Clone> Ruler<M, T>

pub fn add(&mut self, mark: M, value: T) -> &mut RuleItem<M, T>

Add a new rule identified by mark with payload value.

pub fn remove(&mut self, mark: M)

Remove all rules identified by mark.

pub fn contains(&mut self, mark: M) -> bool

Check if there are any rules identified by mark.

pub fn iter(&self) -> Iter<'_, T>

Ordered iteration through rules.

Trait Implementations

impl<M: Eq + Hash + Copy + Debug, T: Clone> Debug for Ruler<M, T>

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

Formats the value using the given formatter.

impl<M, T> Default for Ruler<M, T>

fn default() -> Self

Returns the “default value” for a type.