Skip to main content

ExecutionLifecycle

Struct ExecutionLifecycle 

Source
pub struct ExecutionLifecycle<F: FoundryEvmFactory> {
    factory: F,
    forks: ForkRegistry<F::Types>,
    snapshots: StateSnapshots<LifecycleSnapshot<F::Types>>,
    pending_env: Option<EvmEnv<F::Types>>,
    tx_prewarm: Option<PrewarmSet>,
    tx_original: AddressMap<Option<AccountInfo>>,
    switch_slots: AddressMap<HashSet<U256>>,
}
Expand description

Fork, snapshot and nested-execution lifecycle for one EVM network family.

Fields§

§factory: F§forks: ForkRegistry<F::Types>§snapshots: StateSnapshots<LifecycleSnapshot<F::Types>>§pending_env: Option<EvmEnv<F::Types>>§tx_prewarm: Option<PrewarmSet>

Base warm set of the running transaction from before a fork switch carried warmth into it.

§tx_original: AddressMap<Option<AccountInfo>>

Transaction-start info of the persistent accounts a fork switch accepted the running transaction’s changes to.

§switch_slots: AddressMap<HashSet<U256>>

Warm slots of persistent accounts the last fork switch carried into the next context.

Implementations§

Source§

impl<F: FoundryEvmFactory> ExecutionLifecycle<F>

Source

pub fn new(factory: F, db: impl BackingDb, env: EvmEnv<F::Types>) -> Self

Creates a lifecycle whose active context is local execution over db.

Source

pub const fn factory(&self) -> &F

Returns the factory.

Source

pub fn set_factory(&mut self, factory: F)

Replaces the factory used for EVMs built from now on.

Source

pub const fn forks(&self) -> &ForkRegistry<F::Types>

Returns the fork registry.

Source

pub const fn forks_mut(&mut self) -> &mut ForkRegistry<F::Types>

Returns the fork registry mutably, for persistent-account changes.

Source

pub fn active(&self) -> &Parked<F::Types>

Returns the active context.

Source

pub fn active_mut(&mut self) -> &mut Parked<F::Types>

Returns the active context mutably.

Use it between executions only: a running EVM holds its own view of the context.

Source

pub fn refresh_switched_slot( &mut self, address: &Address, slot: U256, value: U256, )

Records value as the accepted value of a slot the running transaction restored the original of when it resumed the active context, such as after refreshing the slot from the remote, so that a revert leaving the context keeps it.

Source

pub fn accepted_mut(&mut self) -> &mut Cache

Returns the active context’s accepted state for modification between executions, initializing the context first if it never ran.

Source

pub fn accepted_db(&self) -> impl BackingDb + use<F>

Returns a database reading the active context’s accepted state over its backing database, for reads between executions.

Source

pub fn has_snapshot(&self, id: U256) -> bool

Returns whether a snapshot exists.

Source

pub fn create_evm<'a>(&self) -> Evm<'a, F::Types>

Creates an EVM over the active context without copying its accepted state.

A context that never ran is initialized first (network genesis, sentinels). Pass the EVM to Self::park to accept its state, or drop it to discard it.

Source

pub fn park(&mut self, evm: Evm<'_, F::Types>)

Accepts evm’s state, environment and network extension state into the active context. A fork keeps its own chain ID.

Call this between transactions, with an EVM created by Self::create_evm whose executions were committed. In-flight state that was not committed is discarded, and a deferred environment change is applied first.

Source

pub(crate) fn park_detached(&mut self, evm: Evm<'_, F::Types>)

Like Self::park, for an EVM whose executions were not committed, such as a call’s: its pending writes are discarded, but the accepted state it carries, such as after a fork switch, is kept.

Source

fn accept(&mut self, evm: Evm<'_, F::Types>, committed: bool)

Accepts evm’s state, environment and network extension state into the active context.

An EVM that materialized its accepted state holds the context’s whole accepted state, which replaces the context’s. One that still reads it through a shared view only holds what its executions read and, if committed, wrote, which is merged into the context’s; without committed writes it only caches reads, so it is dropped rather than copying the shared accepted state.

Source

pub fn materialize(&self, evm: &mut Evm<'_, F::Types>)

Materializes the accepted state evm reads through a shared view into its own overlay.

Operations that capture or replace the running state call this first; it copies the accepted state once per execution.

Source

pub fn create_fork( &mut self, info: ForkInfo, db: impl BackingDb, env: EvmEnv<F::Types>, ) -> U256

Registers a fork without selecting it and returns its local fork ID.

Source

pub fn select_fork( &mut self, evm: &mut Evm<'_, F::Types>, id: Option<U256>, phase: ExecutionPhase, ) -> Result<()>

Makes id the running context, or the local context for None.

Persistent accounts carry their accepted state into the target. Leaving the local context makes what the running transaction loaded and created there the initial state of every fork.

Source

pub const fn activate_detached(&mut self, id: Option<U256>)

Makes id the active context, or the local context for None, without suspending the running state: for a throwaway copy of the lifecycle whose transaction already runs over id’s state, such as one prepared with Self::prepare_on_inactive.

Source

pub fn roll_fork( &mut self, evm: &mut Evm<'_, F::Types>, id: Option<U256>, db: impl BackingDb, env: EvmEnv<F::Types>, cache: Option<Cache>, phase: ExecutionPhase, ) -> Result<()>

Moves fork id, or the running context for None, onto a new backing database and environment, such as a later block.

The fork starts over from the initial fork state, keeping persistent accounts and accounts created on the fork. Rolling the running context also keeps other loaded accounts, but reloads only their info from the new database, discarding their pre-roll storage slots.

With cache, the fork resumes with it as its accepted state, such as state replayed up to a transaction.

Source

pub fn replace_inactive( &mut self, id: Option<U256>, db: impl BackingDb, env: EvmEnv<F::Types>, cache: Option<Cache>, ) -> Result<()>

Moves the inactive fork id, or the local context for None, onto a new backing database and environment, optionally with cache as its accepted state.

The fork’s accepted state is discarded except for persistent accounts and accounts created on it, and the fork starts over from the initial fork state.

Source

pub const fn pending_env(&self) -> Option<&EvmEnv<F::Types>>

Returns the environment change deferred by an in-flight operation, applied at the next transaction.

Source

pub const fn tx_prewarm(&self) -> Option<&PrewarmSet>

Returns the base warm set of the running transaction if a fork switch carried warmth into its warm set, which cooling the transaction’s state must restore.

Source

pub fn remove_prewarm(&mut self, state: &mut State<'_>, address: &Address)

Removes address from the running transaction’s base warmth in state and in the warmth that fork switches and isolated static calls restore, so it stays cold until it is accessed again.

Source

pub fn tracks_prewarm(&self, address: &Address) -> bool

Returns whether Self::remove_prewarm would change the lifecycle, not only state.

Source

pub fn has_persistent_warmth(&self) -> bool

Returns whether any context keeps warmth of a persistent account for the running transaction, which Self::take_persistent_warmth would take.

Source

pub fn take_persistent_warmth( &mut self, ) -> Vec<(Option<U256>, AddressMap<HashSet<U256>>)>

Takes the warmth of persistent accounts that contexts kept for the running transaction, so that a nested transaction, such as an isolated call, resumes them cold in every context. Hand it back with Self::restore_persistent_warmth when the nested transaction ends.

Source

pub fn restore_persistent_warmth( &mut self, warmth: Vec<(Option<U256>, AddressMap<HashSet<U256>>)>, )

Hands persistent warmth taken with Self::take_persistent_warmth back to its contexts.

Source

pub fn begin_transaction(&mut self, evm: &mut Evm<'_, F::Types>)

Applies an environment change deferred by an in-flight operation and forgets the warmth contexts kept from the previous transaction. Call before every transaction.

Source

pub fn set_env( &mut self, evm: &mut Evm<'_, F::Types>, env: EvmEnv<F::Types>, phase: ExecutionPhase, )

Switches evm to env. The block applies at once; a spec or chain ID change applies at once between transactions and is deferred to the next transaction while one is in flight.

Source

pub fn snapshot(&mut self, evm: &mut Evm<'_, F::Types>) -> U256

Captures the running context and every fork, and returns the snapshot ID.

Source

pub fn revert( &mut self, evm: &mut Evm<'_, F::Types>, id: U256, action: RevertStateSnapshotAction, phase: ExecutionPhase, ) -> Option<StateSnapshot>

Restores snapshot id and returns the running state it replaced, or None if it does not exist.

Logs emitted since the snapshot are kept. Only the context that was active at the snapshot gets its state back and becomes active again; other contexts, persistent accounts and forks created after the snapshot are left as they are. The replaced state is materialized, so that a failing frame can reinstate it over a backing database with SnapshotRestores.

Source

pub fn delete_snapshot(&mut self, id: U256) -> bool

Deletes a snapshot, returning whether it existed.

Source

pub fn delete_snapshots(&mut self)

Deletes every snapshot.

Source

pub fn nested_evm<'a>( &self, evm: &mut Evm<'_, F::Types>, tx: &Recovered<<F::Types as EvmTypesHost>::Tx>, env: Option<EvmEnv<F::Types>>, ext: Option<<F::Types as EvmTypesHost>::EvmExt>, ) -> Evm<'a, F::Types>

Builds the EVM a nested transaction of the running one executes on: a copy of the running transaction’s current state, with env or the running environment, and ext or network extension state derived from the running EVM for tx.

Source

pub unsafe fn begin_frame_evm<'a>( &self, evm: &mut Evm<'_, F::Types>, env: EvmEnv<F::Types>, ) -> Evm<'a, F::Types>

Moves the transaction evm is running onto a separate frame EVM executing with env, such as for deployCode or an in-flight spec change.

Execute messages on the returned EVM with Host::execute_message and hand its state back with Self::end_frame_evm; evm must not execute in between.

§Safety

The running state of evm moves into the returned EVM, whose lifetime 'a the caller chooses. Every database in that state must outlive 'a: it must be one the lifecycle installed, all of which are owned ('static), not a database borrowed by the caller.

Source

pub unsafe fn end_frame_evm( &self, evm: &mut Evm<'_, F::Types>, frame: Evm<'_, F::Types>, )

Hands the state, transaction environment, block and network extension state of a frame EVM created with Self::begin_frame_evm back to evm, restoring evm’s empty-account policy on the active backing database.

§Safety

The running state of frame moves into evm. Every database in that state must outlive evm: it must be one the lifecycle installed, as for Self::begin_frame_evm.

Source

pub fn prepare_nested( &self, evm: &mut Evm<'_, F::Types>, tx: Recovered<<F::Types as EvmTypesHost>::Tx>, env: Option<EvmEnv<F::Types>>, ext: Option<<F::Types as EvmTypesHost>::EvmExt>, ) -> PreparedTx<F::Types>

Prepares tx to execute as a nested transaction of the running one on the EVM Self::nested_evm builds.

Source

pub fn prepare_on_inactive( &self, evm: &mut Evm<'_, F::Types>, id: Option<U256>, tx: Recovered<<F::Types as EvmTypesHost>::Tx>, env: Option<EvmEnv<F::Types>>, ext: Option<<F::Types as EvmTypesHost>::EvmExt>, ) -> Result<PreparedTx<F::Types>>

Prepares tx to execute on the inactive fork id, or the local context for None, and be accepted there, such as for vm.transact on another fork.

Persistent accounts carry the running transaction’s state into the fork, and the transaction’s changes to them are merged back into the running transaction as journaled writes. The running transaction’s other loaded accounts then take the fork’s resulting state, see Self::rebase_onto_inactive.

Source

pub fn store_executed( &mut self, executed: ExecutedNested<F::Types>, ) -> TxResult<F::Types>

Stores the outcome of a PreparedTx: an inactive context’s new accepted state.

Source

pub fn rebase_onto_inactive( &self, evm: &mut Evm<'_, F::Types>, id: Option<U256>, ) -> Result<()>

Replaces the accounts the running transaction of evm loaded, except persistent ones, with their accepted state on the inactive fork id, or the local context for None, as journaled writes, such as after replaying transactions there.

Source

fn suspend(&mut self, evm: &mut Evm<'_, F::Types>) -> Suspended

Accepts the running state and stores it, with the running environment, in the active context. A fork keeps its own chain ID. Returns what the running transaction carries into the next context.

Source

fn resume( &mut self, evm: &mut Evm<'_, F::Types>, suspended: Suspended, carry: bool, phase: ExecutionPhase, )

Installs the active context into evm, carrying persistent accounts, logs and base warmth over from the suspended context. With carry, the loaded and created accounts of the suspended context are carried over as well.

Source

fn apply_env( &mut self, factory: &F, evm: &mut Evm<'_, F::Types>, env: EvmEnv<F::Types>, phase: ExecutionPhase, )

Applies env, deferring a spec or chain ID change while a transaction is in flight.

Source

fn store_env(&mut self, env: EvmEnv<F::Types>)

Stores env as the active context’s environment.

A fork keeps the chain ID it was created or rolled with: a running change such as vm.chainId does not follow the fork to its next selection. The executor carries such a change to its next transaction instead.

Source

pub const fn switch_slots(&self) -> &AddressMap<HashSet<U256>>

Returns the warm slots of persistent accounts the last fork switch carried into the next context.

Source

pub fn loaded_state(&self, state: &State<'_>) -> AddressMap<HashSet<U256>>

Returns the accounts loaded in the running transaction, including accounts loaded as absent and accounts loaded before fork switches, with their loaded slots.

Accepted state the running transaction did not load is not included.

Source

pub fn loaded_storage(&self, state: &State<'_>, address: &Address) -> Vec<U256> ⓘ

Returns the slots of address loaded in the running transaction, including before fork switches.

Source

pub fn suspended_storage( &self, ) -> impl Iterator<Item = (Option<U256>, Address, U256)> + '_

Returns storage keys retained from earlier context visits, attributed to their forks. These can be absent from the final pending state when an unchanged slot was read before a fork switch. Collect them before parking clears the active context’s loaded keys.

Source

pub fn sync_database_policy(&self, evm: &mut Evm<'_, F::Types>)

Rebinds the running state’s backing handle to its EVM’s empty-account policy without copying accepted state or changing another execution’s policy.

Trait Implementations§

Source§

impl<F: FoundryEvmFactory> Clone for ExecutionLifecycle<F>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<F: FoundryEvmFactory> Debug for ExecutionLifecycle<F>

Source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

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,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

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

impl<T> DynClone for T
where T: Clone,

§

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<T> FromRef<T> for T
where T: Clone,

§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
§

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.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T> TryClone for T
where T: Clone,

§

fn try_clone(&self) -> Result<T, Error>

Clones self, possibly returning an error.
§

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: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.