Struct Printer 

pub struct Printer {
    out: String,
    space: isize,
    buf: RingBuffer<BufEntry>,
    left_total: isize,
    right_total: isize,
    scan_stack: VecDeque<usize>,
    print_stack: Vec<PrintFrame>,
    indent: usize,
    pending_indentation: usize,
    last_printed: Option<Token>,
    margin: isize,
    indent_config: Option<usize>,
}

Fields

out: String

space: isize

Number of spaces left on line.

buf: RingBuffer<BufEntry>

Ring-buffer of tokens and calculated sizes.

left_total: isize

Running size of stream “…left”.

right_total: isize

Running size of stream “…right”.

scan_stack: VecDeque<usize>

Pseudo-stack, really a ring too. Holds the primary-ring-buffers index of the Begin that started the current block, possibly with the most recent Break after that Begin (if there is any) on top of it. Stuff is flushed off the bottom as it becomes irrelevant due to the primary ring-buffer advancing.

print_stack: Vec<PrintFrame>

Stack of blocks-in-progress being flushed by print.

indent: usize

Level of indentation of current line.

pending_indentation: usize

Buffered indentation to avoid writing trailing whitespace.

last_printed: Option<Token>

The token most recently popped from the left boundary of the ring-buffer for printing.

margin: isize

Target line width.

indent_config: Option<usize>

If Some(tab_width) the printer will use tabs for indentation.

Implementations

impl Printer

pub fn rbox(&mut self, indent: isize, breaks: Breaks)

“raw box”

pub fn ibox(&mut self, indent: isize)

Inconsistent breaking box

pub fn cbox(&mut self, indent: isize)

Consistent breaking box

pub fn visual_align(&mut self)

pub fn break_offset(&mut self, n: usize, off: isize)

pub fn end(&mut self)

pub fn eof(self) -> String

pub fn word(&mut self, w: impl Into<Cow<'static, str>>)

fn spaces(&mut self, n: usize)

pub fn zerobreak(&mut self)

pub fn space(&mut self)

pub fn hardbreak(&mut self)

pub fn last_token_is_neverbreak(&self) -> bool

pub fn last_token_is_break(&self) -> bool

pub fn last_token_is_space(&self) -> bool

pub fn is_beginning_of_line(&self) -> bool

pub fn is_bol_or_only_ind(&self) -> bool

Attempts to identify whether the current position is:

1. the beginning of a line (empty)
2. a line with only indentation (just whitespaces)

NOTE: this is still an educated guess, based on a heuristic.

fn token_has_non_whitespace_content(token: &Token) -> bool

pub(crate) fn hardbreak_tok_offset(offset: isize) -> Token

pub fn hardbreak_if_nonempty(&mut self)

pub fn neverbreak(&mut self)

impl Printer

pub fn word_space(&mut self, w: impl Into<Cow<'static, str>>)

pub fn hardbreak_if_not_bol(&mut self)

Adds a new hardbreak if not at the beginning of the line. If there was a buffered break token, replaces it (ensures hardbreak) keeping the offset.

pub fn space_if_not_bol(&mut self)

pub fn nbsp(&mut self)

pub fn space_or_nbsp(&mut self, breaks: bool)

pub fn word_nbsp(&mut self, w: impl Into<Cow<'static, str>>)

impl Printer

pub fn new(margin: usize, use_tab_with_size: Option<usize>) -> Self

pub(crate) fn space_left(&self) -> usize

Predicts available space on the current or next line based on pending breaks.

This function provides a heuristic for estimating available space by checking if an unconditional hard break is pending in the buffer. The printer’s internal self.space value may not accurately reflect pending formatting decisions.

Returns

• The full margin if an unconditional hard break is pending, signaling that a new line will be created. Callers should apply their own indentation logic as they have more semantic context about the code structure.
• The current space left (self.space) if no hard break is found, which can be trusted when no line breaks are imminent.

Trade-offs

This heuristic may overestimate available space, but provides a reliable signal for hard breaks while keeping the implementation simple.

pub(crate) fn last_token(&self) -> Option<&Token>

pub(crate) fn last_token_still_buffered(&self) -> Option<&Token>

pub(crate) fn replace_last_token_still_buffered(&mut self, token: Token)

Be very careful with this!

pub(crate) fn find_and_replace_last_token_still_buffered<F>( &mut self, new_token: Token, predicate: F, )

where F: FnOnce(&Token) -> bool,

WARNING: Be very careful with this!

Searches backwards through the buffer to find and replace the last token that satisfies a predicate. This is a specialized and sensitive operation.

This function’s traversal logic is specifically designed to handle cases where formatting boxes have been closed (e.g., after a multi-line comment). It will automatically skip over any trailing Token::End tokens to find the substantive token before them.

The search stops as soon as it encounters any token other than End (i.e., a String, Break, or Begin). The provided predicate is then called on that token. If the predicate returns true, the token is replaced.

This function will only ever evaluate the predicate on one token.

fn scan_eof(&mut self)

fn scan_begin(&mut self, token: BeginToken)

fn scan_end(&mut self)

pub(crate) fn scan_break(&mut self, token: BreakToken)

fn scan_string(&mut self, string: Cow<'static, str>)

pub(crate) fn offset(&mut self, offset: isize)

pub(crate) fn ends_with(&self, ch: char) -> bool

fn check_stream(&mut self)

fn advance_left(&mut self)

fn check_stack(&mut self, depth: usize)

fn get_top(&self) -> PrintFrame

fn print_begin(&mut self, token: BeginToken, size: isize)

fn print_end(&mut self)

fn print_break(&mut self, token: BreakToken, size: isize)

fn print_string(&mut self, string: &str)

fn print_indent(&mut self)

Trait Implementations

impl Debug for Printer

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 240 bytes