Struct tokio::util::linked_list::LinkedList

pub(crate) struct LinkedList<L, T> {
    head: Option<NonNull<T>>,
    tail: Option<NonNull<T>>,
    _marker: PhantomData<*const L>,
}

An intrusive linked list.

Currently, the list is not emptied on drop. It is the caller’s responsibility to ensure the list is empty before dropping it.

Fields

head: Option<NonNull<T>>

Linked list head

tail: Option<NonNull<T>>

Linked list tail

_marker: PhantomData<*const L>

Node type marker.

Implementations

impl<L, T> LinkedList<L, T>

pub(crate) const fn new() -> LinkedList<L, T>

Creates an empty linked list.

impl<L: Link> LinkedList<L, L::Target>

pub(crate) fn push_front(&mut self, val: L::Handle)

Adds an element first in the list.

pub(crate) fn pop_front(&mut self) -> Option<L::Handle>

Removes the first element from a list and returns it, or None if it is empty.

pub(crate) fn pop_back(&mut self) -> Option<L::Handle>

Removes the last element from a list and returns it, or None if it is empty.

pub(crate) fn is_empty(&self) -> bool

Returns whether the linked list does not contain any node

pub(crate) unsafe fn remove( &mut self, node: NonNull<L::Target>, ) -> Option<L::Handle>

Removes the specified node from the list

Safety

The caller must ensure that exactly one of the following is true:

• node is currently contained by self,
• node is not contained by any list,
• node is currently contained by some other GuardedLinkedList and the caller has an exclusive access to that list. This condition is used by the linked list in sync::Notify.

impl<L: Link> LinkedList<L, L::Target>

pub(crate) fn last(&self) -> Option<&L::Target>

impl<T: Link> LinkedList<T, T::Target>

pub(crate) fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F>

where F: FnMut(&T::Target) -> bool,

impl<L: Link> LinkedList<L, L::Target>

pub(crate) fn into_guarded( self, guard_handle: L::Handle, ) -> GuardedLinkedList<L, L::Target>

Turns a linked list into the guarded version by linking the guard node with the head and tail nodes. Like with other nodes, you should guarantee that the guard node is pinned in memory.

Trait Implementations

impl<L: Link> Debug for LinkedList<L, L::Target>

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

Formats the value using the given formatter.

impl<L: Link> Default for LinkedList<L, L::Target>

fn default() -> Self

Returns the “default value” for a type.

impl<L: Link> Send for LinkedList<L, L::Target>

where L::Target: Send,

impl<L: Link> Sync for LinkedList<L, L::Target>

where L::Target: Sync,