Struct wasmer::TypedFunction

impl<Rets> TypedFunction<(), Rets>where
Rets: WasmTypeList,

pub fn call(&self, store: &mut impl AsStoreMut) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, Rets> TypedFunction<A1, Rets>where
A1: FromToNativeWasmType,
Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, Rets> TypedFunction<(A1, A2), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, Rets> TypedFunction<(A1, A2, A3), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, Rets> TypedFunction<(A1, A2, A3, A4), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, Rets> TypedFunction<(A1, A2, A3, A4, A5), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 A15: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14,
 A15: A15
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 A15: FromToNativeWasmType,
 A16: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14,
 A15: A15,
 A16: A16
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 A15: FromToNativeWasmType,
 A16: FromToNativeWasmType,
 A17: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14,
 A15: A15,
 A16: A16,
 A17: A17
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 A15: FromToNativeWasmType,
 A16: FromToNativeWasmType,
 A17: FromToNativeWasmType,
 A18: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14,
 A15: A15,
 A16: A16,
 A17: A17,
 A18: A18
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 A15: FromToNativeWasmType,
 A16: FromToNativeWasmType,
 A17: FromToNativeWasmType,
 A18: FromToNativeWasmType,
 A19: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14,
 A15: A15,
 A16: A16,
 A17: A17,
 A18: A18,
 A19: A19
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Rets> TypedFunction<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20), Rets>where
 A1: FromToNativeWasmType,
 A2: FromToNativeWasmType,
 A3: FromToNativeWasmType,
 A4: FromToNativeWasmType,
 A5: FromToNativeWasmType,
 A6: FromToNativeWasmType,
 A7: FromToNativeWasmType,
 A8: FromToNativeWasmType,
 A9: FromToNativeWasmType,
 A10: FromToNativeWasmType,
 A11: FromToNativeWasmType,
 A12: FromToNativeWasmType,
 A13: FromToNativeWasmType,
 A14: FromToNativeWasmType,
 A15: FromToNativeWasmType,
 A16: FromToNativeWasmType,
 A17: FromToNativeWasmType,
 A18: FromToNativeWasmType,
 A19: FromToNativeWasmType,
 A20: FromToNativeWasmType,
 Rets: WasmTypeList,

pub fn call(
 &self,
 store: &mut impl AsStoreMut,
 A1: A1,
 A2: A2,
 A3: A3,
 A4: A4,
 A5: A5,
 A6: A6,
 A7: A7,
 A8: A8,
 A9: A9,
 A10: A10,
 A11: A11,
 A12: A12,
 A13: A13,
 A14: A14,
 A15: A15,
 A16: A16,
 A17: A17,
 A18: A18,
 A19: A19,
 A20: A20
) -> Result<Rets, RuntimeError>

Call the typed func and return results.

Trait Implementations§

impl<Args: WasmTypeList, Rets: WasmTypeList> Clone for TypedFunction<Args, Rets>

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<Args, Rets> From<TypedFunction<Args, Rets>> for Functionwhere
Args: WasmTypeList,
Rets: WasmTypeList,

fn from(other: TypedFunction<Args, Rets>) -> Self

Converts to this type from the input type.

impl<Args, Rets> Send for TypedFunction<Args, Rets>

Auto Trait Implementations§

impl<Args, Rets> UnwindSafe for TypedFunction<Args, Rets>

Blanket Implementations§

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> ArchivePointee for T

type ArchivedMetadata = ()

The archived version of the pointer metadata for this type.

fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata

Converts some archived metadata to the pointer metadata for itself.

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
 W: DeserializeWith<F, T, D>,
 D: Fallible + ?Sized,
 F: ?Sized,

fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Pointee for T

type Metadata = ()

The type for metadata in pointers and references to Self.

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> Upcastable for Twhere
T: Any + Send + Sync + 'static,

fn upcast_any_ref(&self) -> &(dyn Any + 'static)

upcast ref

fn upcast_any_mut(&mut self) -> &mut (dyn Any + 'static)

upcast mut ref

fn upcast_any_box(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

upcast boxed dyn

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more