Struct State 

#[non_exhaustive]
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 code_block: Option<CodeBlockKind>,
    pub last_was_text_without_trailing_newline: bool,
    pub last_was_paragraph_start: bool,
    pub next_is_link_like: bool,
    pub link_stack: Vec<LinkCategory<'a>>,
    pub image_stack: Vec<ImageLink<'a>>,
    pub current_heading: Option<Heading<'a>>,
    pub in_table_cell: bool,
    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 (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

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

code_block: Option<CodeBlockKind>

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.

last_was_paragraph_start: bool

True if the last event was a paragraph start. Used to escape spaces at start of line (prevent spurrious indented code).

next_is_link_like: bool

True if the next event is a link, image, or footnote.

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

in_table_cell: bool

True whenever between Start(TableCell) and End(TableCell)

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 State<'_>

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

where F: Write,

pub fn is_in_code_block(&self) -> bool

Trait Implementations

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

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

Returns a duplicate 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,

Restrict a value to a certain interval.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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>