Struct scale_encode::Variant

pub struct Variant<'a, Vals> {
    pub name: &'a str,
    pub fields: Composite<Vals>,
}

This type represents named or unnamed composite values, and can be used to help generate EncodeAsType impls. It’s primarily used by the exported macros to do just that.

use scale_encode::{ Error, EncodeAsType, Composite, Variant, PortableRegistry };

enum MyType {
   SomeField(bool),
   OtherField { foo: u64, bar: String }
}

impl EncodeAsType for MyType {
    fn encode_as_type_to(&self, type_id: u32, types: &PortableRegistry, out: &mut Vec<u8>) -> Result<(), Error> {
        match self {
            MyType::SomeField(b) => Variant {
                name: "SomeField",
                fields: Composite([
                    (None, b as &dyn EncodeAsType),
                ].into_iter())
            }.encode_as_type_to(type_id, types, out),
            MyType::OtherField { foo, bar } => Variant {
                name: "OtherField",
                fields: Composite([
                    (Some("foo"), foo as &dyn EncodeAsType),
                    (Some("bar"), bar as &dyn EncodeAsType)
                ].into_iter())
            }.encode_as_type_to(type_id, types, out)
        }
    }
}

Fields

name: &'a str

The name of the variant we’ll try to encode into.

fields: Composite<Vals>

The fields of the variant that we wish to encode.

Trait Implementations

impl<'a, Vals> EncodeAsType for Variant<'a, Vals>where Vals: ExactSizeIterator<Item = (Option<&'a str>, &'a dyn EncodeAsType)> + Clone,

fn encode_as_type_to( &self, type_id: u32, types: &PortableRegistry, out: &mut Vec<u8> ) -> Result<(), Error>

Given some type_id, types, a context and some output target for the SCALE encoded bytes, attempt to SCALE encode the current value into the type given by type_id.

fn encode_as_type( &self, type_id: u32, types: &PortableRegistry ) -> Result<Vec<u8>, Error>

This is a helper function which internally calls EncodeAsType::encode_as_type_to. Prefer to implement that instead.