Trait linera_witty::WitLoad

pub trait WitLoad: WitType + Sized {
    // Required methods
    fn load<Instance>(
        memory: &Memory<'_, Instance>,
        location: GuestPointer,
    ) -> Result<Self, RuntimeError>
       where Instance: InstanceWithMemory,
             <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>;
    fn lift_from<Instance>(
        flat_layout: <Self::Layout as Layout>::Flat,
        memory: &Memory<'_, Instance>,
    ) -> Result<Self, RuntimeError>
       where Instance: InstanceWithMemory,
             <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>;
}

A type that can be loaded from a guest Wasm module.

Required Methods

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

Loads an instance of the type from the location in the guest’s memory.

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

Lifts an instance of the type from the flat_layout representation.

May read from the memory if the type has references to heap data.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl WitLoad for Level

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for bool

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for f32

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for f64

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for i8

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for i16

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for i32

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for i64

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for i128

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for u8

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for u16

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for u32

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for u64

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for u128

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for ()

where HNil: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for String

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl WitLoad for Duration

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A> WitLoad for (A,)

where A: WitLoad, HCons<A, HNil>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B> WitLoad for (A, B)

where A: WitLoad, B: WitLoad, HCons<A, HCons<B, HNil>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C> WitLoad for (A, B, C)

where A: WitLoad, B: WitLoad, C: WitLoad, HCons<A, HCons<B, HCons<C, HNil>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D> WitLoad for (A, B, C, D)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HNil>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E> WitLoad for (A, B, C, D, E)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HNil>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F> WitLoad for (A, B, C, D, E, F)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HNil>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G> WitLoad for (A, B, C, D, E, F, G)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HNil>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H> WitLoad for (A, B, C, D, E, F, G, H)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HNil>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I> WitLoad for (A, B, C, D, E, F, G, H, I)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HNil>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J> WitLoad for (A, B, C, D, E, F, G, H, I, J)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HNil>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K> WitLoad for (A, B, C, D, E, F, G, H, I, J, K)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HNil>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HNil>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HNil>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HNil>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HNil>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HNil>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HNil>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HNil>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HNil>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HNil>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, U: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HNil>>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, U: WitLoad, V: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HNil>>>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, U: WitLoad, V: WitLoad, W: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HNil>>>>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, U: WitLoad, V: WitLoad, W: WitLoad, X: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HNil>>>>>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, U: WitLoad, V: WitLoad, W: WitLoad, X: WitLoad, Y: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HCons<Y, HNil>>>>>>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> WitLoad for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: WitLoad, B: WitLoad, C: WitLoad, D: WitLoad, E: WitLoad, F: WitLoad, G: WitLoad, H: WitLoad, I: WitLoad, J: WitLoad, K: WitLoad, L: WitLoad, M: WitLoad, N: WitLoad, O: WitLoad, P: WitLoad, Q: WitLoad, R: WitLoad, S: WitLoad, T: WitLoad, U: WitLoad, V: WitLoad, W: WitLoad, X: WitLoad, Y: WitLoad, Z: WitLoad, HCons<A, HCons<B, HCons<C, HCons<D, HCons<E, HCons<F, HCons<G, HCons<H, HCons<I, HCons<J, HCons<K, HCons<L, HCons<M, HCons<N, HCons<O, HCons<P, HCons<Q, HCons<R, HCons<S, HCons<T, HCons<U, HCons<V, HCons<W, HCons<X, HCons<Y, HCons<Z, HNil>>>>>>>>>>>>>>>>>>>>>>>>>>: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<K, V> WitLoad for BTreeMap<K, V>

where K: WitType + Ord, V: WitType, (K, V): WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Option<T>

where T: WitLoad, HNil: Merge<T::Layout>, <HNil as Merge<T::Layout>>::Output: Layout, <T::Layout as Layout>::Flat: JoinFlatLayouts<<<HNil as Merge<T::Layout>>::Output as Layout>::Flat>,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Box<[T]>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Box<T>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for BTreeSet<T>

where T: WitType + Ord + WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Rc<[T]>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Rc<T>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Arc<[T]>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Arc<T>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for Vec<T>

where T: WitLoad,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( flat_layout: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T> WitLoad for PhantomData<T>

fn load<Instance>( _memory: &Memory<'_, Instance>, _location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _flat_layout: <Self::Layout as Layout>::Flat, _memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

impl<T, E> WitLoad for Result<T, E>

where T: WitLoad, E: WitLoad, T::Layout: Merge<E::Layout>, <T::Layout as Merge<E::Layout>>::Output: Layout, <T::Layout as Layout>::Flat: JoinFlatLayouts<<<T::Layout as Merge<E::Layout>>::Output as Layout>::Flat>, <E::Layout as Layout>::Flat: JoinFlatLayouts<<<T::Layout as Merge<E::Layout>>::Output as Layout>::Flat>,

fn load<Instance>( memory: &Memory<'_, Instance>, location: GuestPointer, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

fn lift_from<Instance>( _: <Self::Layout as Layout>::Flat, memory: &Memory<'_, Instance>, ) -> Result<Self, RuntimeError>

where Instance: InstanceWithMemory, <Instance::Runtime as Runtime>::Memory: RuntimeMemory<Instance>,

Implementors

impl WitLoad for GuestPointer

impl WitLoad for HNil

impl<Head, Tail> WitLoad for HCons<Head, Tail>

where Head: WitLoad, Tail: WitLoad + SizeCalculation, Head::Layout: Add<Tail::Layout>, <Head::Layout as Add<Tail::Layout>>::Output: Layout, <Self::Layout as Layout>::Flat: Split<<Head::Layout as Layout>::Flat, Remainder = <Tail::Layout as Layout>::Flat>,