reth_ethereum::rpc

Struct DebugApi

Source 
pub struct DebugApi<Eth, BlockExecutor> { /* private fields */ }
Available on crate feature rpc only.
Expand description

debug API implementation.

This type provides the functionality for handling debug related requests.

Implementations§

Source§

impl<Eth, BlockExecutor> DebugApi<Eth, BlockExecutor>

Source

pub fn new( eth: Eth, blocking_task_guard: BlockingTaskGuard, block_executor: BlockExecutor, ) -> DebugApi<Eth, BlockExecutor>

Create a new instance of the DebugApi

Source

pub fn eth_api(&self) -> &Eth

Access the underlying Eth API.

Source§

impl<Eth, BlockExecutor> DebugApi<Eth, BlockExecutor>
where Eth: RpcNodeCore,

Source

pub fn provider(&self) -> &<Eth as RpcNodeCore>::Provider

Access the underlying provider.

Source§

impl<Eth, BlockExecutor> DebugApi<Eth, BlockExecutor>
where Eth: EthApiTypes + TraceExt + 'static, BlockExecutor: BlockExecutorProvider, <BlockExecutor as BlockExecutorProvider>::Primitives: NodePrimitives<Block = <<Eth as RpcNodeCore>::Provider as BlockReader>::Block>,

Source

pub async fn debug_trace_raw_block( &self, rlp_block: Bytes, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult<GethTrace, String>>, <Eth as EthApiTypes>::Error>

Replays the given block and returns the trace of each transaction.

This expects a rlp encoded block

Note, the parent of this block must be present, or it will fail.

Source

pub async fn debug_trace_block( &self, block_id: BlockId, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult<GethTrace, String>>, <Eth as EthApiTypes>::Error>

Replays a block and returns the trace of each transaction.

Source

pub async fn debug_trace_transaction( &self, tx_hash: FixedBytes<32>, opts: GethDebugTracingOptions, ) -> Result<GethTrace, <Eth as EthApiTypes>::Error>

Trace the transaction according to the provided options.

Ref: https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers

Source

pub async fn debug_trace_call( &self, call: TransactionRequest, block_id: Option<BlockId>, opts: GethDebugTracingCallOptions, ) -> Result<GethTrace, <Eth as EthApiTypes>::Error>

The debug_traceCall method lets you run an eth_call within the context of the given block execution using the final state of parent block as the base.

Differences compare to eth_call:

Source

pub async fn debug_trace_call_many( &self, bundles: Vec<Bundle>, state_context: Option<StateContext>, opts: Option<GethDebugTracingCallOptions>, ) -> Result<Vec<Vec<GethTrace>>, <Eth as EthApiTypes>::Error>

The debug_traceCallMany method lets you run an eth_callMany within the context of the given block execution using the first n transactions in the given block as base. Each following bundle increments block number by 1 and block timestamp by 12 seconds

Source

pub async fn debug_execution_witness_by_block_hash( &self, hash: FixedBytes<32>, ) -> Result<ExecutionWitness, <Eth as EthApiTypes>::Error>

Generates an execution witness for the given block hash. see Self::debug_execution_witness for more info.

Source

pub async fn debug_execution_witness( &self, block_id: BlockNumberOrTag, ) -> Result<ExecutionWitness, <Eth as EthApiTypes>::Error>

The debug_executionWitness method allows for re-execution of a block with the purpose of generating an execution witness. The witness comprises of a map of all hashed trie nodes to their preimages that were required during the execution of the block, including during state root recomputation.

Source

pub async fn debug_execution_witness_for_block( &self, block: Arc<RecoveredBlock<<<Eth as RpcNodeCore>::Provider as BlockReader>::Block>>, ) -> Result<ExecutionWitness, <Eth as EthApiTypes>::Error>

Generates an execution witness, using the given recovered block.

Source

pub async fn debug_code_by_hash( &self, hash: FixedBytes<32>, block_id: Option<BlockId>, ) -> Result<Option<Bytes>, <Eth as EthApiTypes>::Error>

Returns the code associated with a given hash at the specified block ID. If no code is found, it returns None. If no block ID is provided, it defaults to the latest block.

Trait Implementations§

Source§

impl<Eth, BlockExecutor> Clone for DebugApi<Eth, BlockExecutor>

Source§

fn clone(&self) -> DebugApi<Eth, BlockExecutor>

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<Eth, BlockExecutor> Debug for DebugApi<Eth, BlockExecutor>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<Eth, BlockExecutor> DebugApiServer for DebugApi<Eth, BlockExecutor>
where Eth: EthApiTypes + EthTransactions + TraceExt + 'static, BlockExecutor: BlockExecutorProvider, <BlockExecutor as BlockExecutorProvider>::Primitives: NodePrimitives<Block = <<Eth as RpcNodeCore>::Provider as BlockReader>::Block>,

Source§

fn raw_header<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Bytes, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_getRawHeader

Source§

fn raw_block<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Bytes, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_getRawBlock

Source§

fn raw_transaction<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_getRawTransaction

If this is a pooled EIP-4844 transaction, the blob sidecar is included.

Returns the bytes of the transaction for the given hash.

Source§

fn raw_transactions<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Bytes>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_getRawTransactions Returns the bytes of the transaction for the given hash.

Source§

fn raw_receipts<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Bytes>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_getRawReceipts

Source§

fn bad_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Block>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_getBadBlocks

Source§

fn debug_trace_chain<'life0, 'async_trait>( &'life0 self, _start_exclusive: BlockNumberOrTag, _end_inclusive: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockTraceResult>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_traceChain

Source§

fn debug_trace_block<'life0, 'async_trait>( &'life0 self, rlp_block: Bytes, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TraceResult<GethTrace, String>>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_traceBlock

Source§

fn debug_trace_block_by_hash<'life0, 'async_trait>( &'life0 self, block: FixedBytes<32>, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TraceResult<GethTrace, String>>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_traceBlockByHash

Source§

fn debug_trace_block_by_number<'life0, 'async_trait>( &'life0 self, block: BlockNumberOrTag, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TraceResult<GethTrace, String>>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_traceBlockByNumber

Source§

fn debug_trace_transaction<'life0, 'async_trait>( &'life0 self, tx_hash: FixedBytes<32>, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = Result<GethTrace, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_traceTransaction

Source§

fn debug_trace_call<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_id: Option<BlockId>, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = Result<GethTrace, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_traceCall

Source§

fn debug_execution_witness<'life0, 'async_trait>( &'life0 self, block: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<ExecutionWitness, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_executionWitness

Source§

fn debug_execution_witness_by_block_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<ExecutionWitness, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Handler for debug_executionWitnessByBlockHash

Source§

fn debug_trace_call_many<'life0, 'async_trait>( &'life0 self, bundles: Vec<Bundle>, state_context: Option<StateContext>, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<GethTrace>>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

The debug_traceCallMany method lets you run an eth_callMany within the context of the given block execution using the final state of parent block as the base followed by n transactions. Read more
Source§

fn debug_backtrace_at<'life0, 'life1, 'async_trait>( &'life0 self, _location: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the logging backtrace location. When a backtrace location is set and a log message is emitted at that location, the stack of the goroutine executing the log statement will be printed to stderr.
Source§

fn debug_account_range<'life0, 'async_trait>( &'life0 self, _block_number: BlockNumberOrTag, _start: Bytes, _max_results: u64, _nocode: bool, _nostorage: bool, _incompletes: bool, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Enumerates all accounts at a given block with paging capability. maxResults are returned in the page and the items have keys that come after the start key (hashed address). Read more
Source§

fn debug_block_profile<'life0, 'async_trait>( &'life0 self, _file: String, _seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Turns on block profiling for the given duration and writes profile data to disk. It uses a profile rate of 1 for most accurate information. If a different rate is desired, set the rate and write the profile manually using debug_writeBlockProfile.
Source§

fn debug_chaindb_compact<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Flattens the entire key-value database into a single level, removing all unused slots and merging all keys.
Source§

fn debug_chain_config<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ChainConfig, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the current chain config.
Source§

fn debug_chaindb_property<'life0, 'async_trait>( &'life0 self, _property: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns leveldb properties of the key-value database.
Source§

fn debug_code_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, block_id: Option<BlockId>, ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the code associated with a given hash at the specified block ID. If no block ID is provided, it defaults to the latest block.
Source§

fn debug_cpu_profile<'life0, 'async_trait>( &'life0 self, _file: String, _seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Turns on CPU profiling for the given duration and writes profile data to disk.
Source§

fn debug_db_ancient<'life0, 'async_trait>( &'life0 self, _kind: String, _number: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Retrieves an ancient binary blob from the freezer. The freezer is a collection of append-only immutable files. The first argument kind specifies which table to look up data from. The list of all table kinds are as follows:
Source§

fn debug_db_ancients<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the number of ancient items in the ancient store.
Source§

fn debug_db_get<'life0, 'async_trait>( &'life0 self, _key: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the raw value of a key stored in the database.
Source§

fn debug_dump_block<'life0, 'async_trait>( &'life0 self, _number: BlockId, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Retrieves the state that corresponds to the block number and returns a list of accounts (including storage and code).
Source§

fn debug_free_os_memory<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Forces garbage collection.
Source§

fn debug_freeze_client<'life0, 'async_trait>( &'life0 self, _node: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Forces a temporary client freeze, normally when the server is overloaded.
Source§

fn debug_gc_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns garbage collection statistics.
Source§

fn debug_get_accessible_state<'life0, 'async_trait>( &'life0 self, _from: BlockNumberOrTag, _to: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the first number where the node has accessible state on disk. This is the post-state of that block and the pre-state of the next block. The (from, to) parameters are the sequence of blocks to search, which can go either forwards or backwards. Read more
Source§

fn debug_get_modified_accounts_by_hash<'life0, 'async_trait>( &'life0 self, _start_hash: FixedBytes<32>, _end_hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns all accounts that have changed between the two blocks specified. A change is defined as a difference in nonce, balance, code hash, or storage hash. With one parameter, returns the list of accounts modified in the specified block.
Source§

fn debug_get_modified_accounts_by_number<'life0, 'async_trait>( &'life0 self, _start_number: u64, _end_number: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns all accounts that have changed between the two blocks specified. A change is defined as a difference in nonce, balance, code hash or storage hash.
Source§

fn debug_go_trace<'life0, 'async_trait>( &'life0 self, _file: String, _seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Turns on Go runtime tracing for the given duration and writes trace data to disk.
Source§

fn debug_intermediate_roots<'life0, 'async_trait>( &'life0 self, _block_hash: FixedBytes<32>, _opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Executes a block (bad- or canon- or side-), and returns a list of intermediate roots: the stateroot after each transaction.
Source§

fn debug_mem_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns detailed runtime memory statistics.
Source§

fn debug_mutex_profile<'life0, 'async_trait>( &'life0 self, _file: String, _nsec: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Turns on mutex profiling for nsec seconds and writes profile data to file. It uses a profile rate of 1 for most accurate information. If a different rate is desired, set the rate and write the profile manually.
Source§

fn debug_preimage<'life0, 'async_trait>( &'life0 self, _hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the preimage for a sha3 hash, if known.
Source§

fn debug_print_block<'life0, 'async_trait>( &'life0 self, _number: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Retrieves a block and returns its pretty printed form.
Source§

fn debug_seed_hash<'life0, 'async_trait>( &'life0 self, _number: u64, ) -> Pin<Box<dyn Future<Output = Result<FixedBytes<32>, ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Fetches and retrieves the seed hash of the block by number.
Source§

fn debug_set_block_profile_rate<'life0, 'async_trait>( &'life0 self, _rate: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the rate (in samples/sec) of goroutine block profile data collection. A non-zero rate enables block profiling, setting it to zero stops the profile. Collected profile data can be written using debug_writeBlockProfile.
Source§

fn debug_set_gc_percent<'life0, 'async_trait>( &'life0 self, _v: i32, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the garbage collection target percentage. A negative value disables garbage collection.
Source§

fn debug_set_head<'life0, 'async_trait>( &'life0 self, _number: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the current head of the local chain by block number. Note, this is a destructive action and may severely damage your chain. Use with extreme caution.
Source§

fn debug_set_mutex_profile_fraction<'life0, 'async_trait>( &'life0 self, _rate: i32, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the rate of mutex profiling.
Source§

fn debug_set_trie_flush_interval<'life0, 'async_trait>( &'life0 self, _interval: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Configures how often in-memory state tries are persisted to disk. The interval needs to be in a format parsable by a time.Duration. Note that the interval is not wall-clock time. Rather it is accumulated block processing time after which the state should be flushed.
Source§

fn debug_stacks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns a printed representation of the stacks of all goroutines.
Source§

fn debug_standard_trace_bad_block_to_file<'life0, 'async_trait>( &'life0 self, _block: BlockNumberOrTag, _opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Used to obtain info about a block.
Source§

fn debug_standard_trace_block_to_file<'life0, 'async_trait>( &'life0 self, _block: BlockNumberOrTag, _opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

This method is similar to debug_standardTraceBlockToFile, but can be used to obtain info about a block which has been rejected as invalid (for some reason).
Source§

fn debug_start_cpu_profile<'life0, 'async_trait>( &'life0 self, _file: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Turns on CPU profiling indefinitely, writing to the given file.
Source§

fn debug_start_go_trace<'life0, 'async_trait>( &'life0 self, _file: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Starts writing a Go runtime trace to the given file.
Source§

fn debug_stop_cpu_profile<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Stops an ongoing CPU profile.
Source§

fn debug_stop_go_trace<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Stops writing the Go runtime trace.
Source§

fn debug_storage_range_at<'life0, 'async_trait>( &'life0 self, _block_hash: FixedBytes<32>, _tx_idx: usize, _contract_address: Address, _key_start: FixedBytes<32>, _max_result: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the storage at the given block height and transaction index. The result can be paged by providing a maxResult to cap the number of storage slots returned as well as specifying the offset via keyStart (hash of storage key).
Source§

fn debug_trace_bad_block<'life0, 'async_trait>( &'life0 self, _block_hash: FixedBytes<32>, _opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Returns the structured logs created during the execution of EVM against a block pulled from the pool of bad ones and returns them as a JSON object. For the second parameter see TraceConfig reference.
Source§

fn debug_verbosity<'life0, 'async_trait>( &'life0 self, _level: usize, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the logging verbosity ceiling. Log messages with level up to and including the given level will be printed.
Source§

fn debug_vmodule<'life0, 'async_trait>( &'life0 self, _pattern: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Sets the logging verbosity pattern.
Source§

fn debug_write_block_profile<'life0, 'async_trait>( &'life0 self, _file: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Writes a goroutine blocking profile to the given file.
Source§

fn debug_write_mem_profile<'life0, 'async_trait>( &'life0 self, _file: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Writes an allocation profile to the given file.
Source§

fn debug_write_mutex_profile<'life0, 'async_trait>( &'life0 self, _file: String, ) -> Pin<Box<dyn Future<Output = Result<(), ErrorObject<'static>>> + Send + 'async_trait>>
where 'life0: 'async_trait, DebugApi<Eth, BlockExecutor>: 'async_trait,

Writes a goroutine blocking profile to the given file.
Source§

fn into_rpc(self) -> RpcModule<Self>

Collects all the methods and subscriptions defined in the trait and adds them into a single RpcModule.

Auto Trait Implementations§

§

impl<Eth, BlockExecutor> Freeze for DebugApi<Eth, BlockExecutor>

§

impl<Eth, BlockExecutor> !RefUnwindSafe for DebugApi<Eth, BlockExecutor>

§

impl<Eth, BlockExecutor> Send for DebugApi<Eth, BlockExecutor>
where Eth: Sync + Send, BlockExecutor: Sync + Send,

§

impl<Eth, BlockExecutor> Sync for DebugApi<Eth, BlockExecutor>
where Eth: Sync + Send, BlockExecutor: Sync + Send,

§

impl<Eth, BlockExecutor> Unpin for DebugApi<Eth, BlockExecutor>

§

impl<Eth, BlockExecutor> !UnwindSafe for DebugApi<Eth, BlockExecutor>

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

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

Source§

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

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

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,

Source§

fn __clone_box(&self, _: Private) -> *mut ()

§

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> 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> Instrument for T

Source§

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

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

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> 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: 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: 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
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.
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 = Infallible

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

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

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

impl<T> WithSubscriber for T

Source§

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

fn with_current_subscriber(self) -> WithDispatch<Self>

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

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> MaybeDebug for T
where T: Debug,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSendSync for T

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