Struct wai_bindgen_rust::Handle

pub struct Handle<T: HandleType> { /* private fields */ }

A type for handles to resources that appear in exported functions.

This type is used as Handle<T> for argument types and return values of exported functions when exposing a Rust-defined resource. A Handle<T> represents an owned reference count on the interface-types-managed resource. It’s similar to an Rc<T> in Rust. Internally a Handle<T> can provide access to &T when T is defined in the current module.

Implementations

impl<T: HandleType> Handle<T>

pub fn new(val: T) -> Handle<T>where
    T: LocalHandle,

Creates a new handle around the specified value.

Note that the lifetime of T will afterwards be managed by the interface types runtime. The host may hold references to T that wasm isn’t necessarily aware of, preventing its destruction. Nevertheless though the Drop for T implementation will still be run when there are no more references to T.

pub fn into_raw(handle: Handle<T>) -> i32

Consumes a handle and returns the underlying raw wasm i32 descriptor.

Note that this, if used improperly, will leak the resource T. This generally should be avoided unless you’re calling raw ABI bindings and managing the lifetime manually.

pub fn as_raw(handle: &Handle<T>) -> i32

Returns the raw underlying handle value for this handle.

This typically isn’t necessary to interact with, but can be useful when interacting with raw ABI bindings.

pub unsafe fn from_raw(val: i32) -> Handle<T>

Unsafely assumes that the given integer descriptor is a handle for T.

This is unsafe because no validation is performed to ensure that val is actually a valid descriptor for T.

Trait Implementations

impl<T: HandleType> Clone for Handle<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: HandleType> Debug for Handle<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: LocalHandle> Deref for Handle<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: HandleType> Drop for Handle<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: LocalHandle> From<T> for Handle<T>

fn from(val: T) -> Handle<T>

Converts to this type from the input type.