Struct WasmtimeInstance Copy item path

impl WasmtimeInstance

pub fn new(store: Store<StoreLimits>, module: Module) -> Result<Self>

Instantiate a new Wasmtime instance.

pub fn exported_functions(&mut self) -> Vec<(String, FuncType)>

Retrieve the names and types of all exported functions in the instance.

This is useful for evaluating each exported function with different values. The DiffInstance trait asks for the function name and we need to know the function signature in order to pass in the right arguments.

pub fn exported_globals(&mut self) -> Vec<(String, DiffValueType)>

Returns the list of globals and their types exported from this instance.

pub fn exported_memories(&mut self) -> Vec<(String, bool)>

Returns the list of exported memories and whether or not it’s a shared memory.

pub fn is_oom(&self) -> bool

Returns whether or not this instance has hit its OOM condition yet.

Trait Implementations§

impl DiffInstance for WasmtimeInstance

fn name(&self) -> &'static str

Return the name of the engine behind this instance.

fn evaluate( &mut self, function_name: &str, arguments: &[DiffValue], _results: &[DiffValueType], ) -> Result<Option<Vec<DiffValue>>>

Evaluate an exported function with the given values. Read more

fn get_global(&mut self, name: &str, _ty: DiffValueType) -> Option<DiffValue>

Attempts to return the value of the specified global, returning None if this engine doesn’t support retrieving globals at this time.

fn get_memory(&mut self, name: &str, shared: bool) -> Option<Vec<u8>>

Same as get_global but for memory.

Auto Trait Implementations§

impl !UnwindSafe for WasmtimeInstance

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

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

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

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

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastSend for T
where T: Any + Send,

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Send + Sync>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

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

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> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more