Struct wasmtime_async::AsyncGetter

pub struct AsyncGetter<'f> { /* fields omitted */ }

Helper struct for retrieving native functions out of WebAssembly functions that call async callbacks.

Implementations

impl<'f> AsyncGetter<'f>

pub fn get0<R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get1<A1, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get2<A1, A2, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get3<A1, A2, A3, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get4<A1, A2, A3, A4, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get5<A1, A2, A3, A4, A5, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get6<A1, A2, A3, A4, A5, A6, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get7<A1, A2, A3, A4, A5, A6, A7, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get8<A1, A2, A3, A4, A5, A6, A7, A8, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get9<A1, A2, A3, A4, A5, A6, A7, A8, A9, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    A10: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    A10: 'static + WasmTy,
    A11: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    A10: 'static + WasmTy,
    A11: 'static + WasmTy,
    A12: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    A10: 'static + WasmTy,
    A11: 'static + WasmTy,
    A12: 'static + WasmTy,
    A13: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    A10: 'static + WasmTy,
    A11: 'static + WasmTy,
    A12: 'static + WasmTy,
    A13: 'static + WasmTy,
    A14: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.

pub fn get15<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R>(
    &self
) -> Result<Box<dyn Fn(&'s mut Stack, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> WasmFuture<'s, Result<R, Trap>> + 'static>> where
    A1: 'static + WasmTy,
    A2: 'static + WasmTy,
    A3: 'static + WasmTy,
    A4: 'static + WasmTy,
    A5: 'static + WasmTy,
    A6: 'static + WasmTy,
    A7: 'static + WasmTy,
    A8: 'static + WasmTy,
    A9: 'static + WasmTy,
    A10: 'static + WasmTy,
    A11: 'static + WasmTy,
    A12: 'static + WasmTy,
    A13: 'static + WasmTy,
    A14: 'static + WasmTy,
    A15: 'static + WasmTy,
    R: 'static + WasmTy, 

Retrieve a Rust-native function that calls this function in an async-ready way. This makes it possible to run functions that have been built by the helper methods provided by this crate.

See also wasmtime::Func::call for more details.