Struct ExnRefPre 

pub struct ExnRefPre { /* private fields */ }

An allocator for a particular Wasm GC exception type.

Every ExnRefPre is associated with a particular Store and a particular ExnType.

Reusing an allocator across many allocations amortizes some per-type runtime overheads inside Wasmtime. An ExnRefPre is to ExnRefs as an InstancePre is to Instances.

Example

use wasmtime::*;

let mut config = Config::new();
config.wasm_function_references(true);
config.wasm_gc(true);

let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());

// Define a exn type.
let exn_ty = ExnType::new(
   store.engine(),
   [ValType::I32],
)?;

// Create an allocator for the exn type.
let allocator = ExnRefPre::new(&mut store, exn_ty.clone());

// Create a tag instance to associate with our exception objects.
let tag = Tag::new(&mut store, &exn_ty.tag_type()).unwrap();

{
    let mut scope = RootScope::new(&mut store);

    // Allocate a bunch of instances of our exception type using the same
    // allocator! This is faster than creating a new allocator for each
    // instance we want to allocate.
    for i in 0..10 {
        ExnRef::new(&mut scope, &allocator, &tag, &[Val::I32(i)])?;
    }
}

Implementations

impl ExnRefPre

pub fn new(store: impl AsContextMut, ty: ExnType) -> ExnRefPre

Create a new ExnRefPre that is associated with the given store and type.

Panics

Panics if ty was not created with the same Engine as store.