Type Alias frame_support::dispatch::DispatchResultWithPostInfo

pub type DispatchResultWithPostInfo = DispatchResultWithInfo<PostDispatchInfo>;

The return type of a Dispatchable in frame. When returned explicitly from a dispatchable function it allows overriding the default PostDispatchInfo returned from a dispatch.

Aliased Type

enum DispatchResultWithPostInfo {
    Ok(PostDispatchInfo),
    Err(DispatchErrorWithPostInfo<PostDispatchInfo>),
}

Variants

Ok(PostDispatchInfo)

Contains the success value

Err(DispatchErrorWithPostInfo<PostDispatchInfo>)

Contains the error value

Trait Implementations

impl<T, E> Decode for Result<T, E>where T: Decode, E: Decode,

fn decode<I>(input: &mut I) -> Result<Result<T, E>, Error>where I: Input,

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.

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

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T, E: Debug> Defensive<T> for Result<T, E>

fn defensive_unwrap_or(self, or: T) -> T

Exactly the same as unwrap_or, but it does the defensive warnings explained in the trait docs.

fn defensive_unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T

Exactly the same as unwrap_or_else, but it does the defensive warnings explained in the trait docs.

fn defensive_unwrap_or_default(self) -> Twhere T: Default,

Exactly the same as unwrap_or_default, but it does the defensive warnings explained in the trait docs.

fn defensive(self) -> Self

Does not alter the inner value at all, but it will log warnings if the inner value is None or Err.

fn defensive_proof(self, proof: &'static str) -> Self

Same as Defensive::defensive, but it takes a proof as input, and displays it if the defensive operation has been triggered.

impl<T, E: Debug> DefensiveResult<T, E> for Result<T, E>

fn defensive_map_err<F, O: FnOnce(E) -> F>(self, o: O) -> Result<T, F>

Defensively map the error into another return type, but you are really sure that this conversion should never be needed.

fn defensive_map_or_else<U, D: FnOnce(E) -> U, F: FnOnce(T) -> U>( self, default: D, f: F ) -> U

Defensively map and unpack the value to something else (U), or call the default callback if Err, which should never happen.

fn defensive_ok(self) -> Option<T>

Defensively transform this result into an option, discarding the Err variant if it happens, which should never happen.

fn defensive_map<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E>

Exactly the same as map, but it prints the appropriate warnings if the value being mapped is Err.

impl<T, E> Encode for Result<T, E>where T: Encode, E: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<W>(&self, dest: &mut W)where W: Output + ?Sized,

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

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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.

impl<T, E> MaxEncodedLen for Result<T, E>where T: MaxEncodedLen, E: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: PalletError, E: PalletError> PalletError for Result<T, E>

const MAX_ENCODED_SIZE: usize = _

The maximum encoded size for the implementing type.

impl<T, E> TypeInfo for Result<T, E>where T: TypeInfo + 'static, E: TypeInfo + 'static,

type Identity = Result<T, E>

The type identifying for which type info is provided.

fn type_info() -> Type<MetaForm>

Returns the static type identifier for Self.