Trait EncodeOption 

pub unsafe trait EncodeOption<W, E>: Sized
where
    W: Wire,
    E: ?Sized,
{
    // Required method
    fn encode_option(
        this: Option<Self>,
        encoder: &mut E,
        out: &mut MaybeUninit<W>,
        constraint: <W as Constrained>::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 as Constrained>::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<&'a [T]>, 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<&'a Vec<T>>, 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, &'a T: EncodeOption<W, E>, E: ?Sized,

fn encode_option( this: Option<&'a Box<T>>, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: <W as Constrained>::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<&'a [T; N]>, 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<&bool>, 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<bool>, 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<&i8>, 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<i8>, 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<&u8>, 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<u8>, 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<&()>, 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<()>, 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<&f32>, 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<f32>, 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<&f64>, 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<f64>, 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<&i16>, 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<i16>, 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<&i32>, 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<i32>, 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<&i64>, 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<i64>, 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<&u16>, 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<u16>, 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<&u32>, 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<u32>, 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<&u64>, 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<u64>, encoder: &mut E, out: &mut MaybeUninit<Box<'static, Uint64>>, constraint: <Uint64 as Constrained>::Constraint, ) -> Result<(), EncodeError>

impl<E> EncodeOption<OptionalString<'static>, E> for &str

where E: Encoder + ?Sized,

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

impl<E> EncodeOption<OptionalString<'static>, E> for &String

where E: Encoder + ?Sized,

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

impl<E> EncodeOption<OptionalString<'static>, E> for String

where E: Encoder + ?Sized,

fn encode_option( this: Option<String>, encoder: &mut E, out: &mut MaybeUninit<OptionalString<'static>>, constraint: u64, ) -> 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<Vec<T>>, 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, T: EncodeOption<W, E>, E: ?Sized,

fn encode_option( this: Option<Box<T>>, encoder: &mut E, out: &mut MaybeUninit<W>, constraint: <W as Constrained>::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<[T; N]>, encoder: &mut E, out: &mut MaybeUninit<OptionalVector<'static, W>>, constraint: (u64, <W as Constrained>::Constraint), ) -> Result<(), EncodeError>

Implementors

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

where P: 'static, &'a T: EncodeOption<W, E>, W: Wire<Constraint = ()>, E: ?Sized,

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

where P: 'static, &'a T: EncodeOption<W, E>, W: Wire<Constraint = ()>, E: ?Sized,

impl<E> EncodeOption<OptionalBti, E> for Bti

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalChannel, E> for Channel

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalCounter, E> for Counter

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalDebugLog, E> for DebugLog

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalEvent, E> for Event

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalEventPair, E> for EventPair

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalException, E> for Exception

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalGuest, E> for Guest

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalHandle, E> for NullableHandle

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalIob, E> for Iob

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalIommu, E> for Iommu

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalJob, E> for Job

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalPager, E> for Pager

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalPmt, E> for Pmt

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalPort, E> for Port

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalProcess, E> for Process

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalProfile, E> for Profile

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalResource, E> for Resource

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalSocket, E> for Socket

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalStream, E> for Stream

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalThread, E> for Thread

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalVcpu, E> for Vcpu

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalVmar, E> for Vmar

where E: HandleEncoder + ?Sized,

impl<E> EncodeOption<OptionalVmo, E> for Vmo

where E: HandleEncoder + ?Sized,

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,

impl<E, K, T> EncodeOption<OptionalInterrupt, E> for Interrupt<K, T>

where E: HandleEncoder + ?Sized, K: InterruptKind, T: Timeline,

impl<E, R, W> EncodeOption<OptionalFifo, E> for Fifo<R, W>

where E: HandleEncoder + ?Sized,

impl<E, Reference, Output> EncodeOption<OptionalClock, E> for Clock<Reference, Output>

where E: HandleEncoder + ?Sized, Reference: Timeline, Output: Timeline,

impl<E, T> EncodeOption<OptionalTimer, E> for Timer<T>

where E: HandleEncoder + ?Sized, T: Timeline,

impl<W, E, P, T> EncodeOption<ClientEnd<P, W>, E> for ClientEnd<P, T>

where P: 'static, T: EncodeOption<W, E>, W: Wire<Constraint = ()>, E: ?Sized,

impl<W, E, P, T> EncodeOption<ServerEnd<P, W>, E> for ServerEnd<P, T>

where P: 'static, T: EncodeOption<W, E>, W: Wire<Constraint = ()>, E: ?Sized,