Struct uninit_tools::initializer::BuffersInitializer

pub struct BuffersInitializer<T> { /* fields omitted */ }

Implementations

impl<T> BuffersInitializer<T>

pub const fn uninit(inner: T) -> Self

pub fn into_raw_parts(self) -> (T, usize, usize)

pub fn into_inner(self) -> T

impl<T> BuffersInitializer<SingleVector<T>>

pub fn from_single_buffer_initializer(single: BufferInitializer<T>) -> Self

impl<T, Item> BuffersInitializer<T> where
    T: InitializeVectored,
    T::UninitVector: Initialize<Item = Item>, 

pub fn current_vector_all(&self) -> Option<&[MaybeUninit<Item>]>

Retrieve the current buffer immutably, provided that there is one.

pub unsafe fn current_vector_all_mut(
    &mut self
) -> Option<&mut [MaybeUninit<Item>]>

Retrieve the current buffer mutably, provided that there is one.

Safety

This is unsafe because the caller must not de-initialize the buffer.

pub fn current_vector_init_part(&self) -> Option<&[Item]>

pub fn current_vector_uninit_part(&self) -> Option<&[MaybeUninit<Item>]>

pub fn current_vector_init_uninit_parts(
    &self
) -> Option<(&[Item], &[MaybeUninit<Item>])>

pub fn current_vector_init_part_mut(&mut self) -> Option<&mut [Item]>

pub fn current_vector_uninit_part_mut(
    &mut self
) -> Option<&mut [MaybeUninit<Item>]>

pub fn current_vector_init_uninit_parts_mut(
    &mut self
) -> Option<(&mut [Item], &mut [MaybeUninit<Item>])>

pub fn total_vector_count(&self) -> usize

Get the total number of vectors, since the wrapper was constructed.

pub fn vectors_initialized(&self) -> usize

Get the number of vectors that are currently filled and completely initialized.

pub fn vectors_remaining(&self) -> usize

Get the number of vectors remaining, possibly including the vector that is currently initializing.

pub fn count_items_to_initialize(&self) -> usize

Counts the items that must be filled before the whole buffer is initialized.

Note that this can be expensive if there are many buffers; it is O(n), where n is the number of vectors that have not yet been initialized. If all vectors are already filled, then this completes in constant time.

pub fn count_total_items_in_all_vectors(&self) -> usize

pub unsafe fn items_initialized_for_vector_unchecked(
    &self,
    vector_index: usize
) -> usize

Get the number of items that have been initialized for the vector at the given index.

For vectors that has not yet been advanced to, this will zero, while vectors that are already initialized will return the full length of that vector. The currently initializing vector will return the partial length of the items within that vector that have been initialized.

Safety

The caller must ensure that vector_index is within the bounds of the slice of vectors given by the inner wrapped value.

pub fn items_initialized_for_vector(&self, vector_index: usize) -> usize

pub fn items_initialized_for_current_vector(&self) -> usize

pub fn all_uninit_vectors(&self) -> &[T::UninitVector]

Get the uninitialized version of all vectors wrapped by this initializer.

pub unsafe fn all_uninit_vectors_mut(&mut self) -> &mut [T::UninitVector]

Get the uninitialized version of all vectors wrapped by this initializer, mutably.

Safety

The caller must not de-initialize any values.

pub unsafe fn advance(&mut self, count: usize) -> usize

Advance the initialization cursor by count items, counting the number of items that were advanced. The count input may be higher than the total number of items in the buffer, without panics or UB.

Safety

For this to be safe, then count items in the vectors ranging from the current vector, to subsequent vectors, must be initialized.

Additionally, count must never overflow isize::MAX, but it may be larger than the total number of items in the vectors (to avoid having to count them in the beginning, for performance purposes).

pub unsafe fn advance_current_vector_to_end(&mut self)

Advance the initialization progress to the end of the current vector, thus wrapping and continuing to the next

Safety

This is unsafe not only because of the initialization invariant, but also because it does not check whether the initialized vectors counter is at the end (meaning that all vectors are initialized). The caller must hence ensure that the value of vectors_remaining is larger than zero.

pub unsafe fn advance_current_vector(&mut self, count: usize)

pub fn partially_fill_current_vector_uninit_part(
    &mut self,
    count: usize,
    item: Item
) where
    Item: Copy, 

pub fn fill_current_vector_uninit_part(&mut self, item: Item) where
    Item: Copy, 

pub fn try_into_init(self) -> Result<AssertInitVectors<T>, Self>

impl<T> BuffersInitializer<T> where
    T: InitializeVectored,
    T::UninitVector: Initialize<Item = u8>, 

pub fn partially_zero_current_vector_uninit_part(&mut self, count: usize)

pub fn zero_current_vector_uninit_part(&mut self)