Struct Func

pub struct Func(/* private fields */);

Newtype wrapper around wasmer::Function.

Implementations

impl Func

pub fn new(inner: Function) -> Self

Create a wasm_runtime_layer::Func-compatible Func from a wasmer::Function.

pub fn into_inner(self) -> Function

Consume a Func to obtain the inner wasmer::Function.

Methods from Deref<Target = Function>

pub fn ty(&self, store: &impl AsStoreRef) -> FunctionType

Returns the FunctionType of the Function.

Example

fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
    a + b
}

let f = Function::new_typed_with_env(&mut store, &env, sum);

assert_eq!(f.ty(&mut store).params(), vec![Type::I32, Type::I32]);
assert_eq!(f.ty(&mut store).results(), vec![Type::I32]);

pub fn param_arity(&self, store: &impl AsStoreRef) -> usize

Returns the number of parameters that this function takes.

Example

fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
    a + b
}

let f = Function::new_typed_with_env(&mut store, &env, sum);

assert_eq!(f.param_arity(&mut store), 2);

pub fn result_arity(&self, store: &impl AsStoreRef) -> usize

Returns the number of results this function produces.

Example

fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
    a + b
}

let f = Function::new_typed_with_env(&mut store, &env, sum);

assert_eq!(f.result_arity(&mut store), 1);

pub fn call( &self, store: &mut impl AsStoreMut, params: &[Value], ) -> Result<Box<[Value]>, RuntimeError>

Call the function.

Depending on where the Function is defined, it will call it.

1. If the function is defined inside a WebAssembly, it will call the trampoline for the function signature.
2. If the function is defined in the host (in a native way), it will call the trampoline.

Examples

let sum = instance.exports.get_function("sum").unwrap();

assert_eq!(sum.call(&mut store, &[Value::I32(1), Value::I32(2)]).unwrap().to_vec(), vec![Value::I32(3)]);

pub fn typed<Args, Rets>( &self, store: &impl AsStoreRef, ) -> Result<TypedFunction<Args, Rets>, RuntimeError>

where Args: WasmTypeList, Rets: WasmTypeList,

Transform this WebAssembly function into a typed function. See TypedFunction to learn more.

Examples

let sum = instance.exports.get_function("sum").unwrap();
let sum_typed: TypedFunction<(i32, i32), i32> = sum.typed(&mut store).unwrap();

assert_eq!(sum_typed.call(&mut store, 1, 2).unwrap(), 3);

Errors

If the Args generic parameter does not match the exported function an error will be raised:

let sum = instance.exports.get_function("sum").unwrap();

// This results in an error: `RuntimeError`
let sum_typed : TypedFunction<(i64, i64), i32> = sum.typed(&mut store).unwrap();

If the Rets generic parameter does not match the exported function an error will be raised:

let sum = instance.exports.get_function("sum").unwrap();

// This results in an error: `RuntimeError`
let sum_typed: TypedFunction<(i32, i32), i64> = sum.typed(&mut store).unwrap();

pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool

Checks whether this Function can be used with the given store.

pub fn as_sys(&self) -> &Function

Convert a reference to self into a reference to crate::backend::sys::function::Function.

pub fn as_sys_mut(&mut self) -> &mut Function

Convert a mutable reference to self into a mutable reference crate::backend::sys::function::Function.

Trait Implementations

impl AsMut<Func> for Function

fn as_mut(&mut self) -> &mut Func

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Function> for Func

fn as_mut(&mut self) -> &mut Function

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Func> for Function

fn as_ref(&self) -> &Func

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Function> for Func

fn as_ref(&self) -> &Function

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Func

fn clone(&self) -> Func

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for Func

type Target = Function

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Func

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Func> for Function

fn from(wrapper: Func) -> Self

Converts to this type from the input type.

impl From<Function> for Func

fn from(inner: Function) -> Self

Converts to this type from the input type.

impl RefCast for Func

type From = Function

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl WasmFunc<Engine> for Func

fn new<T>( ctx: impl AsContextMut<Engine, UserState = T>, ty: FuncType, func: impl 'static + Send + Sync + Fn(StoreContextMut<'_, T>, &[Value<Engine>], &mut [Value<Engine>]) -> Result<()>, ) -> Self

Creates a new function with the given arguments.

fn ty(&self, ctx: impl AsContext<Engine>) -> FuncType

Gets the function type of this object.

fn call<T>( &self, ctx: impl AsContextMut<Engine>, args: &[Value<Engine>], results: &mut [Value<Engine>], ) -> Result<()>

Calls the object with the given arguments.