Struct Block

pub struct Block {
    pub connect: bool,
    pub start: String,
    pub end: String,
    /* private fields */
}

A block of code with a starting line, ending line, and an indented body

Fields

connect: bool

If this block should be connected to the end of a previous block (for example, else {)

start: String

The start of the block (for example, if (x) {)

end: String

The end of the block (for example, })

Implementations

impl Block

pub fn empty<TStart, TEnd>(start: TStart, end: TEnd) -> Self

where TStart: ToString, TEnd: ToString,

Create a new block with empty body

pub fn new<TStart, TBody, TEnd>(start: TStart, body: TBody, end: TEnd) -> Self

where TStart: ToString, TEnd: ToString, TBody: IntoIterator, TBody::Item: Into<Code>,

Create a new code block

pub fn connected(self) -> Self

Set this block to start on the same line as the end of the previous block

pub fn inline_when(self, condition: fn(&Block) -> bool) -> Self

Set a condition for displaying the block as one line

pub fn inlined(self) -> Self

Set the inline condition to be always true

pub fn never_inlined(self) -> Self

Set the inline condition to be always false

pub fn body(&self) -> &[Code]

Get the body of the block

pub fn should_inline(&self) -> bool

Should the block be displayed in one line

pub fn should_inline_intrinsic(&self) -> bool

Should intrinsicly inline the block

This is used for blocks that only contain one line of code

Trait Implementations

impl Clone for Block

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl Display for Block

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

Formats the value using the given formatter.

impl FormatCode for Block

fn size_hint(&self) -> usize

Upperbound for the line count of the code for pre-allocating. Return 0 to skip

fn format_into_vec_with( &self, format: &Format, out: &mut Vec<String>, connect: bool, indent: &str, )

Emit self with the format in the given output context

fn format(&self) -> String

Emit self with the default format as a string

fn format_with(&self, format: &Format) -> String

Emit self with the format as a string

fn format_vec_with(&self, format: &Format) -> Vec<String>

Emit self with the format as a vector of lines

impl From<Block> for Code

fn from(x: Block) -> Self

Converts to this type from the input type.

impl PartialEq for Block

fn eq(&self, other: &Self) -> 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.