Union zerovec::ule::NichedOptionULE

#[repr(C)]
pub union NichedOptionULE<U: NicheBytes<N> + ULE, const N: usize> {
    /* private fields */
}

ULE type for NichedOption<U,N> where U implements NicheBytes. The invalid bit pattern is used as the niche.

This uses 1 byte less than crate::ule::OptionULE<U> to represent NichedOption<U,N>.

Example

use core::num::NonZeroI8;
use zerovec::ule::NichedOption;
use zerovec::ZeroVec;

let bytes = &[0x00, 0x01, 0x02, 0x00];
let zv_no: ZeroVec<NichedOption<NonZeroI8, 1>> =
    ZeroVec::parse_byte_slice(bytes)
        .expect("Unable to parse as NichedOption.");

assert_eq!(zv_no.get(0).map(|e| e.0), Some(None));
assert_eq!(zv_no.get(1).map(|e| e.0), Some(NonZeroI8::new(1)));
assert_eq!(zv_no.get(2).map(|e| e.0), Some(NonZeroI8::new(2)));
assert_eq!(zv_no.get(3).map(|e| e.0), Some(None));

Implementations

impl<U: NicheBytes<N> + ULE, const N: usize> NichedOptionULE<U, N>

pub fn new(opt: Option<U>) -> Self

New NichedOptionULE<U, N> from Option<U>

pub fn get(self) -> Option<U>

Convert to an Option<U>

Trait Implementations

impl<U: NicheBytes<N> + ULE, const N: usize> Clone for NichedOptionULE<U, N>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<U: NicheBytes<N> + ULE + Debug, const N: usize> Debug for NichedOptionULE<U, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<U: NicheBytes<N> + ULE + PartialEq, const N: usize> PartialEq for NichedOptionULE<U, N>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<U: NicheBytes<N> + ULE, const N: usize> ULE for NichedOptionULE<U, N>

Safety for ULE trait

1. NichedOptionULE does not have any padding bytes due to #[repr(C)] on a struct containing only ULE fields. NichedOptionULE either contains NICHE_BIT_PATTERN or valid U byte sequences. In both cases the data is initialized.
2. NichedOptionULE is aligned to 1 byte due to #[repr(C, packed)] on a struct containing only ULE fields.
3. validate_byte_slice impl returns an error if invalid bytes are encountered.
4. validate_byte_slice impl returns an error there are extra bytes.
5. The other ULE methods are left to their default impl.
6. NichedOptionULE equality is based on ULE equality of the subfield, assuming that NicheBytes has been implemented correctly (this is a correctness but not a safety guarantee).

fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError>

Validates a byte slice, &[u8].

fn parse_byte_slice(bytes: &[u8]) -> Result<&[Self], ZeroVecError>

Parses a byte slice, &[u8], and return it as &[Self] with the same lifetime.

unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &[Self]

Takes a byte slice, &[u8], and return it as &[Self] with the same lifetime, assuming that this byte slice has previously been run through Self::parse_byte_slice() with success.

fn as_byte_slice(slice: &[Self]) -> &[u8]

Given &[Self], returns a &[u8] with the same lifetime.

impl<U: NicheBytes<N> + ULE, const N: usize> Copy for NichedOptionULE<U, N>

impl<U: NicheBytes<N> + ULE + Eq, const N: usize> Eq for NichedOptionULE<U, N>