Struct DynList

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

A doubly-linked list that allows nodes with dynamically sized types.

Implementations

impl<U, A> DynList<U, A>

where U: ?Sized, A: Allocator,

pub fn extend_unsize<T>(&mut self, iter: T)

where T: IntoIterator, T::Item: Unsize<U>,

Extends the list with the contents of iter after unsizing them.

pub fn from_iter_unsize_in<T>(iter: T, allocator: A) -> Self

where T: IntoIterator, T::Item: Unsize<U>,

Creates a DynList from the contents of iter in allocator after unsizing the elements.

impl<U> DynList<U>

where U: ?Sized,

pub fn from_iter_unsize<T>(iter: T) -> Self

where T: IntoIterator, T::Item: Unsize<U>,

Creates a DynList from the contents of iter after unsizing the elements.

impl<T, A> DynList<T, A>

where A: Allocator,

pub fn try_allocate_uninit_sized_front( &mut self, ) -> Result<MaybeUninitNode<'_, T, A>, AllocError>

Attempts to allocate an uninitialised, sized node at the front of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn try_allocate_uninit_sized_back( &mut self, ) -> Result<MaybeUninitNode<'_, T, A>, AllocError>

Attempts to allocate an uninitialised, sized node at the back of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn allocate_uninit_sized_front(&mut self) -> MaybeUninitNode<'_, T, A>

Allocates an uninitialised, sized node at the front of the list.

pub fn allocate_uninit_sized_back(&mut self) -> MaybeUninitNode<'_, T, A>

Allocates an uninitialised, sized node at the back of the list.

pub fn try_push_front(&mut self, value: T) -> Result<(), AllocError>

Attempts to push value to the front of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn try_push_back(&mut self, value: T) -> Result<(), AllocError>

Attempts to push value to the back of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn push_front(&mut self, value: T)

Pushes value to the front of the list.

pub fn push_back(&mut self, value: T)

Pushes value to the back of the list.

Examples found in repository

examples/test.rs (line 6)

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

    list.push_back(0);
    list.push_back(1);
    list.push_back(2);

    let mut cursor = list.cursor_front_mut();
    cursor.move_next();
    cursor.insert_before(100);

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

pub fn pop_front(&mut self) -> Option<T>

Removes the front value from the list and returns it.

pub fn pop_back(&mut self) -> Option<T>

Removes the back value from the list and returns it.

pub const fn into_iter(self) -> IntoIter<T, A>

Converts the list to an iterator that yields the elements.

impl<T, A> DynList<[T], A>

where A: Allocator,

pub fn try_allocate_uninit_slice_front( &mut self, length: usize, ) -> Result<MaybeUninitNode<'_, [T], A>, AllocError>

Attempts to allocate an uninitialised slice node at the front of the list.

Errors

If allocation fails, or an arithmetic overflow occours in Layout::array, this will return an AllocError.

pub fn try_allocate_uninit_slice_back( &mut self, length: usize, ) -> Result<MaybeUninitNode<'_, [T], A>, AllocError>

Attempts to allocate an uninitialised slice node at the back of the list.

Errors

If allocation fails, or an arithmetic overflow occours in Layout::array, this will return an AllocError.

pub fn allocate_uninit_slice_front( &mut self, length: usize, ) -> MaybeUninitNode<'_, [T], A>

Allocates an uninitialised slice node at the front of the list.

pub fn allocate_uninit_slice_back( &mut self, length: usize, ) -> MaybeUninitNode<'_, [T], A>

Allocates an uninitialised slice node at the back of the list.

Examples found in repository

examples/slice.rs (line 10)

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 try_push_front_copy_slice(&mut self, src: &[T]) -> Result<(), AllocError>

where T: Copy,

Attempts to copy the slice src and push it to the front of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn try_push_back_copy_slice(&mut self, src: &[T]) -> Result<(), AllocError>

where T: Copy,

Attempts to copy the slice src and push it to the back of the list.

Errors

If allocation fails, this will return an AllocError.

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

where T: Copy,

Copies the slice src and pushes it to the front of the list.

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

where T: Copy,

Copies the slice src and pushes it to the back of the list.

pub fn try_push_front_clone_slice( &mut self, src: &[T], ) -> Result<(), AllocError>

where T: Clone,

Attempts to clone the slice src and push it to the front of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn try_push_back_clone_slice(&mut self, src: &[T]) -> Result<(), AllocError>

where T: Clone,

Attempts to clone the slice src and push it to the back of the list.

Errors

If allocation fails, this will return an AllocError.

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

where T: Clone,

Clones the slice src and pushes it to the front of the list.

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

where T: Clone,

Clones the slice src and pushes it to the back of the list.

impl<A> DynList<str, A>

where A: Allocator,

pub unsafe fn from_utf8_unchecked(bytes: DynList<[u8], A>) -> Self

Converts the list of byte slices to a list of string slices without checking that the slices contain valid UTF-8.

Safety

All byte slices in the list must be valid UTF-8. For more information, see str::from_utf8_unchecked.

pub fn into_bytes(self) -> DynList<[u8], A>

Converts the list of string slices to a list of byte slices.

pub fn try_allocate_uninit_str_front( &mut self, length: usize, ) -> Result<MaybeUninitNode<'_, str, A>, AllocError>

Attempts to allocate an uninitialised str node at the front of the list.

Errors

If allocation fails, or an arithmetic overflow occours in Layout::array, this will return an AllocError.

pub fn try_allocate_uninit_str_back( &mut self, length: usize, ) -> Result<MaybeUninitNode<'_, str, A>, AllocError>

Attempts to allocate an uninitialised str node at the back of the list.

Errors

If allocation fails, or an arithmetic overflow occours in Layout::array, this will return an AllocError.

pub fn allocate_uninit_str_front( &mut self, length: usize, ) -> MaybeUninitNode<'_, str, A>

Allocates an uninitialised str node at the front of the list.

pub fn allocate_uninit_str_back( &mut self, length: usize, ) -> MaybeUninitNode<'_, str, A>

Allocates an uninitialised str node at the back of the list.

pub fn try_push_front_copy_str(&mut self, src: &str) -> Result<(), AllocError>

Attempts to copy the string slice src and push it to the front of the list.

Errors

If allocation fails, this will return an AllocError.

pub fn try_push_back_copy_str(&mut self, src: &str) -> Result<(), AllocError>

Attempts to copy the string slice src and push it to the back of the list.

Errors

If allocation fails, this will return an AllocError.

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

Copies the string slice src and pushes it to the front of the list.

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

Copies the string slice src and pushes it to the back of the list.

Examples found in repository

examples/str.rs (line 7)

fn main() {
    let mut list = DynList::<str>::new();

    list.push_back_copy_str("Hello,");
    list.push_back_copy_str(" World!");

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

impl<U, A> DynList<U, A>

where U: ?Sized, A: Allocator,

pub const fn new_in(allocator: A) -> Self

Creates an empty DynList in the given allocator.

pub fn into_raw_parts(self) -> (Option<(NonNull<()>, NonNull<()>)>, A)

Decomposes the DynList into pointers to the head and tail (if not empty), and the allocator.

pub unsafe fn from_raw_parts( ends: Option<(NonNull<()>, NonNull<()>)>, allocator: A, ) -> Self

Creates a DynList from pointers to the head and tail (if not empty), and an allocator.

Safety

• If the ends are not None, they must have come from a call to Self::into_raw_parts with a U with the same layout and invariants.
• allocator must be valid for the nodes in the list.

pub unsafe fn try_allocate_uninit_front( &mut self, metadata: <U as Pointee>::Metadata, ) -> Result<MaybeUninitNode<'_, U, A>, AllocError>

Attempts to allocate an uninitialised node at the front of the list.

Safety

The metadata must be valid under the safety conditions for Layout::for_value_raw.

Errors

If allocation fails, this will return an AllocError.

pub unsafe fn try_allocate_uninit_back( &mut self, metadata: <U as Pointee>::Metadata, ) -> Result<MaybeUninitNode<'_, U, A>, AllocError>

Attempts to allocate an uninitialised node at the back of the list.

Safety

The metadata must be valid under the safety conditions for Layout::for_value_raw.

Errors

If allocation fails, this will return an AllocError.

pub unsafe fn allocate_uninit_front( &mut self, metadata: <U as Pointee>::Metadata, ) -> MaybeUninitNode<'_, U, A>

Allocates an uninitialised node at the front of the list.

Safety

The metadata must be valid under the safety conditions for Layout::for_value_raw.

pub unsafe fn allocate_uninit_back( &mut self, metadata: <U as Pointee>::Metadata, ) -> MaybeUninitNode<'_, U, A>

Allocates an uninitialised node at the tail of the list.

Safety

The metadata must be valid under the safety conditions for Layout::for_value_raw.

pub fn try_push_front_unsize<T>(&mut self, value: T) -> Result<(), AllocError>

where T: Unsize<U>,

Attempts to push value to the front of the list and unsize it to U.

Errors

If allocation fails, this will return an AllocError.

pub fn try_push_back_unsize<T>(&mut self, value: T) -> Result<(), AllocError>

where T: Unsize<U>,

Attempts to push value to the back of the list and unsize it to U.

Errors

If allocation fails, this will return an AllocError.

pub fn push_front_unsize<T>(&mut self, value: T)

where T: Unsize<U>,

Pushes value to the front of the list and unsizes it to U.

Examples

let mut list = DynList::<dyn Debug>::new();
list.push_front_unsize("Hello, World!");

pub fn push_back_unsize<T>(&mut self, value: T)

where T: Unsize<U>,

Pushes value to the back of the list and unsizes it to U.

Examples

let mut list = DynList::<dyn Debug>::new();
list.push_back_unsize("Hello, World!");

Examples found in repository

examples/debug.rs (line 9)

fn main() {
    let mut list = DynList::<dyn Debug>::new();

    list.push_back_unsize("Hello, World");
    list.push_back_unsize(0);
    list.push_back_unsize([1, 2, 3, 4]);

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

examples/slice.rs (line 7)

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 pop_front_node(&mut self) -> Option<MaybeUninitNode<'_, U, A>>

Removes the front node of the list. If you do not want a MaybeUninitNode, this is the wrong function!

pub fn pop_back_node(&mut self) -> Option<MaybeUninitNode<'_, U, A>>

Removes the back node of the list. If you do not want a MaybeUninitNode, this is the wrong function!

pub fn delete_front(&mut self) -> bool

Deletes and drops the node at the front of the list.

Returns true if a node was removed and false if the list was empty.

Examples

let mut list = DynList::<dyn Debug>::new();
assert!(!list.delete_front());

list.push_back_unsize("Hello, World!");
assert!(list.delete_front());

pub fn delete_back(&mut self) -> bool

Deletes and drops the node at the back of the list.

Returns true if a node was removed and false if the list was empty.

Examples

let mut list = DynList::<dyn Debug>::new();
assert!(!list.delete_back());

list.push_back_unsize("Hello, World!");
assert!(list.delete_back());

pub fn try_pop_front_boxed(&mut self) -> Option<Result<Box<U, A>, AllocError>>

where A: Clone,

Attempts to remove the front node and return it in a Box.

Errors

If allocation fails, this will return an AllocError. The node will be deleted.

pub fn try_pop_back_boxed(&mut self) -> Option<Result<Box<U, A>, AllocError>>

where A: Clone,

Attempts to remove the back node and return it in a Box.

Errors

If allocation fails, this will return an AllocError. The node will be deleted.

pub fn pop_front_boxed(&mut self) -> Option<Box<U, A>>

where A: Clone,

Removes the front node and returns it in a Box.

let mut list = DynList::<dyn PartialEq<u8>>::new();
list.push_back_unsize(5);
assert!(&*list.pop_front_boxed().unwrap() == &5_u8);

pub fn pop_back_boxed(&mut self) -> Option<Box<U, A>>

where A: Clone,

Removes the back node and returns it in a Box.

let mut list = DynList::<dyn PartialEq<u8>>::new();
list.push_back_unsize(5);
assert!(&*list.pop_back_boxed().unwrap() == &5_u8);

pub const fn cursor_front(&self) -> Cursor<'_, U, A>

Creates a Cursor at the front of the list.

If the list is empty, this will point to the “ghost” element.

pub const fn cursor_back(&self) -> Cursor<'_, U, A>

Creates a Cursor at the back of the list.

If the list is empty, this will point to the “ghost” element.

pub const fn cursor_front_mut(&mut self) -> CursorMut<'_, U, A>

Creates a CursorMut at the front of the list that can mutate the list.

If the list is empty, this will point to the “ghost” element.

Examples found in repository

examples/test.rs (line 10)

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

    list.push_back(0);
    list.push_back(1);
    list.push_back(2);

    let mut cursor = list.cursor_front_mut();
    cursor.move_next();
    cursor.insert_before(100);

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

pub const fn cursor_back_mut(&mut self) -> CursorMut<'_, U, A>

Creates a CursorMut at the back of the list that can mutate the list.

If the list is empty, this will point to the “ghost” element.

pub const fn iter(&self) -> Iter<'_, U>

Creates an iterator over references to the items in the list.

pub const fn iter_mut(&mut self) -> IterMut<'_, U>

Creates an iterator over mutable references to the items in the list.

pub const fn into_iter_boxed(self) -> IntoIterBoxed<U, A>

where A: Clone,

Converts the list to an iterator that yields the elements in boxes.

pub fn try_clone_in<A2>( &self, allocator: A2, ) -> Result<DynList<U, A2>, AllocError>

where U: CloneToUninit, A2: Allocator,

Attempts to clone the list into another allocator.

Errors

If allocation fails, this will return an AllocError.

pub fn clone_in<A2>(&self, allocator: A2) -> DynList<U, A2>

where U: CloneToUninit, A2: Allocator,

Clones the list into another allocator.

impl<U> DynList<U>

where U: ?Sized,

pub const fn new() -> Self

Creates an empty DynList.

Examples found in repository

examples/str.rs (line 5)

fn main() {
    let mut list = DynList::<str>::new();

    list.push_back_copy_str("Hello,");
    list.push_back_copy_str(" World!");

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

examples/debug.rs (line 7)

fn main() {
    let mut list = DynList::<dyn Debug>::new();

    list.push_back_unsize("Hello, World");
    list.push_back_unsize(0);
    list.push_back_unsize([1, 2, 3, 4]);

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

examples/test.rs (line 4)

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

    list.push_back(0);
    list.push_back(1);
    list.push_back(2);

    let mut cursor = list.cursor_front_mut();
    cursor.move_next();
    cursor.insert_before(100);

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

examples/slice.rs (line 5)

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:?}");
}

Trait Implementations

impl<U, A> Clone for DynList<U, A>

where U: ?Sized + CloneToUninit, A: Allocator + Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<U, A> Debug for DynList<U, A>

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

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

Formats the value using the given formatter.

impl<U> Default for DynList<U>

where U: ?Sized,

fn default() -> Self

Returns the “default value” for a type.

impl<U, A> Drop for DynList<U, A>

where U: ?Sized, A: Allocator,

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, Item, A> Extend<&'a Item> for DynList<Item, A>

where Item: Copy, A: Allocator,

fn extend<T: IntoIterator<Item = &'a Item>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Item, A> Extend<Item> for DynList<Item, A>

where A: Allocator,

fn extend<T: IntoIterator<Item = Item>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Item> FromIterator<Item> for DynList<Item>

fn from_iter<T: IntoIterator<Item = Item>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, U: ?Sized, A> IntoIterator for &'a DynList<U, A>

where A: Allocator,

type Item = &'a U

The type of the elements being iterated over.

type IntoIter = Iter<'a, U>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, U: ?Sized, A> IntoIterator for &'a mut DynList<U, A>

where A: Allocator,

type Item = &'a mut U

The type of the elements being iterated over.

type IntoIter = IterMut<'a, U>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, A> IntoIterator for DynList<T, A>

where A: Allocator,

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<U, A> Send for DynList<U, A>

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

impl<U, A> Sync for DynList<U, A>

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