Struct DynList 

pub struct DynList<T, Typ = DoubleLinked>
where
    T: Pointee<Metadata = DynMetadata<T>> + ?Sized,
    Typ: ListType<T>,
{ /* private fields */ }

A list of objects that all implement a trait.

See the crate documentation for more info.

Implementations

impl<T, Typ> DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + ?Sized, Typ: ListType<T>,

pub fn new() -> Self

Creates an empty list.

Does not allocate.

pub fn len(&self) -> usize

Gets the number of items in the list.

pub fn is_empty(&self) -> bool

Checks if the list is empty.

pub unsafe fn push_ptr(&mut self, value: *mut T)

Moves a dyn trait from a pointer and pushes it to the end of the list.

This moves the data out of the passed-in pointer, rendering it no longer dereferenceable.

Safety

The pointer must be dereferenceable.

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

Moves a dyn trait out of a box and pushes it to the end of the list.

In addition to adding items from boxes, it also does not require the dyn trait object to implement FromImpl.

pub fn push<U>(&mut self, value: U)

where T: FromImpl<U>,

Pushes an element onto the list.

This requires that the trait object implements FromImpl for U. On nightly, it is implemented for all trait implementations, but on stable requires using the impl_from_impl macro on the trait.

See also Self::push_boxed and Self::push_ptr.

pub fn extend_from_other<Typ2>(&mut self, other: DynList<T, Typ2>)

where Typ2: ListType<T>,

Moves all items from another DynList into this one, adding them to the end in order.

pub fn clear(&mut self)

Clears the list, removing all elements.

The list capacity is retained.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity to hold exactly what is stored in the list.

pub fn iter<'a>(&'a self) -> Iter<'a, T, Typ>

Iterates through items in this list

pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T, Typ>

Iterates through items in this list mutably.

Note: if using with dyn Any, review Rust’s advice about calling its methods! You will need to derference the item before calling a method from Any.

pub fn into_ptrs_iter(self) -> IntoPtrsIter<T, Typ>

Move elements out of the list, yielding pointers to them.

The pointers are valid until the iterator is dropped, at which point they are all deallocated.

Yielded pointers will not have their contents dropped, so it is safe to move the data out of them. Any remaining unyielded pointers will have their contents dropped once the iterator is dropped.

pub fn into_box_iter(self) -> IntoBoxedIter<T, Typ>

Moves elements out of the list, moving them into boxes.

pub fn cursor<'a>(&'a mut self) -> Option<Cursor<'a, T, Typ>>

Creates a cursor located at the beginning of the list.

Unlike an iterator, the Cursor is lending, but provides the iters::Cursor::drop_after method for dropping a section of the list.

Returns None if the list is empty.

impl<T, Typ> DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + ?Sized, Typ: ListTypeRev<T>,

pub fn cursor_end<'a>(&'a mut self) -> Option<Cursor<'a, T, Typ>>

Creates a cursor located at the end of the list.

Returns None if the list is empty.

Trait Implementations

impl<T, Typ> Debug for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + Debug + ?Sized, Typ: ListType<T>,

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

Formats the value using the given formatter.

impl<T, Typ> Default for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + ?Sized, Typ: ListType<T>,

fn default() -> Self

Returns the “default value” for a type.

impl<T, Typ> Drop for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + ?Sized, Typ: ListType<T>,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T, Typ> Eq for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + Eq + ?Sized, Typ: ListType<T>,

impl<U, T, Typ> Extend<U> for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + FromImpl<U> + ?Sized, Typ: ListType<T>,

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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<T, Typ1, U, Typ2> PartialEq<DynList<U, Typ2>> for DynList<T, Typ1>

where T: Pointee<Metadata = DynMetadata<T>> + PartialEq<U> + ?Sized, U: Pointee<Metadata = DynMetadata<U>> + ?Sized, Typ1: ListType<T>, Typ2: ListType<U>,

fn eq(&self, other: &DynList<U, Typ2>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T, Typ> Send for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + Send + ?Sized, Typ: ListType<T> + Send,

impl<T, Typ> Sync for DynList<T, Typ>

where T: Pointee<Metadata = DynMetadata<T>> + Sync + ?Sized, Typ: ListType<T> + Sync,