Enum subxt::error::EncodeError

pub enum EncodeError<T> {
    CompositeIsWrongLength {
        actual: Composite<T>,
        expected: TypeId,
        expected_len: usize,
    },
    VariantNotFound {
        actual: Variant<T>,
        expected: TypeId,
    },
    CompositeFieldIsMissing {
        missing_field_name: String,
        expected: TypeId,
    },
    TypeIdNotFound(TypeId),
    WrongShape {
        actual: Value<T>,
        expected: TypeId,
    },
    BitSequenceError(FromMetadataError),
    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.

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(FromMetadataError)

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 for EncodeError<T>where
    T: Clone,

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 for EncodeError<T>where
    T: Debug,

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

Formats the value using the given formatter.

impl<T> Display for EncodeError<T>where
    Value<T>: Debug,

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

Formats the value using the given formatter.

impl<T> Error for EncodeError<T>where
    EncodeError<T>: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, demand: &mut Demand<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

impl From<EncodeError<()>> for Error

fn from(source: EncodeError<()>) -> Self

Converts to this type from the input type.

impl<T> PartialEq<EncodeError<T>> for EncodeError<T>where
    T: PartialEq<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> Eq for EncodeError<T>where
    T: Eq,

impl<T> StructuralEq for EncodeError<T>

impl<T> StructuralPartialEq for EncodeError<T>