Struct tagger::ElementStack

pub struct ElementStack<'a, T> { /* fields omitted */ }

Sometimes, having to deal with all the borrowing and closures is difficult. For these cases a traditional ElementStack can be used. This allows you to move around the stack between functions and classes easily. The downside is that you lose compile time assurance that every push matches every pop.

Implementations

impl<'a, T: Write> ElementStack<'a, T>

pub fn check_unwound(&mut self)

pub fn new(writer: T) -> ElementStack<'a, T>

pub fn from_element(writer: Element<T>) -> ElementStack<'a, T>

pub fn elem_stack<F, J>(&mut self, tag: &'a str, func: F) -> Result<J, Error> where
    F: FnOnce(&'x mut AttributeWriter<'y, T>) -> Result<(&'x mut AttributeWriter<'y, T>, J), Error>, 

Write a element that has an ending tag. The user is required to feed the element back into this function thus proving that they called ElementHeaderWriter::write.

pub fn as_element(&mut self) -> &mut Element<T>

Use Deref/DerefMut is possible

pub fn pop(&mut self) -> Result<&mut ElementStack<'a, T>, Error>

Methods from Deref<Target = Element<T>>

pub fn get_writer(&mut self) -> &mut T

pub fn empty_ok(&mut self) -> Result<(&mut Element<T>, ()), Error>

pub fn single_ext<F, J>(
    &mut self,
    tag: &str,
    tags: [&str; 2],
    func: F
) -> Result<J, Error> where
    F: FnOnce(&'x mut AttributeWriter<'y, T>) -> Result<(&'x mut AttributeWriter<'y, T>, J), Error>, 

Write a element that doesnt have an ending tag. i.e. it can only have attributes. Some common tag types are in tag_types.

pub fn single<F, J>(&mut self, tag: &str, func: F) -> Result<J, Error> where
    F: FnOnce(&'x mut AttributeWriter<'y, T>) -> Result<(&'x mut AttributeWriter<'y, T>, J), Error>, 

Shorthand for Element::single_ext with tag_types::NORMAL

pub fn elem_no_attr<F, J>(
    &mut self,
    tag: &str,
    func: F
) -> Result<(&mut Self, J), Error> where
    F: FnOnce(&'x mut Element<T>) -> Result<(&'x mut Element<T>, J), Error>, 

Shorthand for Element::elem with the attribute builder functionality omitted.

pub fn elem<J, F>(&mut self, tag: &str, func: F) -> Result<J, Error> where
    F: FnOnce(ElementHeaderWriter<'_, T>) -> Result<(&mut Element<T>, J), Error>, 

Write a element that has an ending tag. The user is required to feed the element back into this function thus proving that they called ElementHeaderWriter::write.

Trait Implementations

impl<'a, T> Deref for ElementStack<'a, T>

type Target = Element<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T> DerefMut for ElementStack<'a, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.