Struct tetcore_test_client::client::Client [−][src]
Tetcore Client
Implementations
impl<B, E, Block, RA> Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
<Block as Block>::Header: Clone,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
<Block as Block>::Header: Clone,
pub fn new(
backend: Arc<B>,
executor: E,
build_genesis_storage: &dyn BuildStorage,
fork_blocks: Option<Vec<(<<Block as Block>::Header as Header>::Number, <Block as Block>::Hash), Global>>,
bad_blocks: Option<HashSet<<Block as Block>::Hash, RandomState>>,
execution_extensions: ExecutionExtensions<Block>,
prometheus_registry: Option<Registry>,
config: ClientConfig
) -> Result<Client<B, E, Block, RA>, Error>
[src]
backend: Arc<B>,
executor: E,
build_genesis_storage: &dyn BuildStorage,
fork_blocks: Option<Vec<(<<Block as Block>::Header as Header>::Number, <Block as Block>::Hash), Global>>,
bad_blocks: Option<HashSet<<Block as Block>::Hash, RandomState>>,
execution_extensions: ExecutionExtensions<Block>,
prometheus_registry: Option<Registry>,
config: ClientConfig
) -> Result<Client<B, E, Block, RA>, Error>
Creates new Tetcore Client with given blockchain and code executor.
pub fn import_notification_sinks(
&self
) -> &Mutex<RawMutex, Vec<TracingUnboundedSender<BlockImportNotification<Block>>, Global>>
[src]
&self
) -> &Mutex<RawMutex, Vec<TracingUnboundedSender<BlockImportNotification<Block>>, Global>>
returns a reference to the block import notification sinks useful for test environments.
pub fn finality_notification_sinks(
&self
) -> &Mutex<RawMutex, Vec<TracingUnboundedSender<FinalityNotification<Block>>, Global>>
[src]
&self
) -> &Mutex<RawMutex, Vec<TracingUnboundedSender<FinalityNotification<Block>>, Global>>
returns a reference to the finality notification sinks useful for test environments.
pub fn state_at(
&self,
block: &BlockId<Block>
) -> Result<<B as Backend<Block>>::State, Error>
[src]
&self,
block: &BlockId<Block>
) -> Result<<B as Backend<Block>>::State, Error>
Get a reference to the state at a given block.
pub fn code_at(&self, id: &BlockId<Block>) -> Result<Vec<u8, Global>, Error>
[src]
Get the code at a given block.
pub fn runtime_version_at(
&self,
id: &BlockId<Block>
) -> Result<RuntimeVersion, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<RuntimeVersion, Error>
Get the RuntimeVersion at a given block.
pub fn header_proof_with_cht_size(
&self,
id: &BlockId<Block>,
cht_size: <<Block as Block>::Header as Header>::Number
) -> Result<(<Block as Block>::Header, StorageProof), Error>
[src]
&self,
id: &BlockId<Block>,
cht_size: <<Block as Block>::Header as Header>::Number
) -> Result<(<Block as Block>::Header, StorageProof), Error>
Reads given header and generates CHT-based header proof for CHT of given size.
pub fn key_changes_proof_with_cht_size(
&self,
first: <Block as Block>::Hash,
last: <Block as Block>::Hash,
min: <Block as Block>::Hash,
max: <Block as Block>::Hash,
storage_key: Option<&PrefixedStorageKey>,
key: &StorageKey,
cht_size: <<Block as Block>::Header as Header>::Number
) -> Result<ChangesProof<<Block as Block>::Header>, Error>
[src]
&self,
first: <Block as Block>::Hash,
last: <Block as Block>::Hash,
min: <Block as Block>::Hash,
max: <Block as Block>::Hash,
storage_key: Option<&PrefixedStorageKey>,
key: &StorageKey,
cht_size: <<Block as Block>::Header as Header>::Number
) -> Result<ChangesProof<<Block as Block>::Header>, Error>
Does the same work as key_changes_proof
, but assumes that CHTs are of passed size.
pub fn revert(
&self,
n: <<Block as Block>::Header as Header>::Number
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
[src]
&self,
n: <<Block as Block>::Header as Header>::Number
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
Attempts to revert the chain by n
blocks guaranteeing that no block is
reverted past the last finalized block. Returns the number of blocks
that were successfully reverted.
pub fn unsafe_revert(
&mut self,
n: <<Block as Block>::Header as Header>::Number,
blacklist: bool
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
[src]
&mut self,
n: <<Block as Block>::Header as Header>::Number,
blacklist: bool
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
Attempts to revert the chain by n
blocks disregarding finality. This method will revert
any finalized blocks as requested and can potentially leave the node in an inconsistent
state. Other modules in the system that persist data and that rely on finality
(e.g. consensus parts) will be unaffected by the revert. Use this method with caution and
making sure that no other data needs to be reverted for consistency aside from the block
data. If blacklist
is set to true, will also blacklist reverted blocks from finalizing
again. The blacklist is reset upon client restart.
Returns the number of blocks that were successfully reverted.
pub fn chain_info(&self) -> Info<Block>
[src]
Get blockchain info.
pub fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error>
[src]
Get block status.
pub fn header(
&self,
id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>
Get block header by id.
pub fn body(
&self,
id: &BlockId<Block>
) -> Result<Option<Vec<<Block as Block>::Extrinsic, Global>>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<Vec<<Block as Block>::Extrinsic, Global>>, Error>
Get block body by id.
pub fn uncles(
&self,
target_hash: <Block as Block>::Hash,
max_generation: <<Block as Block>::Header as Header>::Number
) -> Result<Vec<<Block as Block>::Hash, Global>, Error>
[src]
&self,
target_hash: <Block as Block>::Hash,
max_generation: <<Block as Block>::Header as Header>::Number
) -> Result<Vec<<Block as Block>::Hash, Global>, Error>
Gets the uncles of the block with target_hash
going back max_generation
ancestors.
Trait Implementations
impl<B, E, Block, RA> AuxStore for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
pub fn insert_aux<'a, 'b, 'c, I, D>(
&self,
insert: I,
delete: D
) -> Result<(), Error> where
'b: 'a,
'c: 'a,
I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
D: IntoIterator<Item = &'a &'b [u8]>,
[src]
&self,
insert: I,
delete: D
) -> Result<(), Error> where
'b: 'a,
'c: 'a,
I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
D: IntoIterator<Item = &'a &'b [u8]>,
Insert auxiliary data into key-value store.
pub fn get_aux(&self, key: &[u8]) -> Result<Option<Vec<u8, Global>>, Error>
[src]
Query auxiliary data from key-value store.
impl<'_, B, E, Block, RA> AuxStore for &'_ Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
pub fn insert_aux<'a, 'b, 'c, I, D>(
&self,
insert: I,
delete: D
) -> Result<(), Error> where
'b: 'a,
'c: 'a,
I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
D: IntoIterator<Item = &'a &'b [u8]>,
[src]
&self,
insert: I,
delete: D
) -> Result<(), Error> where
'b: 'a,
'c: 'a,
I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
D: IntoIterator<Item = &'a &'b [u8]>,
pub fn get_aux(&self, key: &[u8]) -> Result<Option<Vec<u8, Global>>, Error>
[src]
impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn block_body(
&self,
id: &BlockId<Block>
) -> Result<Option<Vec<<Block as Block>::Extrinsic, Global>>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<Vec<<Block as Block>::Extrinsic, Global>>, Error>
pub fn block(
&self,
id: &BlockId<Block>
) -> Result<Option<SignedBlock<Block>>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<SignedBlock<Block>>, Error>
pub fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error>
[src]
pub fn justification(
&self,
id: &BlockId<Block>
) -> Result<Option<Vec<u8, Global>>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<Vec<u8, Global>>, Error>
pub fn block_hash(
&self,
number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>
impl<B, E, Block, RA> BlockBuilderProvider<B, Block, Client<B, E, Block, RA>> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block> + Send + Sync + 'static,
B: Backend<Block> + Send + Sync + 'static,
Client<B, E, Block, RA>: HeaderBackend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: BlockBuilder<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
[src]
Block: Block,
E: CallExecutor<Block> + Send + Sync + 'static,
B: Backend<Block> + Send + Sync + 'static,
Client<B, E, Block, RA>: HeaderBackend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: BlockBuilder<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
pub fn new_block_at<R>(
&self,
parent: &BlockId<Block>,
inherent_digests: Digest<<<Block as Block>::Header as Header>::Hash>,
record_proof: R
) -> Result<BlockBuilder<'_, Block, Client<B, E, Block, RA>, B>, Error> where
R: Into<RecordProof>,
[src]
&self,
parent: &BlockId<Block>,
inherent_digests: Digest<<<Block as Block>::Header as Header>::Hash>,
record_proof: R
) -> Result<BlockBuilder<'_, Block, Client<B, E, Block, RA>, B>, Error> where
R: Into<RecordProof>,
pub fn new_block(
&self,
inherent_digests: Digest<<<Block as Block>::Header as Header>::Hash>
) -> Result<BlockBuilder<'_, Block, Client<B, E, Block, RA>, B>, Error>
[src]
&self,
inherent_digests: Digest<<<Block as Block>::Header as Header>::Hash>
) -> Result<BlockBuilder<'_, Block, Client<B, E, Block, RA>, B>, Error>
impl<B, E, Block, RA> BlockIdTo<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
RA: Send + Sync,
[src]
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
RA: Send + Sync,
type Error = Error
The error type that will be returned by the functions.
pub fn to_hash(
&self,
block_id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
block_id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn to_number(
&self,
block_id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
[src]
&self,
block_id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
impl<'_, B, E, Block, RA> BlockImport<Block> for &'_ Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State,
[src]
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State,
NOTE: only use this implementation when you are sure there are NO consensus-level BlockImport objects. Otherwise, importing blocks directly into the client would be bypassing important verification work.
type Error = Error
The error type.
type Transaction = <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction
The transaction type used by the backend.
pub fn import_block(
&mut self,
import_block: BlockImportParams<Block, <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction>,
new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Result<ImportResult, <&'_ Client<B, E, Block, RA> as BlockImport<Block>>::Error>
[src]
&mut self,
import_block: BlockImportParams<Block, <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction>,
new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Result<ImportResult, <&'_ Client<B, E, Block, RA> as BlockImport<Block>>::Error>
Import a checked and validated block. If a justification is provided in
BlockImportParams
then finalized
must be true.
NOTE: only use this implementation when there are NO consensus-level BlockImport objects. Otherwise, importing blocks directly into the client would be bypassing important verification work.
If you are not sure that there are no BlockImport objects provided by the consensus algorithm, don’t use this function.
pub fn check_block(
&mut self,
block: BlockCheckParams<Block>
) -> Result<ImportResult, <&'_ Client<B, E, Block, RA> as BlockImport<Block>>::Error>
[src]
&mut self,
block: BlockCheckParams<Block>
) -> Result<ImportResult, <&'_ Client<B, E, Block, RA> as BlockImport<Block>>::Error>
Check block preconditions.
impl<B, E, Block, RA> BlockImport<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State,
[src]
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: Core<Block>,
<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: ApiExt<Block>,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiErrorExt>::Error == Error,
<<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api as ApiExt<Block>>::StateBackend == <B as Backend<Block>>::State,
type Error = Error
The error type.
type Transaction = <<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction
The transaction type used by the backend.
pub fn import_block(
&mut self,
import_block: BlockImportParams<Block, <Client<B, E, Block, RA> as BlockImport<Block>>::Transaction>,
new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Result<ImportResult, <Client<B, E, Block, RA> as BlockImport<Block>>::Error>
[src]
&mut self,
import_block: BlockImportParams<Block, <Client<B, E, Block, RA> as BlockImport<Block>>::Transaction>,
new_cache: HashMap<[u8; 4], Vec<u8, Global>, RandomState>
) -> Result<ImportResult, <Client<B, E, Block, RA> as BlockImport<Block>>::Error>
pub fn check_block(
&mut self,
block: BlockCheckParams<Block>
) -> Result<ImportResult, <Client<B, E, Block, RA> as BlockImport<Block>>::Error>
[src]
&mut self,
block: BlockCheckParams<Block>
) -> Result<ImportResult, <Client<B, E, Block, RA> as BlockImport<Block>>::Error>
impl<B, E, Block, RA> BlockOf for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
type Type = Block
The type of the block.
impl<B, E, Block, RA> BlockchainEvents<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
pub fn import_notification_stream(
&self
) -> TracingUnboundedReceiver<BlockImportNotification<Block>>
[src]
&self
) -> TracingUnboundedReceiver<BlockImportNotification<Block>>
Get block import event stream.
pub fn finality_notification_stream(
&self
) -> TracingUnboundedReceiver<FinalityNotification<Block>>
[src]
&self
) -> TracingUnboundedReceiver<FinalityNotification<Block>>
pub fn storage_changes_notification_stream(
&self,
filter_keys: Option<&[StorageKey]>,
child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey, Global>>)]>
) -> Result<TracingUnboundedReceiver<(<Block as Block>::Hash, StorageChangeSet)>, Error>
[src]
&self,
filter_keys: Option<&[StorageKey]>,
child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey, Global>>)]>
) -> Result<TracingUnboundedReceiver<(<Block as Block>::Hash, StorageChangeSet)>, Error>
Get storage changes event stream.
impl<B, E, Block, RA> CallApiAt<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block, Backend = B> + Send + Sync,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block, Backend = B> + Send + Sync,
B: Backend<Block>,
type Error = Error
Error type used by the implementation.
type StateBackend = <B as Backend<Block>>::State
The state backend that is used to store the block states.
pub fn call_api_at<R, NC, C>(
&self,
params: CallApiAtParams<'a, Block, C, NC, <B as Backend<Block>>::State>
) -> Result<NativeOrEncoded<R>, Error> where
C: Core<Block, Error = Error>,
R: Encode + Decode + PartialEq<R>,
NC: FnOnce() -> Result<R, String> + UnwindSafe,
[src]
&self,
params: CallApiAtParams<'a, Block, C, NC, <B as Backend<Block>>::State>
) -> Result<NativeOrEncoded<R>, Error> where
C: Core<Block, Error = Error>,
R: Encode + Decode + PartialEq<R>,
NC: FnOnce() -> Result<R, String> + UnwindSafe,
pub fn runtime_version_at(
&self,
at: &BlockId<Block>
) -> Result<RuntimeVersion, Error>
[src]
&self,
at: &BlockId<Block>
) -> Result<RuntimeVersion, Error>
impl<BE, E, B, RA> Chain<B> for Client<BE, E, B, RA> where
E: CallExecutor<B>,
B: Block,
BE: Backend<B>,
[src]
E: CallExecutor<B>,
B: Block,
BE: Backend<B>,
pub fn block_status(
&self,
id: &BlockId<B>
) -> Result<BlockStatus, Box<dyn Error + 'static + Send, Global>>
[src]
&self,
id: &BlockId<B>
) -> Result<BlockStatus, Box<dyn Error + 'static + Send, Global>>
impl<B, E, RA, Block: BlockT> ClientBlockImportExt<Block> for Client<B, E, Block, RA> where
Self: BlockImport<Block, Error = ConsensusError>,
[src]
Self: BlockImport<Block, Error = ConsensusError>,
fn import(
&mut self,
origin: BlockOrigin,
block: Block
) -> Result<(), ConsensusError>
[src]
&mut self,
origin: BlockOrigin,
block: Block
) -> Result<(), ConsensusError>
fn import_as_best(
&mut self,
origin: BlockOrigin,
block: Block
) -> Result<(), ConsensusError>
[src]
&mut self,
origin: BlockOrigin,
block: Block
) -> Result<(), ConsensusError>
fn import_as_final(
&mut self,
origin: BlockOrigin,
block: Block
) -> Result<(), ConsensusError>
[src]
&mut self,
origin: BlockOrigin,
block: Block
) -> Result<(), ConsensusError>
fn import_justified(
&mut self,
origin: BlockOrigin,
block: Block,
justification: Justification
) -> Result<(), ConsensusError>
[src]
&mut self,
origin: BlockOrigin,
block: Block,
justification: Justification
) -> Result<(), ConsensusError>
impl<B, E, RA, Block> ClientExt<Block> for Client<B, E, Block, RA> where
B: Backend<Block>,
E: CallExecutor<Block> + 'static,
Self: BlockImport<Block, Error = ConsensusError>,
Block: BlockT,
[src]
B: Backend<Block>,
E: CallExecutor<Block> + 'static,
Self: BlockImport<Block, Error = ConsensusError>,
Block: BlockT,
fn finalize_block(
&self,
id: BlockId<Block>,
justification: Option<Justification>
) -> Result<()>
[src]
&self,
id: BlockId<Block>,
justification: Option<Justification>
) -> Result<()>
fn genesis_hash(&self) -> <Block as BlockT>::Hash
[src]
impl<B, E, Block, RA> ExecutorProvider<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
type Executor = E
executor instance
pub fn executor(
&self
) -> &<Client<B, E, Block, RA> as ExecutorProvider<Block>>::Executor
[src]
&self
) -> &<Client<B, E, Block, RA> as ExecutorProvider<Block>>::Executor
pub fn execution_extensions(&self) -> &ExecutionExtensions<Block>
[src]
impl<B, E, Block, RA> Finalizer<Block, B> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn apply_finality(
&self,
operation: &mut ClientImportOperation<Block, B>,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
[src]
&self,
operation: &mut ClientImportOperation<Block, B>,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
pub fn finalize_block(
&self,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
[src]
&self,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
impl<'_, B, E, Block, RA> Finalizer<Block, B> for &'_ Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn apply_finality(
&self,
operation: &mut ClientImportOperation<Block, B>,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
[src]
&self,
operation: &mut ClientImportOperation<Block, B>,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
pub fn finalize_block(
&self,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
[src]
&self,
id: BlockId<Block>,
justification: Option<Vec<u8, Global>>,
notify: bool
) -> Result<(), Error>
impl<B, E, Block, RA> HeaderBackend<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
RA: Send + Sync,
[src]
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
RA: Send + Sync,
pub fn header(
&self,
id: BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>
[src]
&self,
id: BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>
pub fn info(&self) -> Info<Block>
[src]
pub fn status(&self, id: BlockId<Block>) -> Result<BlockStatus, Error>
[src]
pub fn number(
&self,
hash: <Block as Block>::Hash
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
[src]
&self,
hash: <Block as Block>::Hash
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
pub fn hash(
&self,
number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn block_hash_from_id(
&self,
id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn block_number_from_id(
&self,
id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
pub fn expect_header(
&self,
id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>
[src]
&self,
id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>
pub fn expect_block_number_from_id(
&self,
id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
pub fn expect_block_hash_from_id(
&self,
id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>
impl<'_, B, E, Block, RA> HeaderBackend<Block> for &'_ Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
RA: Send + Sync,
[src]
Block: Block,
E: CallExecutor<Block> + Send + Sync,
B: Backend<Block>,
RA: Send + Sync,
pub fn header(
&self,
id: BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>
[src]
&self,
id: BlockId<Block>
) -> Result<Option<<Block as Block>::Header>, Error>
pub fn info(&self) -> Info<Block>
[src]
pub fn status(&self, id: BlockId<Block>) -> Result<BlockStatus, Error>
[src]
pub fn number(
&self,
hash: <Block as Block>::Hash
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
[src]
&self,
hash: <Block as Block>::Hash
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
pub fn hash(
&self,
number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
number: <<Block as Block>::Header as Header>::Number
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn block_hash_from_id(
&self,
id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn block_number_from_id(
&self,
id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<Option<<<Block as Block>::Header as Header>::Number>, Error>
pub fn expect_header(
&self,
id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>
[src]
&self,
id: BlockId<Block>
) -> Result<<Block as Block>::Header, Error>
pub fn expect_block_number_from_id(
&self,
id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<<<Block as Block>::Header as Header>::Number, Error>
pub fn expect_block_hash_from_id(
&self,
id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<<Block as Block>::Hash, Error>
impl<B, E, Block, RA> HeaderMetadata<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
type Error = Error
Error used in case the header metadata is not found.
pub fn header_metadata(
&self,
hash: <Block as Block>::Hash
) -> Result<CachedHeaderMetadata<Block>, <Client<B, E, Block, RA> as HeaderMetadata<Block>>::Error>
[src]
&self,
hash: <Block as Block>::Hash
) -> Result<CachedHeaderMetadata<Block>, <Client<B, E, Block, RA> as HeaderMetadata<Block>>::Error>
pub fn insert_header_metadata(
&self,
hash: <Block as Block>::Hash,
metadata: CachedHeaderMetadata<Block>
)
[src]
&self,
hash: <Block as Block>::Hash,
metadata: CachedHeaderMetadata<Block>
)
pub fn remove_header_metadata(&self, hash: <Block as Block>::Hash)
[src]
impl<'_, B, E, Block, RA> LockImportRun<Block, B> for &'_ Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err> where
Err: From<Error>,
F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
[src]
Err: From<Error>,
F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err> where
Err: From<Error>,
F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
[src]
Err: From<Error>,
F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
impl<B, E, Block, RA> ProofProvider<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn read_proof(
&self,
id: &BlockId<Block>,
keys: &mut dyn Iterator<Item = &[u8]>
) -> Result<StorageProof, Error>
[src]
&self,
id: &BlockId<Block>,
keys: &mut dyn Iterator<Item = &[u8]>
) -> Result<StorageProof, Error>
pub fn read_child_proof(
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
keys: &mut dyn Iterator<Item = &[u8]>
) -> Result<StorageProof, Error>
[src]
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
keys: &mut dyn Iterator<Item = &[u8]>
) -> Result<StorageProof, Error>
pub fn execution_proof(
&self,
id: &BlockId<Block>,
method: &str,
call_data: &[u8]
) -> Result<(Vec<u8, Global>, StorageProof), Error>
[src]
&self,
id: &BlockId<Block>,
method: &str,
call_data: &[u8]
) -> Result<(Vec<u8, Global>, StorageProof), Error>
pub fn header_proof(
&self,
id: &BlockId<Block>
) -> Result<(<Block as Block>::Header, StorageProof), Error>
[src]
&self,
id: &BlockId<Block>
) -> Result<(<Block as Block>::Header, StorageProof), Error>
pub fn key_changes_proof(
&self,
first: <Block as Block>::Hash,
last: <Block as Block>::Hash,
min: <Block as Block>::Hash,
max: <Block as Block>::Hash,
storage_key: Option<&PrefixedStorageKey>,
key: &StorageKey
) -> Result<ChangesProof<<Block as Block>::Header>, Error>
[src]
&self,
first: <Block as Block>::Hash,
last: <Block as Block>::Hash,
min: <Block as Block>::Hash,
max: <Block as Block>::Hash,
storage_key: Option<&PrefixedStorageKey>,
key: &StorageKey
) -> Result<ChangesProof<<Block as Block>::Header>, Error>
impl<B, E, Block, RA> ProvideCache<Block> for Client<B, E, Block, RA> where
Block: Block,
B: Backend<Block>,
[src]
Block: Block,
B: Backend<Block>,
impl<B, E, Block, RA> ProvideRuntimeApi<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block, Backend = B> + Send + Sync,
B: Backend<Block>,
RA: ConstructRuntimeApi<Block, Client<B, E, Block, RA>>,
[src]
Block: Block,
E: CallExecutor<Block, Backend = B> + Send + Sync,
B: Backend<Block>,
RA: ConstructRuntimeApi<Block, Client<B, E, Block, RA>>,
type Api = <RA as ConstructRuntimeApi<Block, Client<B, E, Block, RA>>>::RuntimeApi
The concrete type that provides the api.
pub fn runtime_api(
&'a self
) -> ApiRef<'a, <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api>
[src]
&'a self
) -> ApiRef<'a, <Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api>
impl<B, E, Block, RA> ProvideUncles<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn uncles(
&self,
target_hash: <Block as Block>::Hash,
max_generation: <<Block as Block>::Header as Header>::Number
) -> Result<Vec<<Block as Block>::Header, Global>, Error>
[src]
&self,
target_hash: <Block as Block>::Hash,
max_generation: <<Block as Block>::Header as Header>::Number
) -> Result<Vec<<Block as Block>::Header, Global>, Error>
impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn storage_keys(
&self,
id: &BlockId<Block>,
key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>
[src]
&self,
id: &BlockId<Block>,
key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>
pub fn storage_pairs(
&self,
id: &BlockId<Block>,
key_prefix: &StorageKey
) -> Result<Vec<(StorageKey, StorageData), Global>, Error>
[src]
&self,
id: &BlockId<Block>,
key_prefix: &StorageKey
) -> Result<Vec<(StorageKey, StorageData), Global>, Error>
pub fn storage_keys_iter(
&self,
id: &BlockId<Block>,
prefix: Option<&'a StorageKey>,
start_key: Option<&StorageKey>
) -> Result<KeyIterator<'a, <B as Backend<Block>>::State, Block>, Error>
[src]
&self,
id: &BlockId<Block>,
prefix: Option<&'a StorageKey>,
start_key: Option<&StorageKey>
) -> Result<KeyIterator<'a, <B as Backend<Block>>::State, Block>, Error>
pub fn storage(
&self,
id: &BlockId<Block>,
key: &StorageKey
) -> Result<Option<StorageData>, Error>
[src]
&self,
id: &BlockId<Block>,
key: &StorageKey
) -> Result<Option<StorageData>, Error>
pub fn storage_hash(
&self,
id: &BlockId<Block>,
key: &StorageKey
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
id: &BlockId<Block>,
key: &StorageKey
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn child_storage_keys(
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>
[src]
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
key_prefix: &StorageKey
) -> Result<Vec<StorageKey, Global>, Error>
pub fn child_storage(
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
key: &StorageKey
) -> Result<Option<StorageData>, Error>
[src]
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
key: &StorageKey
) -> Result<Option<StorageData>, Error>
pub fn child_storage_hash(
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
key: &StorageKey
) -> Result<Option<<Block as Block>::Hash>, Error>
[src]
&self,
id: &BlockId<Block>,
child_info: &ChildInfo,
key: &StorageKey
) -> Result<Option<<Block as Block>::Hash>, Error>
pub fn max_key_changes_range(
&self,
first: <<Block as Block>::Header as Header>::Number,
last: BlockId<Block>
) -> Result<Option<(<<Block as Block>::Header as Header>::Number, BlockId<Block>)>, Error>
[src]
&self,
first: <<Block as Block>::Header as Header>::Number,
last: BlockId<Block>
) -> Result<Option<(<<Block as Block>::Header as Header>::Number, BlockId<Block>)>, Error>
pub fn key_changes(
&self,
first: <<Block as Block>::Header as Header>::Number,
last: BlockId<Block>,
storage_key: Option<&PrefixedStorageKey>,
key: &StorageKey
) -> Result<Vec<(<<Block as Block>::Header as Header>::Number, u32), Global>, Error>
[src]
&self,
first: <<Block as Block>::Header as Header>::Number,
last: BlockId<Block>,
storage_key: Option<&PrefixedStorageKey>,
key: &StorageKey
) -> Result<Vec<(<<Block as Block>::Header as Header>::Number, u32), Global>, Error>
impl<B, E, Block, RA> UsageProvider<Block> for Client<B, E, Block, RA> where
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
[src]
Block: Block,
E: CallExecutor<Block>,
B: Backend<Block>,
pub fn usage_info(&self) -> ClientInfo<Block>
[src]
Get usage info about current client.
Auto Trait Implementations
impl<B, E, Block, RA> !RefUnwindSafe for Client<B, E, Block, RA>
impl<B, E, Block, RA> Send for Client<B, E, Block, RA> where
B: Send + Sync,
E: Send,
RA: Send,
B: Send + Sync,
E: Send,
RA: Send,
impl<B, E, Block, RA> Sync for Client<B, E, Block, RA> where
B: Send + Sync,
E: Sync,
RA: Sync,
B: Send + Sync,
E: Sync,
RA: Sync,
impl<B, E, Block, RA> Unpin for Client<B, E, Block, RA> where
E: Unpin,
RA: Unpin,
<Block as Block>::Hash: Unpin,
<<Block as Block>::Header as Header>::Number: Unpin,
E: Unpin,
RA: Unpin,
<Block as Block>::Hash: Unpin,
<<Block as Block>::Header as Header>::Number: Unpin,
impl<B, E, Block, RA> !UnwindSafe for Client<B, E, Block, RA>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<C, B> BlockchainEventsExt<C, B> for C where
C: BlockchainEvents<B>,
B: Block,
[src]
C: BlockchainEvents<B>,
B: Block,
pub fn wait_for_blocks(
&Self,
usize
) -> Pin<Box<dyn Future<Output = ()> + 'static + Send, Global>>
[src]
&Self,
usize
) -> Pin<Box<dyn Future<Output = ()> + 'static + Send, Global>>
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> CheckedConversion for T
[src]
pub fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,
[src]
Self: TryFrom<T>,
pub fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,
[src]
Self: TryInto<T>,
impl<Block, T> Client<Block> for T where
Block: Block,
T: HeaderBackend<Block> + ProofProvider<Block> + BlockIdTo<Block, Error = Error> + BlockBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync,
Block: Block,
T: HeaderBackend<Block> + ProofProvider<Block> + BlockIdTo<Block, Error = Error> + BlockBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync,
impl<Block, BE, T> ClientForGrandpa<Block, BE> for T where
Block: Block,
T: LockImportRun<Block, BE> + Finalizer<Block, BE> + AuxStore + HeaderMetadata<Block, Error = Error> + HeaderBackend<Block> + BlockchainEvents<Block> + ProvideRuntimeApi<Block> + ExecutorProvider<Block> + BlockImport<Block, Transaction = <<BE as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction, Error = Error>,
BE: Backend<Block>,
Block: Block,
T: LockImportRun<Block, BE> + Finalizer<Block, BE> + AuxStore + HeaderMetadata<Block, Error = Error> + HeaderBackend<Block> + BlockchainEvents<Block> + ProvideRuntimeApi<Block> + ExecutorProvider<Block> + BlockImport<Block, Transaction = <<BE as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction, Error = Error>,
BE: Backend<Block>,
impl<T> Downcast for T where
T: Any,
T: Any,
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn as_any(&self) -> &(dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
impl<T> DowncastSync for T where
T: Any + Send + Sync,
T: Any + Send + Sync,
impl<T> From<T> for T
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, Outer> IsWrappedBy<Outer> for T where
T: From<Outer>,
Outer: AsRef<T> + AsMut<T> + From<T>,
[src]
T: From<Outer>,
Outer: AsRef<T> + AsMut<T> + From<T>,
pub fn from_ref(outer: &Outer) -> &T
[src]
Get a reference to the inner from the outer.
pub fn from_mut(outer: &mut Outer) -> &mut T
[src]
Get a mutable reference to the inner from the outer.
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> SaturatedConversion for T
pub fn saturated_from<T>(t: T) -> Self where
Self: UniqueSaturatedFrom<T>,
Self: UniqueSaturatedFrom<T>,
pub fn saturated_into<T>(self) -> T where
Self: UniqueSaturatedInto<T>,
Self: UniqueSaturatedInto<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<S, T> UncheckedInto<T> for S where
T: UncheckedFrom<S>,
[src]
T: UncheckedFrom<S>,
pub fn unchecked_into(self) -> T
[src]
impl<T, S> UniqueSaturatedInto<T> for S where
T: Bounded,
S: TryInto<T>,
T: Bounded,
S: TryInto<T>,
pub fn unique_saturated_into(self) -> T
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,
pub fn vzip(self) -> V
impl<T> WithSubscriber for T
[src]
pub fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
[src]
S: Into<Dispatch>,