pub struct Ruler<M, T> { /* private fields */ }
Expand description
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_that::common::ruler::Ruler;
// this example prints "[ hello, world! ]",
// where each token is printed by a 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"));
// an 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 implementEq + Copy + Hash + Debug. Common choices for
Mare
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§
Trait Implementations§
Auto Trait Implementations§
impl<M, T> !Freeze for Ruler<M, T>
impl<M, T> RefUnwindSafe for Ruler<M, T>
impl<M, T> Send for Ruler<M, T>
impl<M, T> Sync for Ruler<M, T>
impl<M, T> Unpin for Ruler<M, T>
impl<M, T> UnwindSafe for Ruler<M, T>where
T: UnwindSafe,
M: UnwindSafe,
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Converts
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
, which can then be
downcast
into Box<dyn ConcreteType>
where ConcreteType
implements Trait
.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Converts
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
, which can then be further
downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Converts
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Converts
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.