Struct pulldown_cmark_to_cmark::State

pub struct State<'a> {

    pub newlines_before_start: usize,
    pub list_stack: Vec<Option<u64>>,
    pub padding: Vec<Cow<'a, str>>,
    pub table_alignments: Vec<Alignment>,
    pub table_headers: Vec<String>,
    pub text_for_header: Option<String>,
    pub is_in_code_block: bool,
    pub last_was_text_without_trailing_newline: bool,
    pub link_stack: Vec<LinkCategory<'a>>,
    pub image_stack: Vec<ImageLink<'a>>,
    pub current_heading: Option<Heading<'a>>,
    pub current_shortcut_text: Option<String>,
    pub shortcuts: Vec<(String, String, String)>,
    pub last_event_end_index: usize,
}

The state of the cmark_resume() and cmark_resume_with_options() functions. This does not only allow introspection, but enables the user to halt the serialization at any time, and resume it later.

Fields

newlines_before_start: usize

The amount of newlines to insert after Event::Start(...)

list_stack: Vec<Option<u64>>

The lists and their types for which we have seen a Event::Start(List(...)) tag

padding: Vec<Cow<'a, str>>

The computed padding and prefix to print after each newline. This changes with the level of BlockQuote and List events.

table_alignments: Vec<Alignment>

Keeps the current table alignments, if we are currently serializing a table.

table_headers: Vec<String>

Keeps the current table headers, if we are currently serializing a table.

text_for_header: Option<String>

The last seen text when serializing a header

is_in_code_block: bool

Is set while we are handling text in a code block

last_was_text_without_trailing_newline: bool

True if the last event was text and the text does not have trailing newline. Used to inject additional newlines before code block end fence.

link_stack: Vec<LinkCategory<'a>>

Currently open links

image_stack: Vec<ImageLink<'a>>

Currently open images

current_heading: Option<Heading<'a>>

Keeps track of the last seen heading’s id, classes, and attributes

current_shortcut_text: Option<String>

Keeps track of the last seen shortcut/link

shortcuts: Vec<(String, String, String)>

A list of shortcuts seen so far for later emission

last_event_end_index: usize

Index into the source bytes of the end of the range corresponding to the last event.

It’s used to see if the current event didn’t capture some bytes because of a skipped-over backslash.

Implementations

impl<'a> State<'a>

pub fn finalize<F>(self, formatter: F) -> Result<Self, Error>

where F: Write,

Trait Implementations

impl<'a> Clone for State<'a>

fn clone(&self) -> State<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for State<'a>

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

Formats the value using the given formatter.

impl<'a> Default for State<'a>

fn default() -> State<'a>

Returns the “default value” for a type.

impl<'a> Hash for State<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for State<'a>

fn cmp(&self, other: &State<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<'a> PartialEq for State<'a>

fn eq(&self, other: &State<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for State<'a>

fn partial_cmp(&self, other: &State<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for State<'a>

impl<'a> StructuralPartialEq for State<'a>