Struct StyleStack 

pub struct StyleStack { /* private fields */ }

Stack of open inline-style spans with deferred starts and overlap normalization.

Construct with StyleStack::default. The typical reader loop is:

1. On encountering an open-style marker, call StyleStack::open and enqueue the returned events.
2. Before emitting any Event::Text, call StyleStack::note_text and enqueue the returned events (deferred StartTextStyle events are released here).
3. On encountering a close-style marker, call StyleStack::close.
4. At a block boundary, call StyleStack::close_all to auto-close any spans still open.

All four methods return the events the reader should emit, in order, for the current step. The stack itself never emits directly.

Implementations

impl StyleStack

pub fn open(&mut self, kind: TextStyleKind) -> Vec<Event>

Opens an inline style if it is not already active and depth allows it.

The corresponding Event::StartTextStyle is deferred — it is not returned here. It is released by the next StyleStack::note_text call, so an empty styled span (open immediately followed by close with no intervening text) emits no events. This implements Rule 13.

Opens are idempotent on kind: if a frame with an equal kind is already on the stack, this call is a no-op and returns an empty vector. Colour-bearing variants compare by colour, so opening Mark(red) while Mark(blue) is open does push a new frame.

Returns an empty vector in all cases; the signature returns Vec<Event> to match StyleStack::close and StyleStack::note_text for caller uniformity.

pub fn close(&mut self, kind: &TextStyleKind) -> Vec<Event>

Closes an inline style, normalizing overlaps via close-and-reopen.

If kind is not currently open, the call is a no-op and returns an empty vector. When the matching frame is below other open frames in the stack (an overlap such as <b><i>x</b></i>), the frames above it are closed in LIFO order, the target frame is closed, and the previously-above frames are re-opened with their starts deferred again. This is the close-and-reopen pattern that satisfies Rule 9.

Returns the Event::EndTextStyle events that the caller should emit, in order. A frame whose text_emitted flag is false contributes no event — its deferred start was never released, so no matching end is needed (Rule 13).

pub fn note_text(&mut self) -> Vec<Event>

Marks every open frame as having emitted text and releases all deferred Event::StartTextStyle events.

Callers invoke this immediately before emitting an Event::Text, Event::LineBreak, or any other event that constitutes “content under the currently open styles”. The returned events must be enqueued in order, before the content event.

pub fn close_all(&mut self) -> Vec<Event>

Closes every active style from innermost to outermost, suppressing frames whose deferred start was never released.

Used at block boundaries (paragraph end, heading end, run end in OOXML, etc.) to satisfy Rule 10. After this call the stack is empty.

pub fn is_empty(&self) -> bool

Returns true when no open frames and no deferred starts remain.

Trait Implementations

impl Clone for StyleStack

fn clone(&self) -> StyleStack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StyleStack

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

Formats the value using the given formatter.

impl Default for StyleStack

fn default() -> StyleStack

Returns the “default value” for a type.