pub struct StoreContextMut<'a, T: 'static>(/* private fields */);Expand description
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§
Source§impl<'a, T> StoreContextMut<'a, T>
 
impl<'a, T> StoreContextMut<'a, T>
Sourcepub fn debug_frames(self) -> Option<DebugFrameCursor<'a, T>>
 Available on crate features runtime and debug only.
pub fn debug_frames(self) -> Option<DebugFrameCursor<'a, T>>
runtime and debug only.Provide an object that captures Wasm stack state, including Wasm VM-level values (locals and operand stack).
This object views all activations for the current store that are on the stack. An activation is a contiguous sequence of Wasm frames (called functions) that were called from host code and called back out to host code. If there are activations from multiple stores on the stack, for example if Wasm code in one store calls out to host code which invokes another Wasm function in another store, then the other stores are “opaque” to our view here in the same way that host code is.
Returns None if debug instrumentation is not enabled for
the engine containing this store.
Source§impl<'a, T> StoreContextMut<'a, T>
 
impl<'a, T> StoreContextMut<'a, T>
Sourcepub async fn gc_async(&mut self, why: Option<&GcHeapOutOfMemory<()>>)where
    T: Send + 'static,
 Available on crate features runtime and async and gc only.
pub async fn gc_async(&mut self, why: Option<&GcHeapOutOfMemory<()>>)where
    T: Send + 'static,
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.
Sourcepub 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.
pub fn epoch_deadline_async_yield_and_update(&mut self, delta: u64)
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.
Source§impl<'a, T> StoreContextMut<'a, T>
 
impl<'a, T> StoreContextMut<'a, T>
Sourcepub fn data(&self) -> &T
 Available on crate feature runtime only.
pub fn data(&self) -> &T
runtime only.Access the underlying data owned by this Store.
Same as Store::data.
Sourcepub fn data_mut(&mut self) -> &mut T
 Available on crate feature runtime only.
pub fn data_mut(&mut self) -> &mut T
runtime only.Access the underlying data owned by this Store.
Same as Store::data_mut.
Sourcepub fn engine(&self) -> &Engine
 Available on crate feature runtime only.
pub fn engine(&self) -> &Engine
runtime only.Returns the underlying Engine this store is connected to.
Sourcepub fn gc(&mut self, why: Option<&GcHeapOutOfMemory<()>>)
 Available on crate features runtime and gc only.
pub fn gc(&mut self, why: Option<&GcHeapOutOfMemory<()>>)
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.
Sourcepub fn get_fuel(&self) -> Result<u64>
 Available on crate feature runtime only.
pub fn get_fuel(&self) -> Result<u64>
runtime only.Returns remaining fuel in this store.
For more information see Store::get_fuel
Sourcepub fn set_fuel(&mut self, fuel: u64) -> Result<()>
 Available on crate feature runtime only.
pub fn set_fuel(&mut self, fuel: u64) -> Result<()>
runtime only.Set the amount of fuel in this store.
For more information see Store::set_fuel
Sourcepub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()>
 Available on crate feature runtime only.
pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()>
runtime only.Configures this Store to periodically yield while executing futures.
For more information see Store::fuel_async_yield_interval
Sourcepub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64)
 Available on crate feature runtime and target_has_atomic=64 only.
pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64)
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.
Sourcepub fn epoch_deadline_trap(&mut self)
 Available on crate feature runtime and target_has_atomic=64 only.
pub fn epoch_deadline_trap(&mut self)
runtime and target_has_atomic=64 only.Configures epoch-deadline expiration to trap.
For more information see Store::epoch_deadline_trap.
Sourcepub fn throw<R>(
    &mut self,
    exception: Rooted<ExnRef>,
) -> Result<R, ThrownException>
 Available on crate features runtime and gc only.
pub fn throw<R>( &mut self, exception: Rooted<ExnRef>, ) -> Result<R, ThrownException>
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.
Sourcepub fn take_pending_exception(&mut self) -> Option<Rooted<ExnRef>>
 Available on crate features runtime and gc only.
pub fn take_pending_exception(&mut self) -> Option<Rooted<ExnRef>>
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.
Sourcepub fn has_pending_exception(&self) -> bool
 Available on crate features runtime and gc only.
pub fn has_pending_exception(&self) -> bool
runtime and gc only.Tests whether there is a pending exception.
See Store::has_pending_exception for more details.
Source§impl<T> StoreContextMut<'_, T>
 
impl<T> StoreContextMut<'_, T>
Sourcepub 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.
pub fn spawn(
    self,
    task: impl AccessorTask<T, HasSelf<T>, Result<()>>,
) -> JoinHandle ⓘwhere
    T: 'static,
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.
Sourcepub 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.
pub async fn run_concurrent<R>(
    self,
    fun: impl AsyncFnOnce(&Accessor<T>) -> R,
) -> Result<R>where
    T: Send + 'static,
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.
§Store-blocking behavior
At this time there are certain situations in which the Future returned
by the AsyncFnOnce passed to this function will not be polled for an
extended period of time, despite one or more Waker::wake events having
occurred for the task to which it belongs.  This can manifest as the
Future seeming to be “blocked” or “locked up”, but is actually due to
the Store being held by e.g. a blocking host function, preventing the
Future from being polled. A canonical example of this is when the
fun provided to this function attempts to set a timeout for an
invocation of a wasm function. In this situation the async closure is
waiting both on (a) the wasm computation to finish, and (b) the timeout
to elapse. At this time this setup will not always work and the timeout
may not reliably fire.
This function will not block the current thread and as such is always
suitable to run in an async context, but the current implementation of
Wasmtime can lead to situations where a certain wasm computation is
required to make progress the closure to make progress. This is an
artifact of Wasmtime’s historical implementation of async functions
and is the topic of #11869 and #11870. In the timeout example from
above it means that Wasmtime can get “wedged” for a bit where (a) must
progress for a readiness notification of (b) to get delivered.
This effectively means that it’s not possible to reliably perform a
“select” operation within the fun closure, which timeouts for example
are based on. Fixing this requires some relatively major refactoring
work within Wasmtime itself. This is a known pitfall otherwise and one
that is intended to be fixed one day. In the meantime it’s recommended
to apply timeouts or such to the entire run_concurrent call itself
rather than internally.
§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§
Source§impl<T: 'static> AsContext for StoreContextMut<'_, T>
Available on crate feature runtime only. 
impl<T: 'static> AsContext for StoreContextMut<'_, T>
runtime only.Source§fn as_context(&self) -> StoreContext<'_, T>
 
fn as_context(&self) -> StoreContext<'_, T>
Source§impl<T: 'static> AsContextMut for StoreContextMut<'_, T>
Available on crate feature runtime only. 
impl<T: 'static> AsContextMut for StoreContextMut<'_, T>
runtime only.Source§fn as_context_mut(&mut self) -> StoreContextMut<'_, T>
 
fn as_context_mut(&mut self) -> StoreContextMut<'_, T>
Source§impl<'a, T: AsContextMut> From<&'a mut T> for StoreContextMut<'a, T::Data>
Available on crate feature runtime only. 
impl<'a, T: AsContextMut> From<&'a mut T> for StoreContextMut<'a, T::Data>
runtime only.Source§impl<'a, T: 'static> From<StoreContextMut<'a, T>> for StoreContext<'a, T>
Available on crate feature runtime only. 
impl<'a, T: 'static> From<StoreContextMut<'a, T>> for StoreContext<'a, T>
runtime only.Source§fn from(store: StoreContextMut<'a, T>) -> StoreContext<'a, T>
 
fn from(store: StoreContextMut<'a, T>) -> StoreContext<'a, T>
Source§impl<I, T> Index<I> for StoreContextMut<'_, T>where
    StoreOpaque: Index<I>,
Available on crate feature runtime only. 
impl<I, T> Index<I> for StoreContextMut<'_, T>where
    StoreOpaque: Index<I>,
runtime only.Auto Trait Implementations§
impl<'a, T> Freeze for StoreContextMut<'a, T>
impl<'a, T> !RefUnwindSafe for StoreContextMut<'a, T>
impl<'a, T> Send for StoreContextMut<'a, T>where
    T: Send,
impl<'a, T> Sync for StoreContextMut<'a, T>where
    T: Sync,
impl<'a, T> Unpin for StoreContextMut<'a, T>
impl<'a, T> !UnwindSafe for StoreContextMut<'a, T>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> IntoEither for T
 
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
 
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
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 moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
 
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
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