Struct sp_runtime_interface::pass_by::Inner

pub struct Inner<T: PassByInner<Inner = I>, I: RIType>(/* private fields */);

The implementation of the pass by inner type strategy. The type that uses this strategy will be passed between wasm and the host by using the wrapped inner type. So, this strategy is only usable by newtype structs.

Use this type as associated type for PassBy to implement this strategy for a type. Besides that the PassByInner trait need to be implemented as well.

This type expects the type that wants to use this strategy as generic parameter T and the inner type as generic parameter I.

PassByInner is a derive macro to implement this strategy.

Example

struct Test([u8; 32]);

impl PassBy for Test {
    type PassBy = Inner<Self, [u8; 32]>;
}

impl PassByInner for Test {
    type Inner = [u8; 32];

    fn into_inner(self) -> [u8; 32] {
        self.0
    }
    fn inner(&self) -> &[u8; 32] {
        &self.0
    }
    fn from_inner(inner: [u8; 32]) -> Self {
        Self(inner)
    }
}

Trait Implementations

impl<T: PassByInner<Inner = I>, I> PassByImpl<T> for Inner<T, I>

where I: IntoFFIValue + FromFFIValue<SelfInstance = I> + RIType,

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

Convert the given instance to the ffi value.

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

Create T from the given ffi value.

impl<T: PassByInner<Inner = I>, I: RIType> RIType for Inner<T, I>

The type is passed as the inner type.

type FFIType = <I as RIType>::FFIType

The ffi type that is used to represent Self.