Enum ProcessMessageError

pub enum ProcessMessageError {
    BadFormat,
    Corrupt,
    Unsupported,
    Overweight(Weight),
    Yield,
    StackLimitReached,
}

Errors that can happen when attempting to process a message with ProcessMessage::process_message().

Variants

BadFormat

The message data format is unknown (e.g. unrecognised header)

Corrupt

The message data is bad (e.g. decoding returns an error).

Unsupported

The message format is unsupported (e.g. old XCM version).

Overweight(Weight)

Message processing was not attempted because it was not certain that the weight limit would be respected. The parameter gives the maximum weight which the message could take to process.

Yield

The queue wants to give up its current processing slot.

Hints the message processor to cease servicing this queue and proceed to the next one. This is seen as a hint, not an instruction. Implementations must therefore handle the case that a queue is re-serviced within the same block after yielding. A queue is not required to yield again when it is being re-serviced withing the same block.

StackLimitReached

The message could not be processed for reaching the stack depth limit.

Trait Implementations

impl Clone for ProcessMessageError

fn clone(&self) -> ProcessMessageError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessMessageError

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

Formats the value using the given formatter.

impl Decode for ProcessMessageError

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<ProcessMessageError, Error>

where __CodecInputEdqy: 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 Encode for ProcessMessageError

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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.

impl PartialEq for ProcessMessageError

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl TypeInfo for ProcessMessageError

type Identity = ProcessMessageError

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Copy for ProcessMessageError

impl DecodeWithMemTracking for ProcessMessageError

impl EncodeLike for ProcessMessageError

impl Eq for ProcessMessageError

impl StructuralPartialEq for ProcessMessageError