struct Transaction<'f, 'a, W> {
fmt: &'f mut Formatter<'a, W>,
buffer: String,
comments: Comments,
}
Expand description
An action which may be committed to a Formatter
Fields§
§fmt: &'f mut Formatter<'a, W>
§buffer: String
§comments: Comments
Implementations§
Source§impl<'f, 'a, W: Write> Transaction<'f, 'a, W>
impl<'f, 'a, W: Write> Transaction<'f, 'a, W>
Sourcefn new(
fmt: &'f mut Formatter<'a, W>,
fun: impl FnMut(&mut Formatter<'a, W>) -> Result<(), FormatterError>,
) -> Result<Self, FormatterError>
fn new( fmt: &'f mut Formatter<'a, W>, fun: impl FnMut(&mut Formatter<'a, W>) -> Result<(), FormatterError>, ) -> Result<Self, FormatterError>
Create a new transaction from a callback
Sourcefn commit(self) -> Result<String, FormatterError>
fn commit(self) -> Result<String, FormatterError>
Commit the transaction to the Formatter
Methods from Deref<Target = Formatter<'a, W>>§
Sourcefn buf(&mut self) -> &mut dyn Write
fn buf(&mut self) -> &mut dyn Write
Get the Write interface of the current temp buffer or the underlying Write
Sourceunsafe fn buf_contents(&self) -> &String
unsafe fn buf_contents(&self) -> &String
Casts the current writer w
as a String
reference. Should only be used for debugging.
Sourceunsafe fn temp_buf_contents(&self) -> &String
unsafe fn temp_buf_contents(&self) -> &String
Casts the current W
writer or the current temp buffer as a String
reference.
Should only be used for debugging.
fn indent(&mut self, delta: usize)
fn dedent(&mut self, delta: usize)
fn start_group(&mut self)
fn end_group(&mut self)
fn create_temp_buf(&self) -> FormatBuffer<String>
fn restrict_to_single_line(&mut self, restricted: bool)
fn current_line_len(&self) -> usize
fn total_indent_len(&self) -> usize
fn is_beginning_of_line(&self) -> bool
fn last_char(&self) -> Option<char>
fn last_indent_group_skipped(&self) -> bool
fn set_last_indent_group_skipped(&mut self, skip: bool)
fn write_raw(&mut self, s: impl AsRef<str>) -> Result
Sourcefn with_temp_buf(
&mut self,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<FormatBuffer<String>, FormatterError>
fn with_temp_buf( &mut self, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<FormatBuffer<String>, FormatterError>
Do the callback within the context of a temp buffer
Sourcefn next_char_needs_space(&self, next_char: char) -> bool
fn next_char_needs_space(&self, next_char: char) -> bool
Does the next written character require whitespace before
Sourcefn will_it_fit(&self, text: impl AsRef<str>) -> bool
fn will_it_fit(&self, text: impl AsRef<str>) -> bool
Is length of the text
with respect to already written line <= config.line_length
Sourcefn write_empty_brackets(&mut self) -> Result<(), FormatterError>
fn write_empty_brackets(&mut self) -> Result<(), FormatterError>
Write empty brackets with respect to config.bracket_spacing
setting:
"{ }"
if true
, "{}"
if false
Sourcefn write_semicolon(&mut self) -> Result<(), FormatterError>
fn write_semicolon(&mut self) -> Result<(), FormatterError>
Write semicolon to the buffer
Sourcefn write_whitespace_separator(
&mut self,
multiline: bool,
) -> Result<(), FormatterError>
fn write_whitespace_separator( &mut self, multiline: bool, ) -> Result<(), FormatterError>
Write whitespace separator to the buffer
"\n"
if multiline
is true
, " "
if false
Sourcefn write_preserved_line(&mut self) -> Result<(), FormatterError>
fn write_preserved_line(&mut self) -> Result<(), FormatterError>
Write new line with preserved last_indent_group_skipped
flag
Sourcefn write_raw_src(&mut self, loc: Loc) -> Result<(), FormatterError>
fn write_raw_src(&mut self, loc: Loc) -> Result<(), FormatterError>
Write unformatted src and comments for given location.
Sourcefn blank_lines(&self, start: usize, end: usize) -> usize
fn blank_lines(&self, start: usize, end: usize) -> usize
Returns number of blank lines in source between two byte indexes
Sourcefn find_next_line(&self, byte_offset: usize) -> Option<usize>
fn find_next_line(&self, byte_offset: usize) -> Option<usize>
Get the byte offset of the next line
Sourcefn find_next_in_src(&self, byte_offset: usize, needle: char) -> Option<usize>
fn find_next_in_src(&self, byte_offset: usize, needle: char) -> Option<usize>
Find the next instance of the character in source excluding comments
Sourcefn find_next_str_in_src(
&self,
byte_offset: usize,
needle: &str,
) -> Option<usize>
fn find_next_str_in_src( &self, byte_offset: usize, needle: &str, ) -> Option<usize>
Find the start of the next instance of a slice in source
Sourcefn extend_loc_until(&self, loc: &mut Loc, needle: char) -> bool
fn extend_loc_until(&self, loc: &mut Loc, needle: char) -> bool
Extends the location to the next instance of a character. Returns true if the loc was extended
Sourcefn should_attempt_block_single_line(
&mut self,
stmt: &mut Statement,
start_from: usize,
) -> bool
fn should_attempt_block_single_line( &mut self, stmt: &mut Statement, start_from: usize, ) -> bool
Return the flag whether the attempt should be made
to write the block on a single line.
If the block style is configured to SingleLineBlockStyle::Preserve,
lookup whether there was a newline introduced in [start_from, end_at]
range
where end_at
is the start of the block.
Sourcefn chunk_at(
&mut self,
byte_offset: usize,
next_byte_offset: Option<usize>,
needs_space: Option<bool>,
content: impl Display,
) -> Chunk
fn chunk_at( &mut self, byte_offset: usize, next_byte_offset: Option<usize>, needs_space: Option<bool>, content: impl Display, ) -> Chunk
Create a chunk given a string and the location information
Sourcefn chunked(
&mut self,
byte_offset: usize,
next_byte_offset: Option<usize>,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<Chunk, FormatterError>
fn chunked( &mut self, byte_offset: usize, next_byte_offset: Option<usize>, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<Chunk, FormatterError>
Create a chunk given a callback
fn chunked_mono( &mut self, byte_offset: usize, next_byte_offset: Option<usize>, fun: &mut dyn FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<Chunk, FormatterError>
Sourcefn visit_to_chunk(
&mut self,
byte_offset: usize,
next_byte_offset: Option<usize>,
visitable: &mut impl Visitable,
) -> Result<Chunk, FormatterError>
fn visit_to_chunk( &mut self, byte_offset: usize, next_byte_offset: Option<usize>, visitable: &mut impl Visitable, ) -> Result<Chunk, FormatterError>
Create a chunk given a Visitable item
Sourcefn items_to_chunks<'b>(
&mut self,
next_byte_offset: Option<usize>,
items: impl Iterator<Item = (Loc, &'b mut (impl Visitable + 'b))> + 'b,
) -> Result<Vec<Chunk>, FormatterError>
fn items_to_chunks<'b>( &mut self, next_byte_offset: Option<usize>, items: impl Iterator<Item = (Loc, &'b mut (impl Visitable + 'b))> + 'b, ) -> Result<Vec<Chunk>, FormatterError>
Transform Visitable items to the list of chunks
Sourcefn items_to_chunks_sorted<'b>(
&mut self,
next_byte_offset: Option<usize>,
items: impl Iterator<Item = &'b mut (impl Visitable + CodeLocation + Ord + 'b)> + 'b,
) -> Result<Vec<Chunk>, FormatterError>
fn items_to_chunks_sorted<'b>( &mut self, next_byte_offset: Option<usize>, items: impl Iterator<Item = &'b mut (impl Visitable + CodeLocation + Ord + 'b)> + 'b, ) -> Result<Vec<Chunk>, FormatterError>
Transform Visitable items to a list of chunks and then sort those chunks.
Sourcefn write_comment(
&mut self,
comment: &CommentWithMetadata,
is_first: bool,
) -> Result<(), FormatterError>
fn write_comment( &mut self, comment: &CommentWithMetadata, is_first: bool, ) -> Result<(), FormatterError>
Write a comment to the buffer formatted. WARNING: This may introduce a newline if the comment is a Line comment or if the comment are wrapped
Sourcefn write_prefix_comment(
&mut self,
comment: &CommentWithMetadata,
is_first: bool,
) -> Result<(), FormatterError>
fn write_prefix_comment( &mut self, comment: &CommentWithMetadata, is_first: bool, ) -> Result<(), FormatterError>
Write a comment with position CommentPosition::Prefix
Sourcefn write_postfix_comment(
&mut self,
comment: &CommentWithMetadata,
) -> Result<(), FormatterError>
fn write_postfix_comment( &mut self, comment: &CommentWithMetadata, ) -> Result<(), FormatterError>
Write a comment with position CommentPosition::Postfix
Sourcefn write_doc_block_line(
&mut self,
comment: &CommentWithMetadata,
line: &str,
) -> Result<(), FormatterError>
fn write_doc_block_line( &mut self, comment: &CommentWithMetadata, line: &str, ) -> Result<(), FormatterError>
Write the line of a doc block comment line
Sourcefn write_comment_line(
&mut self,
comment: &CommentWithMetadata,
line: &str,
) -> Result<bool, FormatterError>
fn write_comment_line( &mut self, comment: &CommentWithMetadata, line: &str, ) -> Result<bool, FormatterError>
Write a comment line that might potentially overflow the maximum line length and, if configured, will be wrapped to the next line.
Sourcefn write_raw_comment(
&mut self,
comment: &CommentWithMetadata,
) -> Result<(), FormatterError>
fn write_raw_comment( &mut self, comment: &CommentWithMetadata, ) -> Result<(), FormatterError>
Write a raw comment. This is like write_comment
but won’t do any
formatting or worry about whitespace behind the comment.
Sourcefn write_comments<'b>(
&mut self,
comments: impl IntoIterator<Item = &'b CommentWithMetadata>,
) -> Result<(), FormatterError>
fn write_comments<'b>( &mut self, comments: impl IntoIterator<Item = &'b CommentWithMetadata>, ) -> Result<(), FormatterError>
Write multiple comments
Sourcefn write_postfix_comments_before(
&mut self,
byte_end: usize,
) -> Result<(), FormatterError>
fn write_postfix_comments_before( &mut self, byte_end: usize, ) -> Result<(), FormatterError>
Write a postfix comments before a given location
Sourcefn write_prefix_comments_before(
&mut self,
byte_end: usize,
) -> Result<(), FormatterError>
fn write_prefix_comments_before( &mut self, byte_end: usize, ) -> Result<(), FormatterError>
Write all prefix comments before a given location
Sourcefn will_chunk_fit(
&mut self,
format_string: &str,
chunk: &Chunk,
) -> Result<bool, FormatterError>
fn will_chunk_fit( &mut self, format_string: &str, chunk: &Chunk, ) -> Result<bool, FormatterError>
Check if a chunk will fit on the current line
Sourcefn are_chunks_separated_multiline<'b>(
&mut self,
format_string: &str,
items: impl IntoIterator<Item = &'b Chunk>,
separator: &str,
) -> Result<bool, FormatterError>
fn are_chunks_separated_multiline<'b>( &mut self, format_string: &str, items: impl IntoIterator<Item = &'b Chunk>, separator: &str, ) -> Result<bool, FormatterError>
Check if a separated list of chunks will fit on the current line
Sourcefn write_chunk(&mut self, chunk: &Chunk) -> Result<(), FormatterError>
fn write_chunk(&mut self, chunk: &Chunk) -> Result<(), FormatterError>
Write the chunk and any surrounding comments into the buffer
This will automatically add whitespace before the chunk given the rule set in
next_char_needs_space
. If the chunk does not fit on the current line it will be put on
to the next line
Sourcefn write_chunks_separated<'b>(
&mut self,
chunks: impl IntoIterator<Item = &'b Chunk>,
separator: &str,
multiline: bool,
) -> Result<(), FormatterError>
fn write_chunks_separated<'b>( &mut self, chunks: impl IntoIterator<Item = &'b Chunk>, separator: &str, multiline: bool, ) -> Result<(), FormatterError>
Write chunks separated by a separator. If multiline
, each chunk will be written to a
separate line
Sourcefn indented(
&mut self,
delta: usize,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<(), FormatterError>
fn indented( &mut self, delta: usize, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<(), FormatterError>
Apply the callback indented by the indent size
Sourcefn indented_if(
&mut self,
condition: bool,
delta: usize,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<(), FormatterError>
fn indented_if( &mut self, condition: bool, delta: usize, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<(), FormatterError>
Apply the callback indented by the indent size if the condition is true
Sourcefn grouped(
&mut self,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<bool, FormatterError>
fn grouped( &mut self, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<bool, FormatterError>
Apply the callback into an indent group. The first line of the indent group is not indented but lines thereafter are
Sourcefn with_function_context(
&mut self,
context: FunctionDefinition,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<(), FormatterError>
fn with_function_context( &mut self, context: FunctionDefinition, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<(), FormatterError>
Add a function context around a procedure and revert the context at the end of the procedure regardless of the response
Sourcefn with_contract_context(
&mut self,
context: ContractDefinition,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<(), FormatterError>
fn with_contract_context( &mut self, context: ContractDefinition, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<(), FormatterError>
Add a contract context around a procedure and revert the context at the end of the procedure regardless of the response
Sourcefn transact<'b>(
&'b mut self,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<Transaction<'b, 'a, W>, FormatterError>
fn transact<'b>( &'b mut self, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<Transaction<'b, 'a, W>, FormatterError>
Create a transaction. The result of the transaction is not applied to the buffer unless
Transacton::commit
is called
Sourcefn simulate_to_string(
&mut self,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<String, FormatterError>
fn simulate_to_string( &mut self, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<String, FormatterError>
Do the callback and return the result on the buffer as a string
Sourcefn chunk_to_string(&mut self, chunk: &Chunk) -> Result<String, FormatterError>
fn chunk_to_string(&mut self, chunk: &Chunk) -> Result<String, FormatterError>
Turn a chunk and its surrounding comments into a string
Sourcefn simulate_to_single_line(
&mut self,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<Option<String>, FormatterError>
fn simulate_to_single_line( &mut self, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<Option<String>, FormatterError>
Try to create a string based on a callback. If the string does not fit on a single line
this will return None
Sourcefn try_on_single_line(
&mut self,
fun: impl FnMut(&mut Self) -> Result<(), FormatterError>,
) -> Result<bool, FormatterError>
fn try_on_single_line( &mut self, fun: impl FnMut(&mut Self) -> Result<(), FormatterError>, ) -> Result<bool, FormatterError>
Try to apply a callback to a single line. If the callback cannot be applied to a single
line the callback will not be applied to the buffer and false
will be returned. Otherwise
true
will be returned
Sourcefn surrounded(
&mut self,
first: SurroundingChunk,
last: SurroundingChunk,
fun: impl FnMut(&mut Self, bool) -> Result<(), FormatterError>,
) -> Result<(), FormatterError>
fn surrounded( &mut self, first: SurroundingChunk, last: SurroundingChunk, fun: impl FnMut(&mut Self, bool) -> Result<(), FormatterError>, ) -> Result<(), FormatterError>
Surrounds a callback with parentheses. The callback will try to be applied to a single
line. If the callback cannot be applied to a single line the callback will applied to the
nextline indented. The callback receives a multiline
hint as the second argument which
receives true
in the latter case
Sourcefn write_lined_visitable<'b, I, V, F>(
&mut self,
loc: Loc,
items: I,
needs_space_fn: F,
) -> Result<(), FormatterError>
fn write_lined_visitable<'b, I, V, F>( &mut self, loc: Loc, items: I, needs_space_fn: F, ) -> Result<(), FormatterError>
Write each Visitable item on a separate line. The function will check if there are any
blank lines between each visitable statement and will apply a single blank line if there
exists any. The needs_space
callback can force a newline and is given the last_item if
any and the next item as arguments
Sourcefn visit_assignment(
&mut self,
expr: &mut Expression,
) -> Result<(), FormatterError>
fn visit_assignment( &mut self, expr: &mut Expression, ) -> Result<(), FormatterError>
Visit the right side of an assignment. The function will try to write the assignment on a single line or indented on the next line. If it can’t do this it resorts to letting the expression decide how to split itself on multiple lines
Sourcefn visit_list<T>(
&mut self,
prefix: &str,
items: &mut [T],
start_offset: Option<usize>,
end_offset: Option<usize>,
paren_required: bool,
) -> Result<(), FormatterError>where
T: Visitable + CodeLocation,
fn visit_list<T>(
&mut self,
prefix: &str,
items: &mut [T],
start_offset: Option<usize>,
end_offset: Option<usize>,
paren_required: bool,
) -> Result<(), FormatterError>where
T: Visitable + CodeLocation,
Visit the list of comma separated items. If the prefix is not empty, then the function will write the whitespace before the parentheses (if they are required).
Sourcefn visit_block<T>(
&mut self,
loc: Loc,
statements: &mut [T],
attempt_single_line: bool,
attempt_omit_braces: bool,
) -> Result<bool, FormatterError>where
T: Visitable + CodeLocation,
fn visit_block<T>(
&mut self,
loc: Loc,
statements: &mut [T],
attempt_single_line: bool,
attempt_omit_braces: bool,
) -> Result<bool, FormatterError>where
T: Visitable + CodeLocation,
Visit the block item. Attempt to write it on the single
line if requested. Surround by curly braces and indent
each line otherwise. Returns true
if the block fit
on a single line
Sourcefn visit_stmt_as_block(
&mut self,
stmt: &mut Statement,
attempt_single_line: bool,
) -> Result<bool, FormatterError>
fn visit_stmt_as_block( &mut self, stmt: &mut Statement, attempt_single_line: bool, ) -> Result<bool, FormatterError>
Visit statement as Statement::Block
.
Sourcefn visit_member_access<'b, T, M>(
&mut self,
expr: &'b mut Box<T>,
ident: &mut Identifier,
matcher: M,
) -> Result<(), FormatterError>where
T: CodeLocation + Visitable,
M: FnMut(&mut Self, &'b mut Box<T>) -> Result<Option<(&'b mut Box<T>, &'b mut Identifier)>, FormatterError>,
fn visit_member_access<'b, T, M>(
&mut self,
expr: &'b mut Box<T>,
ident: &mut Identifier,
matcher: M,
) -> Result<(), FormatterError>where
T: CodeLocation + Visitable,
M: FnMut(&mut Self, &'b mut Box<T>) -> Result<Option<(&'b mut Box<T>, &'b mut Identifier)>, FormatterError>,
Visit the generic member access expression and attempt flatten it by checking if the inner expression matches a given member access variant.
Sourcefn visit_yul_string_with_ident(
&mut self,
loc: Loc,
val: &str,
ident: &mut Option<Identifier>,
) -> Result<(), FormatterError>
fn visit_yul_string_with_ident( &mut self, loc: Loc, val: &str, ident: &mut Option<Identifier>, ) -> Result<(), FormatterError>
Visit the yul string with an optional identifier.
If the identifier is present, write the value in the format <val>:<ident>
.
Ref: https://docs.soliditylang.org/en/v0.8.15/yul.html#variable-declarations
Sourcefn quote_str(&self, loc: Loc, prefix: Option<&str>, string: &str) -> String
fn quote_str(&self, loc: Loc, prefix: Option<&str>, string: &str) -> String
Format a quoted string as prefix"string"
where the quote character is handled
by the configuration quote_style
Sourcefn write_quoted_str(
&mut self,
loc: Loc,
prefix: Option<&str>,
string: &str,
) -> Result<(), FormatterError>
fn write_quoted_str( &mut self, loc: Loc, prefix: Option<&str>, string: &str, ) -> Result<(), FormatterError>
Write a quoted string. See Formatter::quote_str
for more information
Sourcefn write_num_literal(
&mut self,
loc: Loc,
value: &str,
fractional: Option<&str>,
exponent: &str,
unit: &mut Option<Identifier>,
) -> Result<(), FormatterError>
fn write_num_literal( &mut self, loc: Loc, value: &str, fractional: Option<&str>, exponent: &str, unit: &mut Option<Identifier>, ) -> Result<(), FormatterError>
Write and format numbers. This will fix underscores as well as remove unnecessary 0’s and exponents
Sourcefn write_hex_literal(&mut self, lit: &HexLiteral) -> Result<(), FormatterError>
fn write_hex_literal(&mut self, lit: &HexLiteral) -> Result<(), FormatterError>
Write and hex literals according to the configuration.
Sourcefn write_unit(
&mut self,
unit: &mut Option<Identifier>,
) -> Result<(), FormatterError>
fn write_unit( &mut self, unit: &mut Option<Identifier>, ) -> Result<(), FormatterError>
Write built-in unit.
Sourcefn write_function_header(
&mut self,
func: &mut FunctionDefinition,
body_loc: Option<Loc>,
header_multiline: bool,
) -> Result<bool, FormatterError>
fn write_function_header( &mut self, func: &mut FunctionDefinition, body_loc: Option<Loc>, header_multiline: bool, ) -> Result<bool, FormatterError>
Write the function header
Sourcefn write_if_stmt(
&mut self,
loc: Loc,
cond: &mut Expression,
if_branch: &mut Box<Statement>,
else_branch: &mut Option<Box<Statement>>,
) -> Result<(), FormatterError>
fn write_if_stmt( &mut self, loc: Loc, cond: &mut Expression, if_branch: &mut Box<Statement>, else_branch: &mut Option<Box<Statement>>, ) -> Result<(), FormatterError>
Write potentially nested if statements
Sourcefn sort_imports(&self, source_unit: &mut SourceUnit)
fn sort_imports(&self, source_unit: &mut SourceUnit)
Sorts grouped import statement alphabetically.
Trait Implementations§
Source§impl<'a, W> Deref for Transaction<'_, 'a, W>
impl<'a, W> Deref for Transaction<'_, 'a, W>
Auto Trait Implementations§
impl<'f, 'a, W> Freeze for Transaction<'f, 'a, W>
impl<'f, 'a, W> RefUnwindSafe for Transaction<'f, 'a, W>where
W: RefUnwindSafe,
impl<'f, 'a, W> Send for Transaction<'f, 'a, W>where
W: Send,
impl<'f, 'a, W> Sync for Transaction<'f, 'a, W>where
W: Sync,
impl<'f, 'a, W> Unpin for Transaction<'f, 'a, W>
impl<'f, 'a, W> !UnwindSafe for Transaction<'f, 'a, W>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere
T: ?Sized,
§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the foreground set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red()
and
green()
, which have the same functionality but are
pithier.
§Example
Set foreground color to white using fg()
:
use yansi::{Paint, Color};
painted.fg(Color::White);
Set foreground color to white using white()
.
use yansi::Paint;
painted.white();
§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the background set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red()
and
on_green()
, which have the same functionality but
are pithier.
§Example
Set background color to red using fg()
:
use yansi::{Paint, Color};
painted.bg(Color::Red);
Set background color to red using on_red()
.
use yansi::Paint;
painted.on_red();
§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling [Attribute
] value
.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold()
and
underline()
, which have the same functionality
but are pithier.
§Example
Make text bold using attr()
:
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);
Make text bold using using bold()
.
use yansi::Paint;
painted.bold();
§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi
[Quirk
] value
.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask()
and
wrap()
, which have the same functionality but are
pithier.
§Example
Enable wrapping using .quirk()
:
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);
Enable wrapping using wrap()
.
use yansi::Paint;
painted.wrap();
§fn clear(&self) -> Painted<&T>
👎Deprecated since 1.0.1: renamed to resetting()
due to conflicts with Vec::clear()
.
The clear()
method will be removed in a future release.
fn clear(&self) -> Painted<&T>
resetting()
due to conflicts with Vec::clear()
.
The clear()
method will be removed in a future release.§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the [Condition
] value
applies. Replaces any previous condition.
See the crate level docs for more details.
§Example
Enable styling painted
only when both stdout
and stderr
are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.§impl<T> TryConv for T
impl<T> TryConv for T
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
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: 96 bytes