## AddToSignaturePayload

# Struct AddToSignaturePayload

Source

    pub struct AddToSignaturePayload;

## Trait Implementations§

Source§

### impl Clone for AddToSignaturePayload

Source§

#### fn clone(&self) -> AddToSignaturePayload

Returns a duplicate 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 Debug for AddToSignaturePayload

Source§

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

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

### impl Decode for AddToSignaturePayload

Source§

#### fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.
§

#### fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>
where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

#### fn skip<I>(input: &mut I) -> Result<(), Error>
where I: Input,

Attempt to skip the encoded value from input. Read more
§

#### fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
Source§

### impl Encode for AddToSignaturePayload

Source§

#### fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
Source§

#### fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.
§

#### fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
§

#### fn using_encoded<R, F>(&self, f: F) -> R
where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.
§

#### fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
Source§

### impl PartialEq for AddToSignaturePayload

Source§

#### fn eq(&self, other: &AddToSignaturePayload) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

#### fn ne(&self, other: &Rhs) -> bool

Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

### impl<Call: Dispatchable> TransactionExtension<Call> for AddToSignaturePayload

Source§

#### const IDENTIFIER: &'static str = "AddToSignaturePayload"

Unique identifier of this signed extension. Read more
Source§

#### type Implicit = u32

Any additional data which was known at the time of transaction construction and can be useful in authenticating the transaction. This is determined dynamically in part from the on-chain environment using the `implicit` function and not directly contained in the transaction itself and therefore is considered “implicit”.
Source§

#### type Pre = ()

The type that encodes information that can be passed from `prepare` to `post_dispatch`.
Source§

#### type Val = ()

The type that encodes information that can be passed from `validate` to `prepare`.
Source§

#### fn implicit(&self) -> Result<Self::Implicit, TransactionValidityError>

Determine any additional data which was known at the time of transaction construction and can be useful in authenticating the transaction. The expected usage of this is to include in any data which is signed and verified as part of transaction validation. Also perform any pre-signature-verification checks and return an error if needed.
Source§

#### fn weight(&self, _call: &Call) -> Weight

The weight consumed by executing this extension instance fully during transaction dispatch.
Source§

#### fn validate( &self, origin: DispatchOriginOf<Call>, _call: &Call, _info: &DispatchInfoOf<Call>, _len: usize, _self_implicit: Self::Implicit, _inherited_implication: &impl Encode, _source: TransactionSource, ) -> ValidateResult<Self::Val, Call>

Validate a transaction for the transaction queue. Read more
Source§

#### fn prepare( self, _val: Self::Val, _origin: &DispatchOriginOf<Call>, _call: &Call, _info: &DispatchInfoOf<Call>, _len: usize, ) -> Result<Self::Pre, TransactionValidityError>

Do any pre-flight stuff for a transaction after validation. Read more
§

#### fn metadata() -> Vec<TransactionExtensionMetadata>

Returns the metadata for this extension. Read more
§

#### fn post_dispatch_details( _pre: Self::Pre, _info: &<Call as Dispatchable>::Info, _post_info: &<Call as Dispatchable>::PostInfo, _len: usize, _result: &Result<(), DispatchError>, ) -> Result<Weight, TransactionValidityError>

Do any post-flight stuff for an extrinsic. Read more
§

#### fn post_dispatch( pre: Self::Pre, info: &<Call as Dispatchable>::Info, post_info: &mut <Call as Dispatchable>::PostInfo, len: usize, result: &Result<(), DispatchError>, ) -> Result<(), TransactionValidityError>

A wrapper for `post_dispatch_details` that refunds the unspent weight consumed by this extension into the post dispatch information. Read more
§

#### fn bare_validate( _call: &Call, _info: &<Call as Dispatchable>::Info, _len: usize, ) -> Result<ValidTransaction, TransactionValidityError>

Validation logic for bare extrinsics. Read more
§

#### fn bare_validate_and_prepare( _call: &Call, _info: &<Call as Dispatchable>::Info, _len: usize, ) -> Result<(), TransactionValidityError>

All pre-flight logic run before dispatching bare extrinsics. Read more
§

#### fn bare_post_dispatch( _info: &<Call as Dispatchable>::Info, _post_info: &mut <Call as Dispatchable>::PostInfo, _len: usize, _result: &Result<(), DispatchError>, ) -> Result<(), TransactionValidityError>

Post dispatch logic run after dispatching bare extrinsics. Read more
Source§

### impl TypeInfo for AddToSignaturePayload

Source§

#### type Identity = AddToSignaturePayload

The type identifying for which type info is provided. Read more
Source§

#### fn type_info() -> Type

Returns the static type identifier for `Self`.
Source§

### impl DecodeWithMemTracking for AddToSignaturePayload

Source§

### impl EncodeLike for AddToSignaturePayload

Source§

### impl Eq for AddToSignaturePayload

Source§

### impl StructuralPartialEq for AddToSignaturePayload

## Auto Trait Implementations§

§

### impl Freeze for AddToSignaturePayload

§

### impl RefUnwindSafe for AddToSignaturePayload

§

### impl Send for AddToSignaturePayload

§

### impl Sync for AddToSignaturePayload

§

### impl Unpin for AddToSignaturePayload

§

### impl UnwindSafe for AddToSignaturePayload

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

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

§

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

§

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

§

#### fn type_name(&self) -> &'static str

§

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

§

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

§

### 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>

Source§

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

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
§

### impl<T> CheckedConversion for T

§

#### fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

Convert from a value of `T` into an equivalent instance of `Option<Self>`. Read more
§

#### fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

Consume self to return `Some` equivalent value of `Option<T>`. Read more
Source§

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

Source§

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

🔬This is a nightly-only experimental API. (`clone_to_uninit` #126799)
Performs copy-assignment from `self` to `dest`. 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> DecodeAll for T
where T: Decode,

§

#### fn decode_all(input: &mut &[u8]) -> Result<T, Error>

Decode `Self` and consume all of the given input data. Read more
§

### impl<T> DecodeLimit for T
where T: Decode,

§

#### fn decode_all_with_depth_limit( limit: u32, input: &mut &[u8], ) -> Result<T, Error>

Decode `Self` and consume all of the given input data. Read more
§

#### fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where I: Input,

Decode `Self` with the given maximum recursion depth and advance `input` by the number of bytes consumed. Read more
§

### impl<T> DecodeWithMemLimit for T
where T: DecodeWithMemTracking,

§

#### fn decode_with_mem_limit<I>(input: &mut I, mem_limit: usize) -> Result<T, Error>
where I: Input,

Decode `Self` with the given maximum memory limit and advance `input` by the number of bytes consumed. Read more
§

### impl<T, U> DefensiveTruncateInto<U> for T
where U: DefensiveTruncateFrom<T>,

§

#### fn defensive_truncate_into(self) -> U

Defensively truncate a value and convert it into its bounded form.
§

### impl<T, Call> DispatchTransaction<Call> for T
where T: TransactionExtension<Call>, Call: Dispatchable + Encode, <Call as Dispatchable>::RuntimeOrigin: AsTransactionAuthorizedOrigin,

§

#### type Origin = <Call as Dispatchable>::RuntimeOrigin

The origin type of the transaction.
§

#### type Info = <Call as Dispatchable>::Info

The info type.
§

#### type Result = Result<Result<<Call as Dispatchable>::PostInfo, DispatchErrorWithPostInfo<<Call as Dispatchable>::PostInfo>>, TransactionValidityError>

The resultant type.
§

#### type Val = <T as TransactionExtension<Call>>::Val

The `Val` of the extension.
§

#### type Pre = <T as TransactionExtension<Call>>::Pre

The `Pre` of the extension.
§

#### fn validate_only( &self, origin: <T as DispatchTransaction<Call>>::Origin, call: &Call, info: &<Call as Dispatchable>::Info, len: usize, source: TransactionSource, extension_version: u8, ) -> Result<(ValidTransaction, <T as TransactionExtension<Call>>::Val, <T as DispatchTransaction<Call>>::Origin), TransactionValidityError>

Just validate a transaction. Read more
§

#### fn validate_and_prepare( self, origin: <T as DispatchTransaction<Call>>::Origin, call: &Call, info: &<Call as Dispatchable>::Info, len: usize, extension_version: u8, ) -> Result<(<T as TransactionExtension<Call>>::Pre, <T as DispatchTransaction<Call>>::Origin), TransactionValidityError>

Validate and prepare a transaction, ready for dispatch.
§

#### fn dispatch_transaction( self, origin: <Call as Dispatchable>::RuntimeOrigin, call: Call, info: &<Call as Dispatchable>::Info, len: usize, extension_version: u8, ) -> <T as DispatchTransaction<Call>>::Result

Dispatch a transaction with the given base origin and call.
§

#### fn test_run( self, origin: <T as DispatchTransaction<Call>>::Origin, call: &Call, info: &<T as DispatchTransaction<Call>>::Info, len: usize, extension_version: u8, substitute: impl FnOnce(<T as DispatchTransaction<Call>>::Origin) -> Result<<Call as Dispatchable>::PostInfo, DispatchErrorWithPostInfo<<Call as Dispatchable>::PostInfo>>, ) -> <T as DispatchTransaction<Call>>::Result

Do everything which would be done in a dispatch_transaction, but instead of executing the call, execute `substitute` instead. Since this doesn’t actually dispatch the call, it doesn’t need to consume it and so `call` can be passed as a reference.
§

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

§

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

Convert `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`. `Box<dyn Any>` can then be further `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`.
§

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

Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`.
§

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

Convert `&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)

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

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

§

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

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`.
Source§

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

Source§

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

§

### impl<T> EncodeAs<T> for T
where T: Encode,

§

#### fn encode_as(&self) -> Vec<u8> ⓘ

Convert Self into T, then encode T. Read more
§

### impl<T> EncodeInto for T
where T: Encode,

§

#### fn encode_into<T, H>(&self) -> T
where T: AsMut<[u8]> + Default, H: Hasher,

§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
§

### 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<T> FullLeaf for T
where T: Encode + Decode + Clone + PartialEq + Debug,

§

#### fn using_encoded<R, F>(&self, f: F, _compact: bool) -> R
where F: FnOnce(&[u8]) -> R,

Encode the leaf either in its full or compact form. Read more
§

### impl<T> Hashable for T
where T: Codec,

§

#### fn blake2_128(&self) -> [u8; 16]

§

#### fn blake2_256(&self) -> [u8; 32]

§

#### fn blake2_128_concat(&self) -> Vec<u8> ⓘ

§

#### fn twox_128(&self) -> [u8; 16]

§

#### fn twox_256(&self) -> [u8; 32]

§

#### fn twox_64_concat(&self) -> Vec<u8> ⓘ

§

#### fn identity(&self) -> Vec<u8> ⓘ

§

### 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, U> IntoKey<U> for T
where U: FromKey<T>,

§

#### fn into_key(self) -> U

§

### impl<Src, Dest> IntoTuple<Dest> for Src
where Dest: FromTuple<Src>,

§

#### fn into_tuple(self) -> Dest

§

### impl<T> IsType<T> for T

§

#### fn from_ref(t: &T) -> &T

Cast reference.
§

#### fn into_ref(&self) -> &T

Cast reference.
§

#### fn from_mut(t: &mut T) -> &mut T

Cast mutable reference.
§

#### fn into_mut(&mut self) -> &mut T

Cast mutable reference.
§

### impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

§

#### fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

§

#### fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

§

### impl<T> KeyedVec for T
where T: Codec,

§

#### fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ

Return an encoding of `Self` prepended by given slice.
§

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

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
§

### impl<T> SaturatedConversion for T

§

#### fn saturated_from<T>(t: T) -> Self
where Self: UniqueSaturatedFrom<T>,

Convert from a value of `T` into an equivalent instance of `Self`. Read more
§

#### fn saturated_into<T>(self) -> T
where Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of `T`. Read more
§

### impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

§

#### fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct `self` from the equivalent element of its superset. Read more
§

#### fn is_in_subset(&self) -> bool

Checks if `self` is actually part of its subset `T` (and can be converted to it).
§

#### fn to_subset_unchecked(&self) -> SS

Use with care! Same as `self.to_subset` but without any property checks. Always succeeds.
§

#### fn from_subset(element: &SS) -> SP

The inclusion map: converts `self` to the equivalent element of its superset.
§

### 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> 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<T, U> TryIntoKey<U> for T
where U: TryFromKey<T>,

§

#### type Error = <U as TryFromKey<T>>::Error

§

#### fn try_into_key(self) -> Result<U, <U as TryFromKey<T>>::Error>

§

### impl<S, T> UncheckedInto<T> for S
where T: UncheckedFrom<S>,

§

#### fn unchecked_into(self) -> T

The counterpart to `unchecked_from`.
§

### impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

§

#### fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of `T`.
§

### 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<S> Codec for S
where S: Decode + Encode,

§

### impl<T> EncodeLike<&&T> for T
where T: Encode,

§

### impl<T> EncodeLike<&T> for T
where T: Encode,

§

### impl<T> EncodeLike<&mut T> for T
where T: Encode,

§

### impl<T> EncodeLike<Arc<T>> for T
where T: Encode,

§

### impl<T> EncodeLike<Box<T>> for T
where T: Encode,

§

### impl<T> EncodeLike<Cow<'_, T>> for T
where T: ToOwned + Encode,

§

### impl<T> EncodeLike<Rc<T>> for T
where T: Encode,

§

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

§

### impl<S> FullCodec for S
where S: Decode + FullEncode,

§

### impl<S> FullEncode for S
where S: Encode + EncodeLike,

§

### impl<T> JsonSchemaMaybe for T

§

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

§

### impl<T> MaybeRefUnwindSafe for T
where T: RefUnwindSafe,

§

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

§

### impl<T> MaybeSendSync for T

§

### impl<T> Member for T
where T: Send + Sync + Debug + Eq + PartialEq + Clone + 'static,

§

### impl<T> Parameter for T
where T: Codec + DecodeWithMemTracking + EncodeLike + Clone + Eq + Debug + TypeInfo,

§

### impl<T> Parameter for T
where T: Codec + EncodeLike + Clone + Eq + Debug + TypeInfo,

Source§

### impl<T> Scalar for T
where T: 'static + Clone + PartialEq + Debug,

§

### impl<T> StaticTypeInfo for T
where T: TypeInfo + 'static,