Skip to main content

AnchorIndex

Struct AnchorIndex 

Source
struct AnchorIndex<'a> {
    bytecode: &'a [u8],
    source_map: &'a SourceMap,
    pcs: Vec<u32>,
    ic_pc_map: &'a IcPcMap,
    entries: Vec<(i32, u32, usize)>,
    branches: Vec<(usize, usize, &'a [u8])>,
    reverting_runs: Vec<Range<usize>>,
    fallen_into: Vec<(usize, usize)>,
    jumps: Vec<(u32, usize)>,
    address_pushes: Vec<(u32, usize)>,
    falls_through: Vec<bool>,
}
Expand description

Source map and branch lookups precomputed once per bytecode.

Fields§

§bytecode: &'a [u8]§source_map: &'a SourceMap§pcs: Vec<u32>

The program counter of every instruction, by instruction counter.

§ic_pc_map: &'a IcPcMap§entries: Vec<(i32, u32, usize)>

(source id, offset, instruction), sorted for source range lookups.

§branches: Vec<(usize, usize, &'a [u8])>

(ic, next pc, push immediate) for every push that feeds a JUMPI.

§reverting_runs: Vec<Range<usize>>

Straight-line instruction ranges ending in REVERT or INVALID, ordered by start.

§fallen_into: Vec<(usize, usize)>

(JUMPDEST, start of its straight-line run) for every JUMPDEST that the previous instruction falls through to, ordered. A run starts after a JUMP, STOP, RETURN, REVERT, INVALID, SELFDESTRUCT, or a JUMPI that can skip to something other than a failure stub or a block that jumps to one. A JUMP that no source element maps does not end a run.

§jumps: Vec<(u32, usize)>

(target pc, push instruction) for every push that feeds a JUMP or JUMPI, sorted.

§address_pushes: Vec<(u32, usize)>

(target pc, push instruction) for every push of a JUMPDEST address, sorted. Unlike jumps, this includes return addresses that code pushes before jumping to a helper.

§falls_through: Vec<bool>

Whether execution can fall through from the previous instruction into each instruction.

Implementations§

Source§

impl<'a> AnchorIndex<'a>

Source

fn new( bytecode: &'a [u8], source_map: &'a SourceMap, ic_pc_map: &'a IcPcMap, ) -> Self

Source

fn instructions_starting_in( &self, loc: &SourceLocation, ) -> impl Iterator<Item = usize> + Clone

Returns the instructions whose source elements start in the byte range of loc.

Source

fn simple(&self, item_id: u32, loc: &SourceLocation) -> Result<ItemAnchor>

Finds the entry opcode of the source range, preferring code outside a failure stub.

The entry is the lowest instruction in the range that is not provably reached only from inside the range. A compiler can lay out blocks that belong to the range before its entry, such as the cleanup of a failed condition, and only code inside the range reaches those. Dynamic jumps are not tracked, so an instruction with no known way in, such as the entry of an internal function, counts as an entry.

Source

fn taken_fails( &self, anchors: &(ItemAnchor, ItemAnchor), loc: &SourceLocation, ) -> bool

Returns whether the taken side of a require branch is its failing side.

A side that starts inside the require span is the failing side, because the failure code carries the span while the passing side continues with the next statement. If neither side starts inside it, the side that reverts without another conditional branch is. If both do, the source map cannot tell them apart, and the revert check cannot follow the failure code’s dynamic returns, so the positional default stays.

Source

fn taken_starts_in( &self, (fallthrough, taken): &(ItemAnchor, ItemAnchor), loc: &SourceLocation, ) -> Option<bool>

Returns whether the taken side starts inside loc and the fallthrough does not, or None when neither does. A fallthrough that starts inside loc wins, so the positional default stays when both do.

Source

fn jump_is_body( &self, (fallthrough, _): &(ItemAnchor, ItemAnchor), loc: &SourceLocation, ) -> bool

Returns whether the jump’s own target push is mapped to loc, as when a body that is only a break, continue, or leave becomes the conditional jump itself.

Source

fn starts_in(&self, pc: u32, loc: &SourceLocation) -> bool

Returns whether the first instruction at pc after any JUMPDESTs is mapped inside loc.

Source

fn maps_inside(&self, ic: usize, loc: &SourceLocation) -> bool

Returns whether the instruction ic is mapped inside loc.

Source

fn fails(&self, pc: u32) -> bool

Returns whether the code at pc reverts without another conditional branch or other halt.

Follows static PUSH target; JUMP hops, which compilers use to share revert blocks.

Source

fn true_arm_falls_through( &self, (fallthrough, taken): &(ItemAnchor, ItemAnchor), arms: &TernaryArms, ) -> bool

Returns whether the true arm of a ternary is the fallthrough of its jump.

A successor with code mapped inside one arm’s span is that arm, because the arms carry their own spans while the join point carries the enclosing expression’s. An arm without code, such as a literal already on the stack, has no successor of its own, so the other arm decides. If neither arm has code, or the successors give conflicting answers, the positional default stays: the true arm is the jump target.

Source

fn block_maps_inside(&self, pc: u32, loc: &SourceLocation) -> bool

Returns whether an instruction of the block at pc is mapped inside loc. The block runs to the first jump or halt, so it covers the entry code of an arm, which can start with instructions mapped to the enclosing expression. An arm that falls into the join point also scans the code after it, which is mapped outside both arms.

Source

fn function(&self, item_id: u32, loc: &SourceLocation) -> Result<ItemAnchor>

Finds the entry of a function.

Compilers map the entry JUMPDEST to exactly the function’s span, so it is preferred over the lowest instruction in the span, which can belong to a body block laid out before the entry. The entry is the exact-span instruction that code outside the function jumps to, which excludes the function’s exit label and inlined code. A public function can have two such instructions, its ABI wrapper and its body. The wrapper falls through into the body, which internal calls jump to, so the body runs on both paths and is preferred. Falls back to Self::simple when there is none, as for inlined constructors and fallbacks, and for functions that only their own modifier wrapper jumps to, such as with solc via-IR and the optimizer.

Source

fn falls_through_into(&self, from: usize, to: usize) -> bool

Returns whether execution can fall through from from into the JUMPDEST to.

Source

fn is_entered_only_from_inside( &self, instruction: usize, loc: &SourceLocation, ) -> bool

Returns whether every known way into instruction comes from an instruction mapped inside loc, and there is at least one. The known ways in are falling through and a push of its address, which is a static jump or a return address. A push takes the source element given by Self::push_element. Unmapped instructions, such as the JUMPDEST that a compiler puts before a loop body, belong to the block they lead, so the ways into that block count.

Source

fn is_jumped_to_from_outside( &self, instruction: usize, loc: &SourceLocation, ) -> bool

Returns whether a static jump mapped outside loc targets instruction.

Source

fn push_element(&self, push: usize) -> Option<&SourceElement>

Returns the source element that places the push push. An unmapped push, such as the jump out of an if arm, belongs to the code it sits in, so it takes the element of the nearest mapped instruction that falls through into it. A push with no such instruction has no place and gives no evidence.

Source

fn fallthrough_entries( &self, (fallthrough, _): &(ItemAnchor, ItemAnchor), ) -> Result<Vec<(u32, bool)>>

Returns the jumps that enter the fallthrough of a branch from elsewhere, as (pc, conditional), such as the back edge of a loop whose head the branch falls into, or a continue that jumps to the code after the if. Their executions are not the fallthrough’s, but its hits count them. Fails when the entries cannot be told apart: the branch’s own jump targets the fallthrough, or a conditional jump’s own fallthrough is a JUMPDEST that others can enter. The branch then keeps its anchors without a discount.

Source

fn branch( &self, item_id: u32, loc: &SourceLocation, exact: bool, nested: Option<&SourceLocation>, ) -> Result<(ItemAnchor, ItemAnchor)>

Finds the fallthrough and taken anchors of a branch.

exact matches only the jump mapped to exactly loc, so ternaries skip nested decisions. Otherwise the last matching jump wins, preferring one mapped outside nested, the code of the branch’s body, which holds the jumps of nested branches and loops.

Source

fn if_edge( &self, item_id: u32, path_id: u32, loc: &SourceLocation, arms: &IfArms, ) -> Option<(ItemAnchor, Option<u32>, Vec<(u32, bool)>)>

Finds the anchor that counts the entries into an arm of an if that has no code of its own, from the edge of the conditional jump that enters it, as gcov counts arcs.

The if’s jump is the only one mapped inside the statement but outside its arms, which hold the jumps of nested branches. Fails when the side that enters the arm is ambiguous (see Self::then_is_taken), or when the fallthrough can be entered other than by falling through, so that its hits do not split the jump’s.

Source

fn then_is_taken( &self, anchors: &(ItemAnchor, ItemAnchor), arms: &IfArms, ) -> Option<bool>

Returns whether the taken side of an if’s jump enters its then arm, or None when the sides cannot be told apart.

The code that each side runs alone, before it joins the other’s, decides when an arm has code there, including the code of the functions that the arm calls by name, which a compiler can inline. An arm that is the jump itself is the taken side. An arm without code is entered by the side that does not reach the next statement of the block, such as the loop exit of a break or the increment of a continue, but only when the sides never meet and the other side does not reach that statement either: a side that carries a value into the join point, as with if (c) { x = 2; }, meets the other side’s code.

Source

fn trace(&self, pc: u32) -> Vec<usize>

Returns the instructions that run from pc up to the first conditional jump, dynamic jump, or halt, following static PUSH target; JUMP hops.

Source

fn starts_in_range(&self, ic: usize, loc: &SourceLocation) -> bool

Returns whether the instruction ic is mapped to the byte range of loc, as Self::simple matches, which tolerates a statement’s span ending before its ;.

Source

fn has_own_code(&self, loc: &SourceLocation) -> bool

Returns whether an instruction mapped inside loc runs only when loc does. The pushes that feed a conditional jump do not: they run with the jump, even when its target is the body of a break or continue.

Source

fn alias_return( &self, item_id: u32, function: &SourceLocation, ) -> Option<ItemAnchor>

An alias-only function has no instructions for some of its statements. Its unique normal return proves those statements completed. Require an exact declaration location at the entry, an explicit function-exit marker mapped to the declaration or the closing brace, and a pure return stub; never infer hits for inlined or aborting code.

Source

fn revert_guard( &self, item_id: u32, guard: &RevertGuard, ) -> Option<(ItemAnchor, Option<u32>)>

A shared revert has no unique body location. Recover its controlling edge only when a single decision matches the condition and exactly one successor emits the resolved error. Payload matching determines polarity; source order and compiler identity do not.

Source

fn continues_after(&self, start: usize, guard: &RevertGuard) -> bool

The other successor must positively reach the source continuation in this same function. An unsupported error stub is unknown, not evidence for the opposite branch’s polarity.

Auto Trait Implementations§

§

impl<'a> Freeze for AnchorIndex<'a>

§

impl<'a> RefUnwindSafe for AnchorIndex<'a>

§

impl<'a> Send for AnchorIndex<'a>

§

impl<'a> Sync for AnchorIndex<'a>

§

impl<'a> Unpin for AnchorIndex<'a>

§

impl<'a> UnsafeUnpin for AnchorIndex<'a>

§

impl<'a> UnwindSafe for AnchorIndex<'a>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<T, R> CollectAndApply<T, R> for T

§

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

§

type Output = R

§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<TxEnv, T> FromRecoveredTx<&T> for TxEnv
where TxEnv: FromRecoveredTx<T>,

§

fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv

Builds a [TxEnv] from a transaction and a sender address.
§

impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnv
where TxEnv: FromTxWithEncoded<T>,

§

fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv

Builds a [TxEnv] from a transaction, its sender, and encoded transaction bytes.
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts 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 more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts 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> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in [Layered].
§

impl<T> MaybeCompact for T

§

impl<T> NonStaticAny for T
where T: ?Sized,

§

fn type_id(&self) -> TypeId

Returns the lifetime-erased type ID of self.
§

impl<T> Paint for T
where T: ?Sized,

§

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 primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Primary].

§Example
println!("{}", value.primary());
§

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Fixed].

§Example
println!("{}", value.fixed(color));
§

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Rgb].

§Example
println!("{}", value.rgb(r, g, b));
§

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Black].

§Example
println!("{}", value.black());
§

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Red].

§Example
println!("{}", value.red());
§

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Green].

§Example
println!("{}", value.green());
§

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Yellow].

§Example
println!("{}", value.yellow());
§

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Blue].

§Example
println!("{}", value.blue());
§

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Magenta].

§Example
println!("{}", value.magenta());
§

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Cyan].

§Example
println!("{}", value.cyan());
§

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: White].

§Example
println!("{}", value.white());
§

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlack].

§Example
println!("{}", value.bright_black());
§

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightRed].

§Example
println!("{}", value.bright_red());
§

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightGreen].

§Example
println!("{}", value.bright_green());
§

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightYellow].

§Example
println!("{}", value.bright_yellow());
§

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlue].

§Example
println!("{}", value.bright_blue());
§

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.bright_magenta());
§

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightCyan].

§Example
println!("{}", value.bright_cyan());
§

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightWhite].

§Example
println!("{}", value.bright_white());
§

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>

Returns self with the bg() set to [Color :: Primary].

§Example
println!("{}", value.on_primary());
§

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Fixed].

§Example
println!("{}", value.on_fixed(color));
§

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Rgb].

§Example
println!("{}", value.on_rgb(r, g, b));
§

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Black].

§Example
println!("{}", value.on_black());
§

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Red].

§Example
println!("{}", value.on_red());
§

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Green].

§Example
println!("{}", value.on_green());
§

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Yellow].

§Example
println!("{}", value.on_yellow());
§

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Blue].

§Example
println!("{}", value.on_blue());
§

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Magenta].

§Example
println!("{}", value.on_magenta());
§

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Cyan].

§Example
println!("{}", value.on_cyan());
§

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: White].

§Example
println!("{}", value.on_white());
§

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlack].

§Example
println!("{}", value.on_bright_black());
§

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightRed].

§Example
println!("{}", value.on_bright_red());
§

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightGreen].

§Example
println!("{}", value.on_bright_green());
§

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightYellow].

§Example
println!("{}", value.on_bright_yellow());
§

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlue].

§Example
println!("{}", value.on_bright_blue());
§

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.on_bright_magenta());
§

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightCyan].

§Example
println!("{}", value.on_bright_cyan());
§

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightWhite].

§Example
println!("{}", value.on_bright_white());
§

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 bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Bold].

§Example
println!("{}", value.bold());
§

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Dim].

§Example
println!("{}", value.dim());
§

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Italic].

§Example
println!("{}", value.italic());
§

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Underline].

§Example
println!("{}", value.underline());

Returns self with the attr() set to [Attribute :: Blink].

§Example
println!("{}", value.blink());

Returns self with the attr() set to [Attribute :: RapidBlink].

§Example
println!("{}", value.rapid_blink());
§

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Invert].

§Example
println!("{}", value.invert());
§

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Conceal].

§Example
println!("{}", value.conceal());
§

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Strike].

§Example
println!("{}", value.strike());
§

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 mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Mask].

§Example
println!("{}", value.mask());
§

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Wrap].

§Example
println!("{}", value.wrap());
§

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Linger].

§Example
println!("{}", value.linger());
§

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.

Returns self with the quirk() set to [Quirk :: Clear].

§Example
println!("{}", value.clear());
§

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Resetting].

§Example
println!("{}", value.resetting());
§

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Bright].

§Example
println!("{}", value.bright());
§

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: OnBright].

§Example
println!("{}", value.on_bright());
§

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);
§

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new [Painted] with a default [Style]. Read more
§

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows 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) -> R
where R: 'a,

Mutably borrows 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
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows 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
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows 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
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .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
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .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
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> Threaded<T> for T

§

type Rest = ()

The outputs beyond the threaded value.
§

fn split(self) -> (T, ())

Splits into the threaded value and the extra outputs.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more

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: 224 bytes