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>
impl<'a> AnchorIndex<'a>
fn new( bytecode: &'a [u8], source_map: &'a SourceMap, ic_pc_map: &'a IcPcMap, ) -> Self
Sourcefn instructions_starting_in(
&self,
loc: &SourceLocation,
) -> impl Iterator<Item = usize> + Clone
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.
Sourcefn simple(&self, item_id: u32, loc: &SourceLocation) -> Result<ItemAnchor>
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.
Sourcefn taken_fails(
&self,
anchors: &(ItemAnchor, ItemAnchor),
loc: &SourceLocation,
) -> bool
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.
Sourcefn taken_starts_in(
&self,
(fallthrough, taken): &(ItemAnchor, ItemAnchor),
loc: &SourceLocation,
) -> Option<bool>
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.
Sourcefn jump_is_body(
&self,
(fallthrough, _): &(ItemAnchor, ItemAnchor),
loc: &SourceLocation,
) -> bool
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.
Sourcefn starts_in(&self, pc: u32, loc: &SourceLocation) -> bool
fn starts_in(&self, pc: u32, loc: &SourceLocation) -> bool
Returns whether the first instruction at pc after any JUMPDESTs is mapped inside loc.
Sourcefn maps_inside(&self, ic: usize, loc: &SourceLocation) -> bool
fn maps_inside(&self, ic: usize, loc: &SourceLocation) -> bool
Returns whether the instruction ic is mapped inside loc.
Sourcefn fails(&self, pc: u32) -> bool
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.
Sourcefn true_arm_falls_through(
&self,
(fallthrough, taken): &(ItemAnchor, ItemAnchor),
arms: &TernaryArms,
) -> bool
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.
Sourcefn block_maps_inside(&self, pc: u32, loc: &SourceLocation) -> bool
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.
Sourcefn function(&self, item_id: u32, loc: &SourceLocation) -> Result<ItemAnchor>
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.
Sourcefn falls_through_into(&self, from: usize, to: usize) -> bool
fn falls_through_into(&self, from: usize, to: usize) -> bool
Returns whether execution can fall through from from into the JUMPDEST to.
Sourcefn is_entered_only_from_inside(
&self,
instruction: usize,
loc: &SourceLocation,
) -> bool
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.
Sourcefn is_jumped_to_from_outside(
&self,
instruction: usize,
loc: &SourceLocation,
) -> bool
fn is_jumped_to_from_outside( &self, instruction: usize, loc: &SourceLocation, ) -> bool
Returns whether a static jump mapped outside loc targets instruction.
Sourcefn push_element(&self, push: usize) -> Option<&SourceElement>
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.
Sourcefn fallthrough_entries(
&self,
(fallthrough, _): &(ItemAnchor, ItemAnchor),
) -> Result<Vec<(u32, bool)>>
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.
Sourcefn branch(
&self,
item_id: u32,
loc: &SourceLocation,
exact: bool,
nested: Option<&SourceLocation>,
) -> Result<(ItemAnchor, ItemAnchor)>
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.
Sourcefn if_edge(
&self,
item_id: u32,
path_id: u32,
loc: &SourceLocation,
arms: &IfArms,
) -> Option<(ItemAnchor, Option<u32>, Vec<(u32, bool)>)>
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.
Sourcefn then_is_taken(
&self,
anchors: &(ItemAnchor, ItemAnchor),
arms: &IfArms,
) -> Option<bool>
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.
Sourcefn trace(&self, pc: u32) -> Vec<usize>
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.
Sourcefn starts_in_range(&self, ic: usize, loc: &SourceLocation) -> bool
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 ;.
Sourcefn has_own_code(&self, loc: &SourceLocation) -> bool
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.
Sourcefn alias_return(
&self,
item_id: u32,
function: &SourceLocation,
) -> Option<ItemAnchor>
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.
Sourcefn revert_guard(
&self,
item_id: u32,
guard: &RevertGuard,
) -> Option<(ItemAnchor, Option<u32>)>
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.
Sourcefn continues_after(&self, start: usize, guard: &RevertGuard) -> bool
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> 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<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for 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<TxEnv, T> FromRecoveredTx<&T> for TxEnvwhere
TxEnv: FromRecoveredTx<T>,
impl<TxEnv, T> FromRecoveredTx<&T> for TxEnvwhere
TxEnv: FromRecoveredTx<T>,
§fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv
fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv
TxEnv] from a transaction and a sender address.§impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnvwhere
TxEnv: FromTxWithEncoded<T>,
impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnvwhere
TxEnv: FromTxWithEncoded<T>,
§fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv
fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv
TxEnv] from a transaction, its sender, and encoded transaction bytes.§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> 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> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T in a tonic::Request§impl<L> LayerExt<L> for L
impl<L> LayerExt<L> for L
§fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
Layered].impl<T> MaybeCompact for T
§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>
renamed to 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> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
§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> Threaded<T> for T
impl<T> Threaded<T> for T
§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: 224 bytes