Enum ac_node_api::decoder::EncodeError

pub enum EncodeError<T> {
    CompositeIsWrongLength {
        actual: Composite<T>,
        expected: TypeId,
        expected_len: usize,
    },
    CompositeIsWrongShape {
        actual: Composite<T>,
        expected: TypeId,
    },
    VariantNotFound {
        actual: Variant<T>,
        expected: TypeId,
    },
    CompositeFieldIsMissing {
        missing_field_name: String,
        expected: TypeId,
    },
    TypeIdNotFound(TypeId),
    WrongShape {
        actual: Value<T>,
        expected: TypeId,
    },
    BitSequenceError(BitSequenceError),
    CannotCompactEncode(TypeId),
}

An error encoding a Value into SCALE bytes.

Variants

CompositeIsWrongLength

Fields

actual: Composite<T>

The composite value that is the wrong length.

expected: TypeId

The type we’re trying to encode it into.

expected_len: usize

The length we’re expecting our composite type to be to encode properly.

The composite type we’re trying to encode is the wrong length for the type we’re trying to encode it into.

CompositeIsWrongShape

Fields

actual: Composite<T>

The composite value that is the wrong shape.

expected: TypeId

The type we’re trying to encode it into.

The composite is expected to contain named or unnamed values to encode properly, and the opposite is true.

VariantNotFound

Fields

actual: Variant<T>

The variant type we’re trying to encode.

expected: TypeId

The type we’re trying to encode it into.

The variant we’re trying to encode was not found in the type we’re encoding into.

CompositeFieldIsMissing

Fields

missing_field_name: String

The name of the composite field we can’t find.

expected: TypeId

The type we’re trying to encode this into.

The variant or composite field we’re trying to encode is not present in the type we’re encoding into.

TypeIdNotFound(TypeId)

The type we’re trying to encode into cannot be found in the type registry provided.

WrongShape

Fields

actual: Value<T>

The value we’re trying to encode.

expected: TypeId

The type we’re trying to encode it into.

The Value type we’re trying to encode is not the correct shape for the type we’re trying to encode it into.

BitSequenceError(BitSequenceError)

There was an error trying to encode the bit sequence provided.

CannotCompactEncode(TypeId)

The type ID given is supposed to be compact encoded, but this is not possible to do automatically.

Trait Implementations

impl<T: Clone> Clone for EncodeError<T>

fn clone(&self) -> EncodeError<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for EncodeError<T>

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

Formats the value using the given formatter.

impl From<EncodeError<()>> for Error

fn from(original: EncodeError<()>) -> Error

Converts to this type from the input type.

impl<T: PartialEq> PartialEq<EncodeError<T>> for EncodeError<T>

fn eq(&self, other: &EncodeError<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> StructuralPartialEq for EncodeError<T>