Struct StoreContextMut 

pub struct StoreContextMut<'a, T: 'static>(/* private fields */);

A temporary handle to a &mut Store<T>.

This type is suitable for AsContextMut or AsContext trait bounds on methods if desired. For more information, see Store.

Implementations

impl<'a, T> StoreContextMut<'a, T>

pub async fn gc_async(&mut self, why: Option<&GcHeapOutOfMemory<()>>)

where T: Send + 'static,

Available on crate features runtime and async and gc only.

Perform garbage collection of ExternRefs.

Same as Store::gc.

This method is only available when the gc Cargo feature is enabled.

pub fn epoch_deadline_async_yield_and_update(&mut self, delta: u64)

Available on crate feature runtime and crate feature async and target_has_atomic=64 only.

Configures epoch-deadline expiration to yield to the async caller and the update the deadline.

For more information see Store::epoch_deadline_async_yield_and_update.

impl<'a, T> StoreContextMut<'a, T>

pub fn data(&self) -> &T

Available on crate feature runtime only.

Access the underlying data owned by this Store.

Same as Store::data.

pub fn data_mut(&mut self) -> &mut T

Available on crate feature runtime only.

Access the underlying data owned by this Store.

Same as Store::data_mut.

pub fn engine(&self) -> &Engine

Available on crate feature runtime only.

Returns the underlying Engine this store is connected to.

pub fn gc(&mut self, why: Option<&GcHeapOutOfMemory<()>>)

Available on crate features runtime and gc only.

Perform garbage collection of ExternRefs.

Same as Store::gc.

This method is only available when the gc Cargo feature is enabled.

pub fn get_fuel(&self) -> Result<u64>

Available on crate feature runtime only.

Returns remaining fuel in this store.

For more information see Store::get_fuel

pub fn set_fuel(&mut self, fuel: u64) -> Result<()>

Available on crate feature runtime only.

Set the amount of fuel in this store.

For more information see Store::set_fuel

pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()>

Available on crate feature runtime only.

Configures this Store to periodically yield while executing futures.

For more information see Store::fuel_async_yield_interval

pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64)

Available on crate feature runtime and target_has_atomic=64 only.

Sets the epoch deadline to a certain number of ticks in the future.

For more information see Store::set_epoch_deadline.

pub fn epoch_deadline_trap(&mut self)

Available on crate feature runtime and target_has_atomic=64 only.

Configures epoch-deadline expiration to trap.

For more information see Store::epoch_deadline_trap.

pub fn throw<R>( &mut self, exception: Rooted<ExnRef>, ) -> Result<R, ThrownException>

Available on crate features runtime and gc only.

Set an exception as the currently pending exception, and return an error that propagates the throw.

See Store::throw for more details.

pub fn take_pending_exception(&mut self) -> Option<Rooted<ExnRef>>

Available on crate features runtime and gc only.

Take the currently pending exception, if any, and return it, removing it from the “pending exception” slot.

See Store::take_pending_exception for more details.

pub fn has_pending_exception(&self) -> bool

Available on crate features runtime and gc only.

Tests whether there is a pending exception.

See Store::has_pending_exception for more details.

impl<T> StoreContextMut<'_, T>

pub fn spawn( self, task: impl AccessorTask<T, HasSelf<T>, Result<()>>, ) -> JoinHandle

where T: 'static,

Available on crate features runtime and component-model and component-model-async only.

Spawn a background task to run as part of this instance’s event loop.

The task will receive an &Accessor<U> and run concurrently with any other tasks in progress for the instance.

Note that the task will only make progress if and when the event loop for this instance is run.

The returned [SpawnHandle] may be used to cancel the task.

pub async fn run_concurrent<R>( self, fun: impl AsyncFnOnce(&Accessor<T>) -> R, ) -> Result<R>

where T: Send + 'static,

Available on crate features runtime and component-model and component-model-async only.

Run the specified closure fun to completion as part of this store’s event loop.

This will run fun as part of this store’s event loop until it yields a result. fun is provided an Accessor, which provides controlled access to the store and its data.

This function can be used to invoke Func::call_concurrent for example within the async closure provided here.

Example

store.run_concurrent(async |accessor| -> wasmtime::Result<_> {
   let resource = accessor.with(|mut access| access.get().table.push(MyResource(42)))?;
   let (another_resource,) = foo.call_concurrent(accessor, (resource,)).await?.0;
   let value = accessor.with(|mut access| access.get().table.delete(another_resource))?;
   bar.call_concurrent(accessor, (value.0,)).await?;
   Ok(())
}).await??;

Trait Implementations

impl<T: 'static> AsContext for StoreContextMut<'_, T>

Available on crate feature runtime only.

type Data = T

The host information associated with the Store, aka the T in Store<T>.

fn as_context(&self) -> StoreContext<'_, T>

Returns the store context that this type provides access to.

impl<T: 'static> AsContextMut for StoreContextMut<'_, T>

Available on crate feature runtime only.

fn as_context_mut(&mut self) -> StoreContextMut<'_, T>

Returns the store context that this type provides access to.

impl<'a, T: AsContextMut> From<&'a mut T> for StoreContextMut<'a, T::Data>

Available on crate feature runtime only.

fn from(t: &'a mut T) -> StoreContextMut<'a, T::Data>

Converts to this type from the input type.

impl<'a, T: 'static> From<StoreContextMut<'a, T>> for StoreContext<'a, T>

Available on crate feature runtime only.

fn from(store: StoreContextMut<'a, T>) -> StoreContext<'a, T>

Converts to this type from the input type.

impl<I, T> Index<I> for StoreContextMut<'_, T>

where StoreOpaque: Index<I>,

Available on crate feature runtime only.

type Output = <StoreOpaque as Index<I>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I, T> IndexMut<I> for StoreContextMut<'_, T>

where StoreOpaque: IndexMut<I>,

Available on crate feature runtime only.

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.