Trait sp_runtime_interface::host::FromFFIValue

pub trait FromFFIValue: RIType {
    type SelfInstance;
    fn from_ffi_value(
        context: &mut dyn FunctionContext, 
        arg: Self::FFIType
    ) -> Result<Self::SelfInstance>;
}

Something that can be created from a ffi value. Implementations are safe to assume that the arg given to from_ffi_value is only generated by the corresponding wasm::IntoFFIValue implementation.

Associated Types

type SelfInstance

As Self can be an unsized type, it needs to be represented by a sized type at the host. This SelfInstance is the sized type.

Loading content...

Required methods

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

Create SelfInstance from the given

Loading content...

Implementations on Foreign Types

impl FromFFIValue for u8

type SelfInstance = u8

fn from_ffi_value(_: &mut dyn FunctionContext, arg: u8) -> Result<u8>

impl FromFFIValue for u16

type SelfInstance = u16

fn from_ffi_value(_: &mut dyn FunctionContext, arg: u16) -> Result<u16>

impl FromFFIValue for u32

type SelfInstance = u32

fn from_ffi_value(_: &mut dyn FunctionContext, arg: u32) -> Result<u32>

impl FromFFIValue for u64

type SelfInstance = u64

fn from_ffi_value(_: &mut dyn FunctionContext, arg: u64) -> Result<u64>

impl FromFFIValue for i8

type SelfInstance = i8

fn from_ffi_value(_: &mut dyn FunctionContext, arg: i8) -> Result<i8>

impl FromFFIValue for i16

type SelfInstance = i16

fn from_ffi_value(_: &mut dyn FunctionContext, arg: i16) -> Result<i16>

impl FromFFIValue for i32

type SelfInstance = i32

fn from_ffi_value(_: &mut dyn FunctionContext, arg: i32) -> Result<i32>

impl FromFFIValue for i64

type SelfInstance = i64

fn from_ffi_value(_: &mut dyn FunctionContext, arg: i64) -> Result<i64>

impl FromFFIValue for bool

type SelfInstance = bool

fn from_ffi_value(_: &mut dyn FunctionContext, arg: u8) -> Result<bool>

impl<T: 'static + Decode> FromFFIValue for Vec<T>

type SelfInstance = Vec<T>

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

impl<T: 'static + Decode> FromFFIValue for [T]

type SelfInstance = Vec<T>

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

impl FromFFIValue for [u8; 1]

type SelfInstance = [u8; 1]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 1]>

impl FromFFIValue for [u8; 2]

type SelfInstance = [u8; 2]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 2]>

impl FromFFIValue for [u8; 3]

type SelfInstance = [u8; 3]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 3]>

impl FromFFIValue for [u8; 4]

type SelfInstance = [u8; 4]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 4]>

impl FromFFIValue for [u8; 5]

type SelfInstance = [u8; 5]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 5]>

impl FromFFIValue for [u8; 6]

type SelfInstance = [u8; 6]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 6]>

impl FromFFIValue for [u8; 7]

type SelfInstance = [u8; 7]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 7]>

impl FromFFIValue for [u8; 8]

type SelfInstance = [u8; 8]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 8]>

impl FromFFIValue for [u8; 9]

type SelfInstance = [u8; 9]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 9]>

impl FromFFIValue for [u8; 10]

type SelfInstance = [u8; 10]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 10]>

impl FromFFIValue for [u8; 11]

type SelfInstance = [u8; 11]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 11]>

impl FromFFIValue for [u8; 12]

type SelfInstance = [u8; 12]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 12]>

impl FromFFIValue for [u8; 13]

type SelfInstance = [u8; 13]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 13]>

impl FromFFIValue for [u8; 14]

type SelfInstance = [u8; 14]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 14]>

impl FromFFIValue for [u8; 15]

type SelfInstance = [u8; 15]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 15]>

impl FromFFIValue for [u8; 16]

type SelfInstance = [u8; 16]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 16]>

impl FromFFIValue for [u8; 17]

type SelfInstance = [u8; 17]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 17]>

impl FromFFIValue for [u8; 18]

type SelfInstance = [u8; 18]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 18]>

impl FromFFIValue for [u8; 19]

type SelfInstance = [u8; 19]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 19]>

impl FromFFIValue for [u8; 20]

type SelfInstance = [u8; 20]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 20]>

impl FromFFIValue for [u8; 21]

type SelfInstance = [u8; 21]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 21]>

impl FromFFIValue for [u8; 22]

type SelfInstance = [u8; 22]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 22]>

impl FromFFIValue for [u8; 23]

type SelfInstance = [u8; 23]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 23]>

impl FromFFIValue for [u8; 24]

type SelfInstance = [u8; 24]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 24]>

impl FromFFIValue for [u8; 25]

type SelfInstance = [u8; 25]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 25]>

impl FromFFIValue for [u8; 26]

type SelfInstance = [u8; 26]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 26]>

impl FromFFIValue for [u8; 27]

type SelfInstance = [u8; 27]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 27]>

impl FromFFIValue for [u8; 28]

type SelfInstance = [u8; 28]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 28]>

impl FromFFIValue for [u8; 29]

type SelfInstance = [u8; 29]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 29]>

impl FromFFIValue for [u8; 30]

type SelfInstance = [u8; 30]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 30]>

impl FromFFIValue for [u8; 31]

type SelfInstance = [u8; 31]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 31]>

impl FromFFIValue for [u8; 32]

type SelfInstance = [u8; 32]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 32]>

impl FromFFIValue for [u8; 33]

type SelfInstance = [u8; 33]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 33]>

impl FromFFIValue for [u8; 34]

type SelfInstance = [u8; 34]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 34]>

impl FromFFIValue for [u8; 35]

type SelfInstance = [u8; 35]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 35]>

impl FromFFIValue for [u8; 36]

type SelfInstance = [u8; 36]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 36]>

impl FromFFIValue for [u8; 37]

type SelfInstance = [u8; 37]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 37]>

impl FromFFIValue for [u8; 38]

type SelfInstance = [u8; 38]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 38]>

impl FromFFIValue for [u8; 39]

type SelfInstance = [u8; 39]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 39]>

impl FromFFIValue for [u8; 40]

type SelfInstance = [u8; 40]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 40]>

impl FromFFIValue for [u8; 41]

type SelfInstance = [u8; 41]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 41]>

impl FromFFIValue for [u8; 42]

type SelfInstance = [u8; 42]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 42]>

impl FromFFIValue for [u8; 43]

type SelfInstance = [u8; 43]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 43]>

impl FromFFIValue for [u8; 44]

type SelfInstance = [u8; 44]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 44]>

impl FromFFIValue for [u8; 45]

type SelfInstance = [u8; 45]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 45]>

impl FromFFIValue for [u8; 46]

type SelfInstance = [u8; 46]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 46]>

impl FromFFIValue for [u8; 47]

type SelfInstance = [u8; 47]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 47]>

impl FromFFIValue for [u8; 48]

type SelfInstance = [u8; 48]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 48]>

impl FromFFIValue for [u8; 49]

type SelfInstance = [u8; 49]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 49]>

impl FromFFIValue for [u8; 50]

type SelfInstance = [u8; 50]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 50]>

impl FromFFIValue for [u8; 51]

type SelfInstance = [u8; 51]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 51]>

impl FromFFIValue for [u8; 52]

type SelfInstance = [u8; 52]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 52]>

impl FromFFIValue for [u8; 53]

type SelfInstance = [u8; 53]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 53]>

impl FromFFIValue for [u8; 54]

type SelfInstance = [u8; 54]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 54]>

impl FromFFIValue for [u8; 55]

type SelfInstance = [u8; 55]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 55]>

impl FromFFIValue for [u8; 56]

type SelfInstance = [u8; 56]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 56]>

impl FromFFIValue for [u8; 57]

type SelfInstance = [u8; 57]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 57]>

impl FromFFIValue for [u8; 58]

type SelfInstance = [u8; 58]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 58]>

impl FromFFIValue for [u8; 59]

type SelfInstance = [u8; 59]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 59]>

impl FromFFIValue for [u8; 60]

type SelfInstance = [u8; 60]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 60]>

impl FromFFIValue for [u8; 61]

type SelfInstance = [u8; 61]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 61]>

impl FromFFIValue for [u8; 62]

type SelfInstance = [u8; 62]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 62]>

impl FromFFIValue for [u8; 63]

type SelfInstance = [u8; 63]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 63]>

impl FromFFIValue for [u8; 64]

type SelfInstance = [u8; 64]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 64]>

impl FromFFIValue for [u8; 65]

type SelfInstance = [u8; 65]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 65]>

impl FromFFIValue for [u8; 66]

type SelfInstance = [u8; 66]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 66]>

impl FromFFIValue for [u8; 67]

type SelfInstance = [u8; 67]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 67]>

impl FromFFIValue for [u8; 68]

type SelfInstance = [u8; 68]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 68]>

impl FromFFIValue for [u8; 69]

type SelfInstance = [u8; 69]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 69]>

impl FromFFIValue for [u8; 70]

type SelfInstance = [u8; 70]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 70]>

impl FromFFIValue for [u8; 71]

type SelfInstance = [u8; 71]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 71]>

impl FromFFIValue for [u8; 72]

type SelfInstance = [u8; 72]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 72]>

impl FromFFIValue for [u8; 73]

type SelfInstance = [u8; 73]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 73]>

impl FromFFIValue for [u8; 74]

type SelfInstance = [u8; 74]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 74]>

impl FromFFIValue for [u8; 75]

type SelfInstance = [u8; 75]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 75]>

impl FromFFIValue for [u8; 76]

type SelfInstance = [u8; 76]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 76]>

impl FromFFIValue for [u8; 77]

type SelfInstance = [u8; 77]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 77]>

impl FromFFIValue for [u8; 78]

type SelfInstance = [u8; 78]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 78]>

impl FromFFIValue for [u8; 79]

type SelfInstance = [u8; 79]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 79]>

impl FromFFIValue for [u8; 80]

type SelfInstance = [u8; 80]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 80]>

impl FromFFIValue for [u8; 81]

type SelfInstance = [u8; 81]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 81]>

impl FromFFIValue for [u8; 82]

type SelfInstance = [u8; 82]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 82]>

impl FromFFIValue for [u8; 83]

type SelfInstance = [u8; 83]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 83]>

impl FromFFIValue for [u8; 84]

type SelfInstance = [u8; 84]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 84]>

impl FromFFIValue for [u8; 85]

type SelfInstance = [u8; 85]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 85]>

impl FromFFIValue for [u8; 86]

type SelfInstance = [u8; 86]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 86]>

impl FromFFIValue for [u8; 87]

type SelfInstance = [u8; 87]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 87]>

impl FromFFIValue for [u8; 88]

type SelfInstance = [u8; 88]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 88]>

impl FromFFIValue for [u8; 89]

type SelfInstance = [u8; 89]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 89]>

impl FromFFIValue for [u8; 90]

type SelfInstance = [u8; 90]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 90]>

impl FromFFIValue for [u8; 91]

type SelfInstance = [u8; 91]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 91]>

impl FromFFIValue for [u8; 92]

type SelfInstance = [u8; 92]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 92]>

impl FromFFIValue for [u8; 93]

type SelfInstance = [u8; 93]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 93]>

impl FromFFIValue for [u8; 94]

type SelfInstance = [u8; 94]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 94]>

impl FromFFIValue for [u8; 95]

type SelfInstance = [u8; 95]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 95]>

impl FromFFIValue for [u8; 96]

type SelfInstance = [u8; 96]

fn from_ffi_value(
    context: &mut dyn FunctionContext,
    arg: u32
) -> Result<[u8; 96]>

impl FromFFIValue for str

type SelfInstance = String

fn from_ffi_value(context: &mut dyn FunctionContext, arg: u64) -> Result<String>

impl FromFFIValue for u128

type SelfInstance = u128

fn from_ffi_value(context: &mut dyn FunctionContext, arg: u32) -> Result<u128>

impl FromFFIValue for i128

type SelfInstance = i128

fn from_ffi_value(context: &mut dyn FunctionContext, arg: u32) -> Result<i128>

Loading content...

Implementors

impl<T: PassBy> FromFFIValue for T

type SelfInstance = Self

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

impl<T: PointerType> FromFFIValue for Pointer<T>

type SelfInstance = Self

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

Loading content...