Struct Test Scenario &nbsp; Copy item path

impl<Cache, Dsf, T> TestScenario<T, Cache, Dsf>
where T: ShieldedPoolTester, Cache: TestCache, Dsf: DataStoreFactory,

Add funds scenarios.

pub fn get_account_balance( &self, confirmations_policy: ConfirmationsPolicy, ) -> Option<AccountBalance>

Return the current test account balance, if possible.

Returns None when no account summary data is available, which is the case before the wallet has scanned any blocks.

pub fn add_a_single_note_checking_balance( &mut self, note: impl Into<TestNoteConfig<T>>, ) -> (BlockHeight, Cache::InsertResult, <T::Fvk as TestFvk>::Nullifier)

Adds funds from a single note from an address of the given type.

Returns the current block height, cache insert result and test viewing key nullifier.

This is shorthand for:

{
    let dfvk = T::test_account_fvk(&st);
    let output@(h, _, _) = st.generate_next_block(&dfvk, address_type, zatoshis);
    st.scan_cached_blocks(h, 1);
    output
}

This also verifies that the test account contains the expected funds as part of the total, and that the funds are spendable with the minimum number of confirmations.

pub fn add_empty_blocks(&mut self, n: usize) -> BlockHeight

Generates N empty blocks and scans them.

Returns the current block height.

pub fn get_account(&self) -> TestAccount<Dsf::Account>

Returns the test account.

pub fn add_notes_checking_balance( &mut self, blocks: impl IntoIterator<Item = impl IntoIterator<Item = impl Into<TestNoteConfig<T>>>>, ) -> AddFundsSummary<T, Cache>

Add funds from multiple notes in one or more blocks, or generate empty blocks.

This step also verifies that the test account contains the expected funds as part of the total. Keep in mind that these funds may not yet be spendable due to the number of confirmations required.

Returns a summary of steps.

§Parameters

blocks - A collection of “blocks”, where each “block” is a collection of “notes”. More specifically, “notes” can be anything that can be converted into a TestNoteConfig. This allows you to add multiple blocks that each containing zero or more notes with one call to add_notes.

§Note

Keep in mind:

Each block coalesces these notes into a single transaction.
Funds are added to the default test account.

pub fn propose_transfer_to( &mut self, to: &Address, amount: Zatoshis, ) -> Proposal<StandardFeeRule, <Dsf::DataStore as InputSource>::NoteRef>

Proposes a ZIP 317 transfer of amount zatoshis from the test account to to, panicking if proposal construction fails.

This fixes the values that are constant across most transfer scenarios: the test account, StandardFeeRule::Zip317, ConfirmationsPolicy::MIN, no memos, and the tester’s shielded pool as the fallback change pool.

pub fn spend_to(&mut self, to: &Address, amount: Zatoshis) -> TxId

Proposes and executes a transfer of amount zatoshis to to with OvkPolicy::Sender, returning the single resulting transaction id.

Shorthand for Self::propose_transfer_to followed by TestState::create_proposed_transactions. (Named spend_to to avoid clashing with the lower-level TestState::spend.)

pub fn create_proposed_expecting( &mut self, proposal: &Proposal<StandardFeeRule, <Dsf::DataStore as InputSource>::NoteRef>, expected: usize, ) -> NonEmpty<TxId>

Creates the transactions for proposal with OvkPolicy::Sender, asserts that exactly expected transactions were produced, and returns their ids.

This collapses the common TestState::create_proposed_transactions-then-assert-count boilerplate. It fixes the values that are constant across nearly every execution site: the test account’s spending key and OvkPolicy::Sender. On failure it reports the full result (including any error), matching the diagnostics of the hand-written form.

pub fn expect_insufficient_funds( &mut self, to: &Address, amount: Zatoshis, available: Zatoshis, required: Zatoshis, )

Asserts that proposing a transfer of amount zatoshis to to fails with Error::InsufficientFunds, reporting available available and exactly required required.

pub fn expect_insufficient_funds_with( &mut self, to: &Address, amount: Zatoshis, confirmations_policy: ConfirmationsPolicy, available: Zatoshis, required: Zatoshis, )

Like Self::expect_insufficient_funds, but with an explicit confirmations_policy instead of the fixed ConfirmationsPolicy::MIN.

pub fn mine_decoy_block(&mut self, seed: u8, value: Zatoshis) -> BlockHeight

Mines a single “decoy” block that pays value to a throwaway external address derived from seed (so the funds do not accrue to the test account), returning the new block height. Does not scan.

pub fn mine_decoy_blocks( &mut self, seeds: impl IntoIterator<Item = u8>, value: Zatoshis, ) -> Option<BlockHeight>

Mines one decoy block per seed (see Self::mine_decoy_block), returning the height of the last block mined, if any. Does not scan.

pub fn sole_note_ref(&self) -> OutputRef

Returns an OutputRef for the wallet’s single received note in the tester’s shielded pool, asserting that exactly one such note exists.

pub fn note_ref_by_value(&self, value: Zatoshis) -> OutputRef

Returns an OutputRef for the single received note whose value equals value, panicking if no such note exists.

Used by the multi-note scenarios, which fund the account with notes of distinct values so that each note can be identified by its value.

pub fn propose_locking_transfer( &mut self, to: &Address, amount: Zatoshis, owner: LockOwner, lock_for_blocks: u32, ) -> Proposal<StandardFeeRule, <Dsf::DataStore as InputSource>::NoteRef>

Proposes a ZIP 317 transfer of amount zatoshis to to that locks its own selected inputs on behalf of owner for lock_for_blocks blocks, panicking if proposal construction fails.

This is the locking counterpart of Self::propose_transfer_to: it goes through the lower-level propose_transfer so that a LockRequest can be attached, and fixes the same constants (the test account, a GreedyInputSelector, the tester’s single-output change strategy, ConfirmationsPolicy::MIN, the default SpendPolicy, and no requested transaction version).

Methods from Deref<Target = TestState<C, D::DataStore, LocalNetwork>>§

pub fn clock(&self) -> &FixedClock

Exposes the fixed clock that this test state passes to wallet operations.

pub fn wallet(&self) -> &DataStore

Exposes an immutable reference to the test’s DataStore.

pub fn wallet_mut(&mut self) -> &mut DataStore

Exposes a mutable reference to the test’s DataStore.

pub fn rng_mut(&mut self) -> &mut ChaChaRng

Exposes the test framework’s source of randomness.

pub fn network(&self) -> &Network

Exposes the network in use.

pub fn sapling_activation_height(&self) -> BlockHeight

Convenience method for obtaining the Sapling activation height for the network under test.

pub fn nu5_activation_height(&self) -> BlockHeight

Convenience method for obtaining the NU5 activation height for the network under test.

pub fn test_seed(&self) -> Option<&SecretVec<u8>>

Exposes the seed for the test wallet.

pub fn test_account( &self, ) -> Option<&TestAccount<<DataStore as WalletRead>::Account>>

Returns a reference to the test account, if one was configured.

pub fn test_account_sapling(&self) -> Option<&DiversifiableFullViewingKey>

Returns the test account’s Sapling DFVK, if one was configured.

pub fn test_account_orchard(&self) -> Option<&FullViewingKey>

Available on crate feature orchard only.

Returns the test account’s Orchard FVK, if one was configured.

pub fn create_account_from_test_seed( &mut self, account_name: &str, ) -> (<DataStore as WalletRead>::AccountId, UnifiedSpendingKey)

Creates a FURTHER account under the test seed, at the test account’s birthday, and returns its id and spending key.

The wallet assigns the next unused ZIP 32 account index, so this is a sibling of the account TestBuilder configured — the shape a test needs to check that some answer is scoped to the account it was asked of, rather than to the wallet.

Create every account a test needs BEFORE scanning anything: account creation adjusts the scan queue, which clears the wallet’s fully-scanned height.

pub fn cache(&self) -> &Cache::BlockSource

Available on crate feature unstable only.

Exposes an immutable reference to the test’s BlockSource.

pub fn latest_cached_block(&self) -> Option<&CachedBlock>

Returns the cached chain state corresponding to the latest block generated by this TestState.

pub fn generate_next_block<Fvk: TestFvk>( &mut self, recipient_fvk: &Fvk, recipient_address_type: AddressType, value: Zatoshis, ) -> (BlockHeight, Cache::InsertResult, Fvk::Nullifier)

Creates a fake block at the expected next height containing a single output of the given value, and inserts it into the cache.

This is a proxy for generate_next_block_multi.

pub fn generate_next_block_multi<Fvk: TestFvk>( &mut self, outputs: &[FakeCompactOutput<Fvk>], ) -> (BlockHeight, Cache::InsertResult, Vec<Fvk::Nullifier>)

Creates a fake block at the expected next height containing multiple outputs and inserts it into the cache.

pub fn generate_next_block_transparent( &mut self, vin: &[OutPoint], vout: &[(TransparentAddress, Zatoshis)], ) -> (BlockHeight, Cache::InsertResult, TxId)

Available on crate feature transparent-inputs only.

Adds a block at the next height containing a single transparent-only transaction that spends vin and creates an output of each (address, value) in vout, and inserts it into the cache.

The transaction is placed at index 1 within the block, behind a placeholder occupying the coinbase position, so that the outputs it creates are not subject to the coinbase maturity rule. Returns the height of the block and the id of the transparent transaction.

pub fn generate_empty_block(&mut self) -> (BlockHeight, Cache::InsertResult)

Adds an empty block to the cache, advancing the simulated chain height.

pub fn generate_block_at<Fvk: TestFvk>( &mut self, height: BlockHeight, prev_hash: BlockHash, outputs: &[FakeCompactOutput<Fvk>], initial_sapling_tree_size: u32, initial_orchard_tree_size: u32, initial_ironwood_tree_size: u32, allow_broken_hash_chain: bool, ) -> (Cache::InsertResult, Vec<Fvk::Nullifier>)

Creates a fake block with the given height and hash containing the requested outputs, and inserts it into the cache.

This generated block will be treated as the latest block, and subsequent calls to Self::generate_next_block will build on it.

pub fn generate_next_block_spending<Fvk: TestFvk>( &mut self, sender_fvk: &Fvk, note: (Fvk::Nullifier, Zatoshis), to: impl Into<Address>, value: Zatoshis, ) -> (BlockHeight, Cache::InsertResult)

Creates a fake block at the expected next height spending the given note, and inserts it into the cache.

pub fn generate_next_block_including( &mut self, txid: TxId, ) -> (BlockHeight, Cache::InsertResult)

Creates a fake block at the expected next height containing only the wallet transaction with the given txid, and inserts it into the cache.

This generated block will be treated as the latest block, and subsequent calls to Self::generate_next_block (or similar) will build on it.

pub fn generate_next_block_from_tx( &mut self, tx_index: usize, tx: &Transaction, ) -> (BlockHeight, Cache::InsertResult)

Creates a fake block at the expected next height containing only the given transaction, and inserts it into the cache.

This generated block will be treated as the latest block, and subsequent calls to Self::generate_next_block will build on it.

pub fn truncate_to_height(&mut self, height: BlockHeight)

Truncates the test wallet and block cache to the specified height, discarding all data from blocks at heights greater than the specified height, excluding transaction data that may not be recoverable from the chain.

pub fn truncate_to_height_retaining_cache(&mut self, height: BlockHeight)

Truncates the test wallet to the specified height, and resets the cache’s latest block height but does not truncate the block cache. This is useful for circumstances when you want to re-scan a set of cached blocks.

pub fn scan_cached_blocks( &mut self, from_height: BlockHeight, limit: usize, ) -> ScanSummary

Invokes scan_cached_blocks with the given arguments, expecting success.

pub fn try_scan_cached_blocks( &mut self, from_height: BlockHeight, limit: usize, ) -> Result<ScanSummary, Error<<DbT as WalletRead>::Error, <Cache::BlockSource as BlockSource>::Error>>

Invokes scan_cached_blocks with the given arguments.

pub fn try_scan_cached_blocks_with_state( &mut self, from_height: BlockHeight, from_state: &ChainState, limit: usize, ) -> Result<ScanSummary, Error<<DbT as WalletRead>::Error, <Cache::BlockSource as BlockSource>::Error>>

Invokes scan_cached_blocks with a caller-supplied from_state instead of deriving it from the block cache.

This is primarily useful for tests that need to drive WalletWrite::put_blocks with a from_state that is deliberately inconsistent with the wallet’s stored note commitment tree state, in order to exercise the resulting error paths.

pub fn put_subtree_roots( &mut self, sapling_start_index: u64, sapling_roots: &[CommitmentTreeRoot<Node>], orchard_start_index: u64, orchard_roots: &[CommitmentTreeRoot<MerkleHashOrchard>], ) -> Result<(), ShardTreeError<<DbT as WalletCommitmentTrees>::Error>>

Insert shard roots for both trees.

pub fn generate_and_scan_empty_blocks(&mut self, n: usize) -> BlockHeight

Generates n empty blocks, scans each, and returns the wallet’s resulting fully-scanned height.

This is the “let the chain advance” step of a test that needs the scanned region to reach a chosen depth above some earlier height — an anchor boundary a fixed number of blocks below the tip, say — with none of the intervening blocks carrying wallet-relevant data.

pub fn orchard_anchor_at( &mut self, height: BlockHeight, ) -> Result<Option<Anchor>, ShardTreeError<<DbT as WalletCommitmentTrees>::Error>>

Available on crate feature orchard only.

The root of the wallet’s own Orchard note commitment tree at the checkpoint height, as an anchor: the value a transaction proved against that height would have installed.

None when the tree holds no checkpoint there; the tree’s own error when it holds one but cannot complete a root over the shard data it retains.

pub fn create_standard_transaction( &mut self, from_account: &TestAccount<DbT::Account>, to: ZcashAddress, value: Zatoshis, ) -> Result<NonEmpty<TxId>, TransferErrT<DbT, GreedyInputSelector<DbT>, MultiOutputChangeStrategy<DbT>>>

pub fn spend<InputsT, ChangeT>( &mut self, input_selector: &InputsT, change_strategy: &ChangeT, usk: &UnifiedSpendingKey, request: TransactionRequest, ovk_policy: OvkPolicy, confirmations_policy: ConfirmationsPolicy, ) -> Result<NonEmpty<TxId>, TransferErrT<DbT, InputsT, ChangeT>>
where InputsT: InputSelector<InputSource = DbT>, ChangeT: ChangeStrategy<MetaSource = DbT>,

Prepares and executes the given zip321::TransactionRequest in a single step.

pub fn propose_transfer<InputsT, ChangeT>( &mut self, spend_from_account: <DbT as InputSource>::AccountId, input_selector: &InputsT, change_strategy: &ChangeT, request: TransactionRequest, confirmations_policy: ConfirmationsPolicy, ) -> Result<Proposal<ChangeT::FeeRule, <DbT as InputSource>::NoteRef>, ProposeTransferErrT<DbT, Infallible, InputsT, ChangeT>>
where InputsT: InputSelector<InputSource = DbT>, ChangeT: ChangeStrategy<MetaSource = DbT>,

Invokes propose_transfer with the given arguments.

pub fn propose_transfer_with_policy<InputsT, ChangeT>( &mut self, spend_from_account: <DbT as InputSource>::AccountId, input_selector: &InputsT, change_strategy: &ChangeT, request: TransactionRequest, confirmations_policy: ConfirmationsPolicy, spend_policy: &SpendPolicy, ) -> Result<Proposal<ChangeT::FeeRule, <DbT as InputSource>::NoteRef>, ProposeTransferErrT<DbT, Infallible, InputsT, ChangeT>>
where InputsT: InputSelector<InputSource = DbT>, ChangeT: ChangeStrategy<MetaSource = DbT>,

Invokes propose_transfer with the given arguments and an explicit SpendPolicy.

Unlike Self::propose_transfer, which always uses the default spend policy (every shielded pool, no transparent), this allows tests to opt in to spending the account’s transparent UTXOs or to restrict the shielded pools notes may be drawn from.

pub fn propose_send_max_transfer<FeeRuleT>( &mut self, spend_from_account: <DbT as InputSource>::AccountId, fee_rule: &FeeRuleT, to: ZcashAddress, memo: Option<MemoBytes>, mode: MaxSpendMode, confirmations_policy: ConfirmationsPolicy, ) -> Result<Proposal<FeeRuleT, <DbT as InputSource>::NoteRef>, ProposeSendMaxErrT<DbT, Infallible, FeeRuleT>>
where FeeRuleT: FeeRule + Clone,

Invokes propose_transfer with the given arguments.

pub fn propose_standard_transfer<CommitmentTreeErrT>( &mut self, spend_from_account: <DbT as InputSource>::AccountId, fee_rule: StandardFeeRule, confirmations_policy: ConfirmationsPolicy, to: &Address, amount: Zatoshis, memo: Option<MemoBytes>, change_memo: Option<MemoBytes>, fallback_change_pool: ShieldedPool, ) -> Result<Proposal<StandardFeeRule, <DbT as InputSource>::NoteRef>, ProposeTransferErrT<DbT, CommitmentTreeErrT, GreedyInputSelector<DbT>, SingleOutputChangeStrategy<DbT>>>

Invokes propose_standard_transfer_to_address with the given arguments.

pub fn propose_shielding<InputsT, ChangeT>( &mut self, input_selector: &InputsT, change_strategy: &ChangeT, shielding_threshold: Zatoshis, from_addrs: &[TransparentAddress], to_account: <InputsT::InputSource as InputSource>::AccountId, confirmations_policy: ConfirmationsPolicy, output_filter: CoinbaseFilter, ) -> Result<Proposal<ChangeT::FeeRule, Infallible>, ProposeShieldingErrT<DbT, Infallible, InputsT, ChangeT>>
where InputsT: ShieldingSelector<InputSource = DbT>, ChangeT: ChangeStrategy<MetaSource = DbT>,

Available on crate feature transparent-inputs only.

Invokes propose_shielding with the given arguments.

pub fn propose_shielding_coinbase<InputsT, FeeRuleT>( &mut self, input_selector: &InputsT, fee_rule: &FeeRuleT, shielding_threshold: Zatoshis, from_addrs: &[TransparentAddress], to_address: ZcashAddress, memo: Option<MemoBytes>, limit: Option<usize>, ) -> Result<Proposal<FeeRuleT, Infallible>, ProposeShieldingCoinbaseErrT<DbT, Infallible, InputsT, FeeRuleT>>
where InputsT: ShieldingSelector<InputSource = DbT>, FeeRuleT: FeeRule + Clone,

Available on crate feature transparent-inputs only.

Invokes propose_shielding_coinbase with the given arguments.

pub fn create_proposed_transactions<InputsErrT, FeeRuleT, ChangeErrT, N>( &mut self, usk: &UnifiedSpendingKey, ovk_policy: OvkPolicy, proposal: &Proposal<FeeRuleT, N>, ) -> Result<NonEmpty<TxId>, CreateErrT<DbT, InputsErrT, FeeRuleT, ChangeErrT, N>>
where FeeRuleT: FeeRule,

Invokes create_proposed_transactions with the given arguments.

pub fn create_pczt_from_proposal<InputsErrT, FeeRuleT, ChangeErrT>( &mut self, spend_from_account: <DbT as InputSource>::AccountId, ovk_policy: OvkPolicy, proposal: &Proposal<FeeRuleT, <DbT as InputSource>::NoteRef>, expiry_height: Option<BlockHeight>, ) -> Result<Pczt, CreateErrT<DbT, InputsErrT, FeeRuleT, ChangeErrT, DbT::NoteRef>>
where <DbT as WalletRead>::AccountId: Serialize, FeeRuleT: FeeRule,

Available on crate feature pczt only.

Invokes create_pczt_from_proposal with the given arguments.

pub fn extract_and_store_transaction_from_pczt( &mut self, pczt: Pczt, ) -> Result<TxId, ExtractErrT<DbT, DbT::NoteRef>>
where <DbT as WalletRead>::AccountId: DeserializeOwned,

Available on crate feature pczt only.

Invokes extract_and_store_transaction_from_pczt with the given arguments.

pub fn shield_transparent_funds<InputsT, ChangeT>( &mut self, input_selector: &InputsT, change_strategy: &ChangeT, shielding_threshold: Zatoshis, usk: &UnifiedSpendingKey, from_addrs: &[TransparentAddress], to_account: <DbT as InputSource>::AccountId, confirmations_policy: ConfirmationsPolicy, ) -> Result<NonEmpty<TxId>, ShieldErrT<DbT, InputsT, ChangeT>>
where InputsT: ShieldingSelector<InputSource = DbT>, ChangeT: ChangeStrategy<MetaSource = DbT>,

Available on crate feature transparent-inputs only.

Invokes shield_transparent_funds with the given arguments.

pub fn get_total_balance(&self, account: AccountIdT) -> Zatoshis

Returns the total balance in the given account at this point in the test.

pub fn get_locked_balance(&self, account: AccountIdT) -> Zatoshis

Returns the locked balance in the given account at this point in the test.

pub fn get_spendable_balance( &self, account: AccountIdT, confirmations_policy: ConfirmationsPolicy, ) -> Zatoshis

Returns the balance in the given account that is spendable with the given number of confirmations at this point in the test.

pub fn get_pending_shielded_balance( &self, account: AccountIdT, confirmations_policy: ConfirmationsPolicy, ) -> Zatoshis

Returns the balance in the given account that is detected but not yet spendable with the given number of confirmations at this point in the test.

pub fn get_pending_change( &self, account: AccountIdT, confirmations_policy: ConfirmationsPolicy, ) -> Zatoshis

Returns the amount of change in the given account that is not yet spendable with the given number of confirmations at this point in the test.

pub fn get_wallet_summary( &self, confirmations_policy: ConfirmationsPolicy, ) -> Option<WalletSummary<AccountIdT>>

Returns a summary of the wallet at this point in the test.

pub fn get_tx_from_history( &self, txid: TxId, ) -> Result<Option<TransactionSummary<AccountIdT>>, ErrT>

Returns a transaction from the history.

pub fn reset(&mut self) -> DbT::Handle

Resets the wallet using a new wallet database but with the same cache of blocks, and returns the old wallet database file.

This does not recreate accounts, nor does it rescan the cached blocks. The resulting wallet has no test account. Before using any generate_* method on the reset state, call reset_latest_cached_block().

Trait Implementations§

impl<T, C, D> Deref for TestScenario<T, C, D>
where T: ShieldedPoolTester, D: DataStoreFactory,

type Target = TestState<C, <D as DataStoreFactory>::DataStore, LocalNetwork>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, C, D> DerefMut for TestScenario<T, C, D>
where T: ShieldedPoolTester, D: DataStoreFactory,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Auto Trait Implementations§

impl<T, Cache, Dsf> Freeze for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: Freeze, PhantomData<T>: Freeze,

impl<T, Cache, Dsf> RefUnwindSafe for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: RefUnwindSafe, PhantomData<T>: RefUnwindSafe,

impl<T, Cache, Dsf> Send for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: Send, PhantomData<T>: Send,

impl<T, Cache, Dsf> Sync for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: Sync, PhantomData<T>: Sync,

impl<T, Cache, Dsf> Unpin for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: Unpin, PhantomData<T>: Unpin,

impl<T, Cache, Dsf> UnsafeUnpin for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: UnsafeUnpin, PhantomData<T>: UnsafeUnpin,

impl<T, Cache, Dsf> UnwindSafe for TestScenario<T, Cache, Dsf>
where TestState<Cache, <Dsf as DataStoreFactory>::DataStore, LocalNetwork>: UnwindSafe, PhantomData<T>: UnwindSafe,

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. 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

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastSend for T
where T: Any + Send,

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Sync + Send>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send> ⓘ

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.

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

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

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

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

fn into(self) -> U

Calls U::from(self).

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

impl<T> IntoEither for T

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

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<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> 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: '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: '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: '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: '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> PossiblyOption<T> for T

fn to_option(self) -> Option<T>

Convert this object into an Option<T>

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)

The target type on which the method may be called.

impl<T> Same for T

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(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Immutable access to the Borrow of a value. Read more

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

Mutable access to the BorrowMut 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(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

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

fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, 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> 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

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

type Error = !

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = >::Error

The type returned in the event of a conversion error.

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

Performs the conversion.

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