Struct glsl_lang::transpiler::glsl::FormattingState

pub struct FormattingState<'s> {
    pub settings: &'s FormattingSettings,
    indentation_level: u32,
    new_line_pending: bool,
    in_function_definition_statement: bool,
    last_flush_line_flushed_line: bool,
    is_first_external_declaration: bool,
}

Formatting state of the GLSL transpiler

Fields

settings: &'s FormattingSettings

Formatting settings

indentation_level: u32

new_line_pending: bool

in_function_definition_statement: bool

last_flush_line_flushed_line: bool

is_first_external_declaration: bool

Implementations

impl<'s> FormattingState<'s>

fn write_indent<F>(&self, f: &mut F) -> Result

where F: Write + ?Sized,

fn write_line<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

pub fn new_line(&mut self, required: bool) -> Result

Append a pending new line to the output

pub fn consume_newline(&mut self)

Consume the pending newlines

pub fn flush_line<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Flush pending newlines to the output, if any

pub fn move_to_empty_line<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Makes sure that the next text to be written to the output will be put at an empty line, or at a line with only indentation characters. Does nothing if the output is already at an empty line

pub fn flush_space<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Flush pending newlines as spaces to the output, if any

pub fn enter_compound_statement_block<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Enter a new compound statement block, and update the indentation level

pub fn enter_external_declaration<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Enters a new external declaration, flushing pending newlines

pub fn exit_external_declaration(&mut self)

Exits the current external declaration

pub fn enter_block<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Enter a new block, and update the indentation level

fn enter_block_inner<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Common logic for entering a new block, and updating the indentation level

pub fn exit_block<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Exit the current block, and update the indentation level

pub fn enter_function_definition_statement(&mut self)

Enter a new function definition statement

pub fn consume_function_definition_statement(&mut self)

Consume the current function definition statement

pub fn enter_collapsed_compound_statement(&mut self) -> Result

Enter a collapsed compound statement

pub fn exit_collapsed_compound_statement(&mut self) -> Result

Exit the current collapsed compound statement

pub fn enter_initializer_list<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Enter a list initializer

pub fn end_initializer_list<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Exit the current list initializer

pub fn enter_case_label<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Enter a case label

pub fn write_else<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a else keyword, part of an if statement

pub fn write_struct_field_separator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a struct field separator

pub fn write_list_separator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a list separator

pub fn write_for_statement_separator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a for statement separator

pub fn write_struct_declaration_terminator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a struct declaration terminator

pub fn write_declaration_terminator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a declaration terminator

pub fn write_binary_op<F>(&self, f: &mut F, op: &str) -> Result

where F: Write + ?Sized,

Write a binary operator

pub fn write_statement_terminator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a statement terminator

pub fn write_function_definition_terminator<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a function definition terminator

pub fn write_statement_opening_parenthesis<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write an opening parenthesis for a statement

pub fn write_statement_closing_parenthesis<F>(&mut self, f: &mut F) -> Result

where F: Write + ?Sized,

Write a closing parenthesis for a statement

Trait Implementations

impl<'s> Clone for FormattingState<'s>

fn clone(&self) -> FormattingState<'s>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'s> Debug for FormattingState<'s>

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

Formats the value using the given formatter.

impl Default for FormattingState<'static>

fn default() -> Self

Returns the “default value” for a type.

impl<'s> From<&'s FormattingSettings> for FormattingState<'s>

fn from(settings: &'s FormattingSettings) -> Self

Converts to this type from the input type.

impl<'s> PartialEq for FormattingState<'s>

fn eq(&self, other: &FormattingState<'s>) -> 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<'s> Copy for FormattingState<'s>

impl<'s> Eq for FormattingState<'s>

impl<'s> StructuralPartialEq for FormattingState<'s>