Trait Encode 

pub unsafe trait Encode<W: Constrained, E: ?Sized>: Sized {
    const COPY_OPTIMIZATION: CopyOptimization<Self, W> = _;

    // Required method
    fn encode(
        self,
        encoder: &mut E,
        out: &mut MaybeUninit<W>,
        constraint: W::Constraint,
    ) -> Result<(), EncodeError>;
}

Encodes a value.

Safety

encode must initialize all non-padding bytes of out.

Provided Associated Constants

const COPY_OPTIMIZATION: CopyOptimization<Self, W> = _

Whether the conversion from Self to W is equivalent to copying the raw bytes of Self.

Copy optimization is disabled by default.

Required Methods

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: W::Constraint, ) -> Result<(), EncodeError>

Encodes this value into an encoder and output.

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<'a, E: ?Sized> Encode<bool, E> for &'a bool

fn encode( self, _: &mut E, out: &mut MaybeUninit<bool>, _constraint: <bool as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<i8, E> for &'a i8

fn encode( self, _: &mut E, out: &mut MaybeUninit<i8>, _constraint: <i8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<u8, E> for &'a u8

fn encode( self, _: &mut E, out: &mut MaybeUninit<u8>, _constraint: <u8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<(), E> for &'a ()

fn encode( self, _: &mut E, out: &mut MaybeUninit<()>, _constraint: <() as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireF32, E> for &'a f32

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireF32>, _constraint: <WireF32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireF64, E> for &'a f64

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireF64>, _constraint: <WireF64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireI16, E> for &'a i16

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireI16>, _constraint: <WireI16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireI32, E> for &'a i32

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireI32>, _constraint: <WireI32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireI64, E> for &'a i64

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireI64>, _constraint: <WireI64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireU16, E> for &'a u16

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireU16>, _constraint: <WireU16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireU32, E> for &'a u32

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireU32>, _constraint: <WireU32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, E: ?Sized> Encode<WireU64, E> for &'a u64

fn encode( self, _: &mut E, out: &mut MaybeUninit<WireU64>, _constraint: <WireU64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, Enc, WT, T, WE, E> Encode<WireResult<'static, WT, WE>, Enc> for &'a Result<T, E>

where Enc: Encoder + ?Sized, WT: Constrained<Constraint = ()> + Wire, &'a T: Encode<WT, Enc>, WE: Constrained<Constraint = ()> + Wire, &'a E: Encode<WE, Enc>,

fn encode( self, encoder: &mut Enc, out: &mut MaybeUninit<WireResult<'static, WT, WE>>, _: (), ) -> Result<(), EncodeError>

impl<'a, W, E, T> Encode<WireVector<'static, W>, E> for &'a [T]

where W: Constrained + Wire, E: Encoder + ?Sized, T: Encode<W, E>, &'a T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

impl<'a, W, E, T> Encode<WireVector<'static, W>, E> for &'a Vec<T>

where W: Constrained + Wire, E: Encoder + ?Sized, T: Encode<W, E>, &'a T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

impl<'a, W, E, T> Encode<W, E> for &'a Option<T>

where W: Constrained, E: ?Sized, Option<&'a T>: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: <W as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, W, E, T> Encode<W, E> for &'a Box<T>

where W: Constrained, E: ?Sized, &'a T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: <W as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, W, E, T, const N: usize> Encode<[W; N], E> for &'a [T; N]

where W: Constrained, E: ?Sized, T: Encode<W, E>, &'a T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<[W; N]>, constraint: <W as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<'a, W, E, T, const N: usize> Encode<WireVector<'static, W>, E> for &'a [T; N]

where W: Constrained + Wire, E: Encoder + ?Sized, T: Encode<W, E>, &'a T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

impl<E: Encoder + ?Sized> Encode<WireString<'static>, E> for &str

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireString<'static>>, _constraint: u64, ) -> Result<(), EncodeError>

impl<E: Encoder + ?Sized> Encode<WireString<'static>, E> for &String

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireString<'static>>, constraint: u64, ) -> Result<(), EncodeError>

impl<E: Encoder + ?Sized> Encode<WireString<'static>, E> for String

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireString<'static>>, constraint: u64, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireBti, E> for Bti

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireBti>, constraint: <WireBti as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireChannel, E> for Channel

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireChannel>, constraint: <WireChannel as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireClock, E> for Clock

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireClock>, constraint: <WireClock as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireCounter, E> for Counter

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireCounter>, constraint: <WireCounter as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireDebugLog, E> for DebugLog

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireDebugLog>, constraint: <WireDebugLog as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireEvent, E> for Event

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireEvent>, constraint: <WireEvent as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireEventPair, E> for EventPair

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireEventPair>, constraint: <WireEventPair as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireException, E> for Exception

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireException>, constraint: <WireException as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireFifo, E> for Fifo

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireFifo>, constraint: <WireFifo as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireGuest, E> for Guest

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireGuest>, constraint: <WireGuest as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireInterrupt, E> for Interrupt

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireInterrupt>, constraint: <WireInterrupt as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireIob, E> for Iob

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireIob>, constraint: <WireIob as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireIommu, E> for Iommu

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireIommu>, constraint: <WireIommu as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireJob, E> for Job

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireJob>, constraint: <WireJob as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WirePager, E> for Pager

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WirePager>, constraint: <WirePager as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WirePmt, E> for Pmt

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WirePmt>, constraint: <WirePmt as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WirePort, E> for Port

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WirePort>, constraint: <WirePort as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireProcess, E> for Process

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireProcess>, constraint: <WireProcess as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireProfile, E> for Profile

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireProfile>, constraint: <WireProfile as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireResource, E> for Resource

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireResource>, constraint: <WireResource as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireSocket, E> for Socket

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireSocket>, constraint: <WireSocket as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireStream, E> for Stream

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireStream>, constraint: <WireStream as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireThread, E> for Thread

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireThread>, constraint: <WireThread as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireTimer, E> for Timer

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireTimer>, constraint: <WireTimer as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireVcpu, E> for Vcpu

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVcpu>, constraint: <WireVcpu as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireVmar, E> for Vmar

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVmar>, constraint: <WireVmar as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireVmo, E> for Vmo

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVmo>, constraint: <WireVmo as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> Encode<WireHandle, E> for Handle

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireHandle>, _constraint: (), ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<bool, E> for bool

const COPY_OPTIMIZATION: CopyOptimization<bool, bool> = CopyOptimization<bool, bool>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<bool>, constraint: <bool as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<i8, E> for i8

const COPY_OPTIMIZATION: CopyOptimization<i8, i8> = CopyOptimization<i8, i8>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<i8>, constraint: <i8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<u8, E> for u8

const COPY_OPTIMIZATION: CopyOptimization<u8, u8> = CopyOptimization<u8, u8>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<u8>, constraint: <u8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<(), E> for ()

const COPY_OPTIMIZATION: CopyOptimization<(), ()> = CopyOptimization<(), ()>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<()>, constraint: <() as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireObjectType, E> for &ObjectType

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireObjectType>, constraint: (), ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireObjectType, E> for ObjectType

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireObjectType>, constraint: (), ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireRights, E> for &Rights

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireRights>, constraint: (), ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireRights, E> for Rights

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireRights>, constraint: (), ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireF32, E> for f32

const COPY_OPTIMIZATION: CopyOptimization<f32, WireF32> = CopyOptimization<f32, WireF32>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireF32>, constraint: <WireF32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireF64, E> for f64

const COPY_OPTIMIZATION: CopyOptimization<f64, WireF64> = CopyOptimization<f64, WireF64>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireF64>, constraint: <WireF64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireI16, E> for i16

const COPY_OPTIMIZATION: CopyOptimization<i16, WireI16> = CopyOptimization<i16, WireI16>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireI16>, constraint: <WireI16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireI32, E> for i32

const COPY_OPTIMIZATION: CopyOptimization<i32, WireI32> = CopyOptimization<i32, WireI32>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireI32>, constraint: <WireI32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireI64, E> for i64

const COPY_OPTIMIZATION: CopyOptimization<i64, WireI64> = CopyOptimization<i64, WireI64>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireI64>, constraint: <WireI64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireU16, E> for u16

const COPY_OPTIMIZATION: CopyOptimization<u16, WireU16> = CopyOptimization<u16, WireU16>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireU16>, constraint: <WireU16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireU32, E> for u32

const COPY_OPTIMIZATION: CopyOptimization<u32, WireU32> = CopyOptimization<u32, WireU32>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireU32>, constraint: <WireU32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: ?Sized> Encode<WireU64, E> for u64

const COPY_OPTIMIZATION: CopyOptimization<u64, WireU64> = CopyOptimization<u64, WireU64>::PRIMITIVE

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireU64>, constraint: <WireU64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<Enc, WT, T, WE, E> Encode<WireResult<'static, WT, WE>, Enc> for Result<T, E>

where Enc: Encoder + ?Sized, WT: Constrained<Constraint = ()> + Wire, T: Encode<WT, Enc>, WE: Constrained<Constraint = ()> + Wire, E: Encode<WE, Enc>,

fn encode( self, encoder: &mut Enc, out: &mut MaybeUninit<WireResult<'static, WT, WE>>, _: (), ) -> Result<(), EncodeError>

impl<W, E, T> Encode<WireVector<'static, W>, E> for Vec<T>

where W: Constrained + Wire, E: Encoder + ?Sized, T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

impl<W, E, T> Encode<W, E> for Option<T>

where W: Constrained, E: ?Sized, T: EncodeOption<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: <W as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<W, E, T> Encode<W, E> for Box<T>

where W: Constrained, E: ?Sized, T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: <W as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<W, E, T, const N: usize> Encode<[W; N], E> for [T; N]

where W: Constrained, E: ?Sized, T: Encode<W, E>,

const COPY_OPTIMIZATION: CopyOptimization<Self, [W; N]>

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<[W; N]>, constraint: <W as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<W, E, T, const N: usize> Encode<WireVector<'static, W>, E> for [T; N]

where W: Constrained + Wire, E: Encoder + ?Sized, T: Encode<W, E>,

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<WireVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

Implementors

impl<'a, E: ?Sized> Encode<WireF32, E> for &'a WireF32

impl<'a, E: ?Sized> Encode<WireF64, E> for &'a WireF64

impl<'a, E: ?Sized> Encode<WireI16, E> for &'a WireI16

impl<'a, E: ?Sized> Encode<WireI32, E> for &'a WireI32

impl<'a, E: ?Sized> Encode<WireI64, E> for &'a WireI64

impl<'a, E: ?Sized> Encode<WireU16, E> for &'a WireU16

impl<'a, E: ?Sized> Encode<WireU32, E> for &'a WireU32

impl<'a, E: ?Sized> Encode<WireU64, E> for &'a WireU64

impl<E: ?Sized> Encode<WireF32, E> for WireF32

const COPY_OPTIMIZATION: CopyOptimization<WireF32, WireF32> = CopyOptimization<WireF32, WireF32>::PRIMITIVE

impl<E: ?Sized> Encode<WireF64, E> for WireF64

const COPY_OPTIMIZATION: CopyOptimization<WireF64, WireF64> = CopyOptimization<WireF64, WireF64>::PRIMITIVE

impl<E: ?Sized> Encode<WireI16, E> for WireI16

const COPY_OPTIMIZATION: CopyOptimization<WireI16, WireI16> = CopyOptimization<WireI16, WireI16>::PRIMITIVE

impl<E: ?Sized> Encode<WireI32, E> for WireI32

const COPY_OPTIMIZATION: CopyOptimization<WireI32, WireI32> = CopyOptimization<WireI32, WireI32>::PRIMITIVE

impl<E: ?Sized> Encode<WireI64, E> for WireI64

const COPY_OPTIMIZATION: CopyOptimization<WireI64, WireI64> = CopyOptimization<WireI64, WireI64>::PRIMITIVE

impl<E: ?Sized> Encode<WireU16, E> for WireU16

const COPY_OPTIMIZATION: CopyOptimization<WireU16, WireU16> = CopyOptimization<WireU16, WireU16>::PRIMITIVE

impl<E: ?Sized> Encode<WireU32, E> for WireU32

const COPY_OPTIMIZATION: CopyOptimization<WireU32, WireU32> = CopyOptimization<WireU32, WireU32>::PRIMITIVE

impl<E: ?Sized> Encode<WireU64, E> for WireU64

const COPY_OPTIMIZATION: CopyOptimization<WireU64, WireU64> = CopyOptimization<WireU64, WireU64>::PRIMITIVE

impl<W: Constrained, E: ?Sized> Encode<W, E> for Never