Struct MaybeUninitNode

pub struct MaybeUninitNode<'a, U, A = Global>
where
    U: ?Sized,
    A: Allocator,
{ /* private fields */ }

A node with possibly uninitialised data.

These nodes sit outside of a DynList and have previous and next nodes in the list. Calling Self::insert inserts the node into the list.

To insert a new node:

1. Allocate an uninitialised node using either a DynList or a CursorMut
2. Initialise the node
3. Call Self::insert

Implementations

impl<'a, U, A> MaybeUninitNode<'a, U, A>

where U: ?Sized, A: Allocator,

pub fn value_ptr(&self) -> NonNull<()>

Gets a pointer to the value with no metadata.

pub fn as_ptr(&self) -> NonNull<U>

Gets a pointer to the value.

pub unsafe fn drop_in_place(&mut self)

Drops the contained value.

Note that this does not deallocate the node.

Safety

The value must:

• have been initialised
• be valid for U with the metadata the node was created with
• not have been dropped
• not have been copied unless it is Copy

pub unsafe fn insert(self)

Inserts the node into the list.

Safety

The value must:

• have been initialised
• be valid for U with the metadata the node was created with
• not have been dropped
• not have been copied unless it is Copy

Examples found in repository

examples/slice.rs (line 19)

fn main() {
    let mut list = DynList::<[u8]>::new();

    list.push_back_unsize([0, 1, 2, 3]);

    let s = "Hello";
    let mut node = list.allocate_uninit_slice_back(s.len());

    node.as_slice_mut()
        .iter_mut()
        .zip("Hello".bytes())
        .for_each(|(dst, src)| {
            dst.write(src);
        });

    unsafe { node.insert() };

    println!("{list:?}");
}

pub unsafe fn try_take_boxed(self) -> Result<Box<U, A>, AllocError>

where A: Clone,

Attempts to move the value into a box and return it.

Safety

The value must:

• have been initialised
• be valid for U with the metadata the node was created with
• not have been dropped
• not have been copied unless it is Copy

Errors

If allocation fails, this will return an AllocError.

pub unsafe fn take_boxed(self) -> Box<U, A>

where A: Clone,

Moves the value into a box and returns it.

Safety

The value must:

• have been initialised
• be valid for U with the metadata the node was created with
• not have been dropped
• not have been copied unless it is Copy

impl<T, A> MaybeUninitNode<'_, T, A>

where A: Allocator,

pub fn as_ref(&self) -> &MaybeUninit<T>

Gets a reference to the contained value.

pub fn as_mut(&mut self) -> &mut MaybeUninit<T>

Gets a mutable reference to the contained value.

pub unsafe fn take(self) -> T

Removes the contained value.

Safety

The value must:

• have been initialised
• be valid for T
• not have been dropped
• not have been copied unless it is Copy

impl<T, A> MaybeUninitNode<'_, [T], A>

where A: Allocator,

pub fn as_slice(&self) -> &[MaybeUninit<T>]

Gets a reference to the contained slice.

pub fn as_slice_mut(&mut self) -> &mut [MaybeUninit<T>]

Gets a mutable reference to the contained slice.

Examples found in repository

examples/slice.rs (line 12)

fn main() {
    let mut list = DynList::<[u8]>::new();

    list.push_back_unsize([0, 1, 2, 3]);

    let s = "Hello";
    let mut node = list.allocate_uninit_slice_back(s.len());

    node.as_slice_mut()
        .iter_mut()
        .zip("Hello".bytes())
        .for_each(|(dst, src)| {
            dst.write(src);
        });

    unsafe { node.insert() };

    println!("{list:?}");
}

pub fn copy_from_slice(&mut self, src: &[T])

where T: Copy,

Copies the slice src into the node.

Note that if src is shorter than the contained slice, some of the slice may not be initialised.

pub fn clone_from_slice(&mut self, src: &[T])

where T: Clone,

Clones the slice src into the node.

Note that if src is shorter than the contained slice, some of the slice may not be initialised.

impl<A> MaybeUninitNode<'_, str, A>

where A: Allocator,

pub fn as_bytes(&self) -> &[MaybeUninit<u8>]

Gets a reference to the contained string as a byte slice.

pub fn as_bytes_mut(&mut self) -> &mut [MaybeUninit<u8>]

Gets a mutable reference to the contained string as a byte slice.

pub fn copy_from_str(&mut self, src: &str)

Copies the string slice src into the node.

Note that if src is shorter than the contained slice, some of the string slice may not be initialised.

Trait Implementations

impl<T, A> AsMut<[MaybeUninit<T>]> for MaybeUninitNode<'_, [T], A>

where A: Allocator,

fn as_mut(&mut self) -> &mut [MaybeUninit<T>]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, A> AsMut<MaybeUninit<T>> for MaybeUninitNode<'_, T, A>

where A: Allocator,

fn as_mut(&mut self) -> &mut MaybeUninit<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, A> AsRef<[MaybeUninit<T>]> for MaybeUninitNode<'_, [T], A>

where A: Allocator,

fn as_ref(&self) -> &[MaybeUninit<T>]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, A> AsRef<MaybeUninit<T>> for MaybeUninitNode<'_, T, A>

where A: Allocator,

fn as_ref(&self) -> &MaybeUninit<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<U, A> Debug for MaybeUninitNode<'_, U, A>

where U: ?Sized, A: Allocator,

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

Formats the value using the given formatter.

impl<U, A> Drop for MaybeUninitNode<'_, U, A>

where U: ?Sized, A: Allocator,

fn drop(&mut self)

Executes the destructor for this type.

impl<U, A> Send for MaybeUninitNode<'_, U, A>

where U: ?Sized + Send, A: Allocator + Send,

impl<U, A> Sync for MaybeUninitNode<'_, U, A>

where U: ?Sized + Sync, A: Allocator + Sync,