Trait EncodeOption 

pub unsafe trait EncodeOption<W: Wire, E: ?Sized>: Sized {
    // Required method
    fn encode_option(
        this: Option<Self>,
        encoder: &mut E,
        out: &mut MaybeUninit<W>,
        constraint: W::Constraint,
    ) -> Result<(), EncodeError>;
}

Encodes an optional value.

Safety

encode_option must initialize all non-padding bytes of out.

Required Methods

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: W::Constraint, ) -> Result<(), EncodeError>

Encodes this optional 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, W, E, T> EncodeOption<OptionalVector<'static, W>, E> for &'a [T]

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

impl<'a, W, E, T> EncodeOption<OptionalVector<'static, W>, E> for &'a Vec<T>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

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

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: W::Constraint, ) -> Result<(), EncodeError>

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

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, bool>, E> for &bool

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, bool>>, constraint: <bool as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, bool>, E> for bool

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, bool>>, constraint: <bool as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, i8>, E> for &i8

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, i8>>, constraint: <i8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, i8>, E> for i8

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, i8>>, constraint: <i8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, u8>, E> for &u8

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, u8>>, constraint: <u8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, u8>, E> for u8

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, u8>>, constraint: <u8 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, ()>, E> for &()

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, ()>>, constraint: <() as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, ()>, E> for ()

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, ()>>, constraint: <() as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Float32>, E> for &f32

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Float32>>, constraint: <Float32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Float32>, E> for f32

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Float32>>, constraint: <Float32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Float64>, E> for &f64

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Float64>>, constraint: <Float64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Float64>, E> for f64

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Float64>>, constraint: <Float64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Int16>, E> for &i16

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Int16>>, constraint: <Int16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Int16>, E> for i16

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Int16>>, constraint: <Int16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Int32>, E> for &i32

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Int32>>, constraint: <Int32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Int32>, E> for i32

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Int32>>, constraint: <Int32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Int64>, E> for &i64

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Int64>>, constraint: <Int64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Int64>, E> for i64

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Int64>>, constraint: <Int64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Uint16>, E> for &u16

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint16>>, constraint: <Uint16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Uint16>, E> for u16

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint16>>, constraint: <Uint16 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Uint32>, E> for &u32

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint32>>, constraint: <Uint32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Uint32>, E> for u32

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint32>>, constraint: <Uint32 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Uint64>, E> for &u64

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint64>>, constraint: <Uint64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<Box<'static, Uint64>, E> for u64

where E: Encoder + ?Sized,

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint64>>, constraint: <Uint64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E: Encoder + ?Sized> EncodeOption<OptionalString<'static>, E> for &str

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalString<'static>>, _constraint: u64, ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalString<'static>>, constraint: u64, ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalString<'static>>, constraint: u64, ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalBti>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalChannel>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalCounter>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalDebugLog>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalEvent>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalEventPair>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalException>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalGuest>, constraint: (), ) -> Result<(), EncodeError>

impl<E: HandleEncoder + ?Sized> EncodeOption<OptionalHandle, E> for NullableHandle

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalHandle>, _constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalIob>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalIommu>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalJob>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalPager>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalPmt>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalPort>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalProcess>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalProfile>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalResource>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalSocket>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalStream>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalThread>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVcpu>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVmar>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVmo>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalInterrupt>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalFifo>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalClock>, constraint: (), ) -> Result<(), EncodeError>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalTimer>, constraint: (), ) -> Result<(), EncodeError>

impl<W, E, T> EncodeOption<OptionalVector<'static, W>, E> for Vec<T>

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

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

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: W::Constraint, ) -> Result<(), EncodeError>

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

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

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<OptionalVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

Implementors

impl<E> EncodeOption<Box<'static, Float32>, E> for &Float32

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Float32>, E> for Float32

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Float64>, E> for &Float64

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Float64>, E> for Float64

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Int16>, E> for &Int16

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Int16>, E> for Int16

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Int32>, E> for &Int32

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Int32>, E> for Int32

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Int64>, E> for &Int64

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Int64>, E> for Int64

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Uint16>, E> for &Uint16

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Uint16>, E> for Uint16

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Uint32>, E> for &Uint32

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Uint32>, E> for Uint32

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Uint64>, E> for &Uint64

where E: Encoder + ?Sized,

impl<E> EncodeOption<Box<'static, Uint64>, E> for Uint64

where E: Encoder + ?Sized,