Struct MaybeData 

pub struct MaybeData<'a, Data>
where
    Data: TrivialType,
{ /* private fields */ }

Wrapper type for Data that may or may not be filled with contents.

This is somewhat similar to VariableElements, but instead of a variable number of elements, data structure allows either having it or not having the contents, which is a simpler and more appropriate API in many cases.

It is a view of memory that is borrowed for 'a.

Implementations

impl<'a, Data> MaybeData<'a, Data>

where Data: TrivialType, Self: IoType,

pub const fn from_ref(data: Option<&'a Data>) -> impl Deref<Target = Self> + 'a

Create a new shared instance from provided data reference.

pub fn from_mut(buffer: &'a mut Data, size: &'a mut u32) -> Option<Self>

Create a new exclusive instance from provided data reference.

size can be either 0 or Data::SIZE, indicating that value is missing or present accordingly.

Returns None if size is neither 0 nor Data::SIZE.

pub fn from_uninit( uninit: &'a mut MaybeUninit<Data>, size: &'a mut u32, ) -> Option<Self>

Create a new exclusive instance from provided uninitialized memory.

size must be 0 since data is not initialized yet.

Returns None if size != 0.

pub const fn get(&self) -> Option<&Data>

Try to get access to initialized Data, returns None if not initialized

pub fn get_mut(&mut self) -> Option<&mut Data>

Try to get exclusive access to initialized Data, returns None if not initialized

pub fn replace(&mut self, data: Data) -> &mut Data

Initialize by inserting Data by value or replace existing value and return reference to it

pub fn remove(&mut self)

Remove Data inside and turn instance back into uninitialized

pub fn get_mut_or_init_with<Init>(&mut self, init: Init) -> &mut Data

where Init: FnOnce(&mut MaybeUninit<Data>) -> &mut Data,

Get exclusive access to initialized Data, running provided initialization function if necessary.

init is expected to initialize provided memory and return a reference to it, like MaybeUninit::write() does. If it returns a reference to some other Data instead, that value is copied into this instance.

pub unsafe fn assume_init(&mut self) -> &mut Data

Assume value is initialized

Safety

Caller must ensure Data is actually properly initialized

impl<Data> MaybeData<'_, Data>

where Data: TrivialType + Default, Self: IoType,

pub fn get_mut_or_default(&mut self) -> &mut Data

Get exclusive access to initialized Data, initializing with default value if necessary

Trait Implementations

impl<'a, Data> Debug for MaybeData<'a, Data>

where Data: TrivialType + Debug,

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

Formats the value using the given formatter.

impl<Data> IoType for MaybeData<'_, Data>

where Data: TrivialType, [(); _]:,

const METADATA: &[u8]

Data structure metadata in binary form, describing shape and types of the contents, see IoTypeMetadataKind for encoding details

type PointerType = Data

Pointer with a trivial type that this IoType represents

type WithLifetime<'b> = MaybeData<'b, Data>

The same type, viewing memory borrowed for 'b.

type Reborrowed<'b> = MaybeData<'b, Data>

where Self: 'b,

Exclusive access to a value for 'b, which Self::reborrow_mut() returns.

fn size(&self) -> u32

Number of bytes that are currently used to store data

fn capacity(&self) -> u32

Number of bytes are allocated right now

unsafe fn set_size(&mut self, size: u32)

Set the number of used bytes.

unsafe fn from_ptr<'a>( ptr: &'a NonNull<Self::PointerType>, size: &'a u32, capacity: u32, ) -> impl Deref<Target = Self::WithLifetime<'a>> + 'a

Create a reference to a type, which is represented by provided memory.

unsafe fn from_mut_ptr<'a>( ptr: &'a mut NonNull<Self::PointerType>, size: &'a mut u32, capacity: u32, ) -> impl DerefMut<Target = Self::WithLifetime<'a>> + 'a

Create a mutable reference to a type, which is represented by provided memory.

unsafe fn try_from_ptr<'a>( ptr: &'a NonNull<Self::PointerType>, size: &'a u32, capacity: u32, ) -> Option<impl Deref<Target = Self::WithLifetime<'a>> + 'a>

Create a reference to a type, which is represented by provided memory, if the memory holds a valid value.

unsafe fn try_from_mut_ptr<'a>( ptr: &'a mut NonNull<Self::PointerType>, size: &'a mut u32, capacity: u32, ) -> Option<impl DerefMut<Target = Self::WithLifetime<'a>> + 'a>

Like Self::try_from_ptr(), but returns an exclusive reference.

fn as_ptr(&self) -> NonNull<Self::PointerType>

Get a raw pointer to the underlying data.

fn as_mut_ptr(&mut self) -> NonNull<Self::PointerType>

Get an exclusive raw pointer to the underlying data.

fn reborrow_mut(&mut self) -> Self::Reborrowed<'_>

Exclusive access to this value for the duration of the borrow.

impl<Data> IoTypeOptional for MaybeData<'_, Data>

where Data: TrivialType, [(); _]:,