Trait Encode 

pub unsafe trait Encode<W: Wire, 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, Enc, WT, T, WE, E> Encode<Result<'static, WT, WE>, Enc> for &'a Result<T, E>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<E: HandleEncoder + ?Sized, K: InterruptKind, T: Timeline> Encode<Interrupt, E> for Interrupt<K, T>

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

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

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

impl<E: HandleEncoder + ?Sized, Reference: Timeline, Output: Timeline> Encode<Clock, E> for Clock<Reference, Output>

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

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

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

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

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

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

const COPY_OPTIMIZATION: CopyOptimization<bool, bool> = crate::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

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

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

const COPY_OPTIMIZATION: CopyOptimization<i8, i8> = crate::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

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

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

const COPY_OPTIMIZATION: CopyOptimization<u8, u8> = crate::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 &()

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

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

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

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

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

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

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

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

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

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

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

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

impl<E: ?Sized> Encode<Float32, E> for &f32

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

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

const COPY_OPTIMIZATION: CopyOptimization<f32, Float32> = crate::CopyOptimization<f32, Float32>::PRIMITIVE

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

impl<E: ?Sized> Encode<Float64, E> for &f64

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

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

const COPY_OPTIMIZATION: CopyOptimization<f64, Float64> = crate::CopyOptimization<f64, Float64>::PRIMITIVE

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

impl<E: ?Sized> Encode<Int16, E> for &i16

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

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

const COPY_OPTIMIZATION: CopyOptimization<i16, Int16> = crate::CopyOptimization<i16, Int16>::PRIMITIVE

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

impl<E: ?Sized> Encode<Int32, E> for &i32

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

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

const COPY_OPTIMIZATION: CopyOptimization<i32, Int32> = crate::CopyOptimization<i32, Int32>::PRIMITIVE

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

impl<E: ?Sized> Encode<Int64, E> for &i64

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

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

const COPY_OPTIMIZATION: CopyOptimization<i64, Int64> = crate::CopyOptimization<i64, Int64>::PRIMITIVE

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

impl<E: ?Sized> Encode<Uint16, E> for &u16

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

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

const COPY_OPTIMIZATION: CopyOptimization<u16, Uint16> = crate::CopyOptimization<u16, Uint16>::PRIMITIVE

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

impl<E: ?Sized> Encode<Uint32, E> for &u32

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

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

const COPY_OPTIMIZATION: CopyOptimization<u32, Uint32> = crate::CopyOptimization<u32, Uint32>::PRIMITIVE

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

impl<E: ?Sized> Encode<Uint64, E> for &u64

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

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

const COPY_OPTIMIZATION: CopyOptimization<u64, Uint64> = crate::CopyOptimization<u64, Uint64>::PRIMITIVE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

where W: Wire, 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::Constraint, ) -> Result<(), EncodeError>

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

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

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

Implementors

impl<E: ?Sized> Encode<Float32, E> for &Float32

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

const COPY_OPTIMIZATION: CopyOptimization<Float32, Float32> = crate::CopyOptimization<Float32, Float32>::PRIMITIVE

impl<E: ?Sized> Encode<Float64, E> for &Float64

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

const COPY_OPTIMIZATION: CopyOptimization<Float64, Float64> = crate::CopyOptimization<Float64, Float64>::PRIMITIVE

impl<E: ?Sized> Encode<Int16, E> for &Int16

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

const COPY_OPTIMIZATION: CopyOptimization<Int16, Int16> = crate::CopyOptimization<Int16, Int16>::PRIMITIVE

impl<E: ?Sized> Encode<Int32, E> for &Int32

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

const COPY_OPTIMIZATION: CopyOptimization<Int32, Int32> = crate::CopyOptimization<Int32, Int32>::PRIMITIVE

impl<E: ?Sized> Encode<Int64, E> for &Int64

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

const COPY_OPTIMIZATION: CopyOptimization<Int64, Int64> = crate::CopyOptimization<Int64, Int64>::PRIMITIVE

impl<E: ?Sized> Encode<Uint16, E> for &Uint16

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

const COPY_OPTIMIZATION: CopyOptimization<Uint16, Uint16> = crate::CopyOptimization<Uint16, Uint16>::PRIMITIVE

impl<E: ?Sized> Encode<Uint32, E> for &Uint32

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

const COPY_OPTIMIZATION: CopyOptimization<Uint32, Uint32> = crate::CopyOptimization<Uint32, Uint32>::PRIMITIVE

impl<E: ?Sized> Encode<Uint64, E> for &Uint64

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

const COPY_OPTIMIZATION: CopyOptimization<Uint64, Uint64> = crate::CopyOptimization<Uint64, Uint64>::PRIMITIVE

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