[−]Struct holochain_wasmer_host::prelude::ImportObject
All of the import data used when instantiating.
It's suggested that you use the imports!
macro
instead of creating an ImportObject
by hand.
Usage:
let import_object = imports! { "env" => { "foo" => func!(foo), }, }; fn foo(_: &mut Ctx, n: i32) -> i32 { n }
Fields
allow_missing_functions: bool
Allow missing functions to be generated and instantiation to continue when required functions are not provided.
Methods
impl ImportObject
pub fn new() -> ImportObject
Create a new ImportObject
.
pub fn new_with_data<F>(state_creator: F) -> ImportObject where
F: Fn() -> (*mut c_void, fn(*mut c_void)) + 'static + Send + Sync,
F: Fn() -> (*mut c_void, fn(*mut c_void)) + 'static + Send + Sync,
Create a new ImportObject
which generates data from the provided state creator.
pub fn register<S, N>(
&mut self,
name: S,
namespace: N
) -> Option<Box<dyn LikeNamespace + 'static>> where
N: LikeNamespace + Send + 'static,
S: Into<String>,
&mut self,
name: S,
namespace: N
) -> Option<Box<dyn LikeNamespace + 'static>> where
N: LikeNamespace + Send + 'static,
S: Into<String>,
Register anything that implements LikeNamespace
as a namespace.
Usage:
fn register(instance: Instance, namespace: Namespace) { let mut import_object = ImportObject::new(); import_object.register("namespace0", instance); import_object.register("namespace1", namespace); // ... }
pub fn with_namespace<Func, InnerRet>(
&self,
namespace: &str,
f: Func
) -> Option<InnerRet> where
Func: FnOnce(&(dyn LikeNamespace + Send)) -> InnerRet,
&self,
namespace: &str,
f: Func
) -> Option<InnerRet> where
Func: FnOnce(&(dyn LikeNamespace + Send)) -> InnerRet,
Apply a function on the namespace if it exists
If your function can fail, consider using maybe_with_namespace
pub fn maybe_with_namespace<Func, InnerRet>(
&self,
namespace: &str,
f: Func
) -> Option<InnerRet> where
Func: FnOnce(&(dyn LikeNamespace + Send)) -> Option<InnerRet>,
&self,
namespace: &str,
f: Func
) -> Option<InnerRet> where
Func: FnOnce(&(dyn LikeNamespace + Send)) -> Option<InnerRet>,
The same as with_namespace
but takes a function that may fail
Usage:
fn get_export(imports: &ImportObject, namespace: &str, name: &str) -> Option<Export> { imports.maybe_with_namespace(namespace, |ns| ns.get_export(name)) }
pub fn clone_ref(&self) -> ImportObject
Create a clone ref of this namespace.
Trait Implementations
impl Extend<(String, String, Export)> for ImportObject
impl IntoIterator for ImportObject
Auto Trait Implementations
impl !RefUnwindSafe for ImportObject
impl Send for ImportObject
impl Sync for ImportObject
impl Unpin for ImportObject
impl !UnwindSafe for ImportObject
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,