Trait WasmAbi

pub trait WasmAbi {
    type Prim1: WasmPrimitive;
    type Prim2: WasmPrimitive;
    type Prim3: WasmPrimitive;
    type Prim4: WasmPrimitive;

    // Required methods
    fn split(self) -> (Self::Prim1, Self::Prim2, Self::Prim3, Self::Prim4);
    fn join(
        prim1: Self::Prim1,
        prim2: Self::Prim2,
        prim3: Self::Prim3,
        prim4: Self::Prim4,
    ) -> Self;
}

A trait which represents types that can be passed across the Wasm ABI boundary, by being split into multiple Wasm primitive types.

Up to 4 primitives are supported; if you don’t want to use all of them, you can set the rest to (), which will cause them to be ignored.

You need to be careful how many primitives you use, however: Result<T, JsValue> uses up 2 primitives to store the error, and so it doesn’t work if T uses more than 2 primitives.

So, if you’re adding support for a type that needs 3 or more primitives and is able to be returned, you have to add another primitive here.

There’s already one type that uses 3 primitives: &mut [T]. However, it can’t be returned anyway, so it doesn’t matter that Result<&mut [T], JsValue> wouldn’t work.

⚠️ Unstable

This is part of the internal convert module, no stability guarantees are provided. Use at your own risk. See its documentation for more details.

Required Associated Types

type Prim1: WasmPrimitive

type Prim2: WasmPrimitive

type Prim3: WasmPrimitive

type Prim4: WasmPrimitive

Required Methods

fn split(self) -> (Self::Prim1, Self::Prim2, Self::Prim3, Self::Prim4)

Splits this type up into primitives to be sent over the ABI.

fn join( prim1: Self::Prim1, prim2: Self::Prim2, prim3: Self::Prim3, prim4: Self::Prim4, ) -> Self

Reconstructs this type from primitives received over the ABI.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T> WasmAbi for Option<T>

where T: WasmAbi<Prim4 = ()>,

type Prim1 = u32

Whether this Option is a Some value.

type Prim2 = <T as WasmAbi>::Prim1

type Prim3 = <T as WasmAbi>::Prim2

type Prim4 = <T as WasmAbi>::Prim3

fn split( self, ) -> (u32, <T as WasmAbi>::Prim1, <T as WasmAbi>::Prim2, <T as WasmAbi>::Prim3)

fn join( is_some: u32, prim1: <T as WasmAbi>::Prim1, prim2: <T as WasmAbi>::Prim2, prim3: <T as WasmAbi>::Prim3, ) -> Option<T>

impl<T> WasmAbi for Result<T, u32>

where T: WasmAbi<Prim3 = (), Prim4 = ()>,

type Prim3 = u32

If this Result is an Err, the error value.

type Prim4 = u32

Whether this Result is an Err.

type Prim1 = <T as WasmAbi>::Prim1

type Prim2 = <T as WasmAbi>::Prim2

fn split(self) -> (<T as WasmAbi>::Prim1, <T as WasmAbi>::Prim2, u32, u32)

fn join( prim1: <T as WasmAbi>::Prim1, prim2: <T as WasmAbi>::Prim2, err: u32, is_err: u32, ) -> Result<T, u32>

Implementors

impl WasmAbi for WasmSlice

type Prim1 = u32

type Prim2 = u32

type Prim3 = ()

type Prim4 = ()

impl<T> WasmAbi for T

where T: WasmPrimitive,

type Prim1 = T

type Prim2 = ()

type Prim3 = ()

type Prim4 = ()