Struct sp_runtime_interface::pass_by::Enum

pub struct Enum<T: Copy + Into<u8> + TryFrom<u8>>(_);

The implementation of the pass by enum strategy. This strategy uses an u8 internally to pass the enum between wasm and the host. So, this strategy only supports enums with unit variants.

Use this type as associated type for PassBy to implement this strategy for a type.

This type expects the type that wants to implement this strategy as generic parameter. Besides that the type needs to implement TryFrom<u8> and From<Self> for u8.

PassByEnum is a derive macro to implement this strategy.

Example

#[derive(Clone, Copy)]
enum Test {
    Test1,
    Test2,
}

impl From<Test> for u8 {
    fn from(val: Test) -> u8 {
        match val {
            Test::Test1 => 0,
            Test::Test2 => 1,
        }
    }
}

impl std::convert::TryFrom<u8> for Test {
    type Error = ();

    fn try_from(val: u8) -> Result<Test, ()> {
        match val {
            0 => Ok(Test::Test1),
            1 => Ok(Test::Test2),
            _ => Err(()),
        }
    }
}

impl PassBy for Test {
    type PassBy = Enum<Self>;
}

Trait Implementations

impl<T: Copy + Into<u8> + TryFrom<u8>> PassByImpl<T> for Enum<T>

pub fn into_ffi_value(
    instance: T,
    _: &mut dyn FunctionContext
) -> Result<Self::FFIType>

Convert the given instance to the ffi value.

pub fn from_ffi_value(
    _: &mut dyn FunctionContext,
    arg: Self::FFIType
) -> Result<T>

Create T from the given ffi value.

impl<T: Copy + Into<u8> + TryFrom<u8>> RIType for Enum<T>

The type is passed as u8.

The value is corresponds to the discriminant of the variant.

type FFIType = u8

The ffi type that is used to represent Self.