Struct crossbeam_epoch::sync::list::List

pub(crate) struct List<T, C: IsElement<T> = T> {
    head: Atomic<Entry>,
    _marker: PhantomData<(T, C)>,
}

A lock-free, intrusive linked list of type T.

Fields

head: Atomic<Entry>

The head of the linked list.

_marker: PhantomData<(T, C)>

The phantom data for using T and C.

Implementations

impl<T, C: IsElement<T>> List<T, C>

pub(crate) fn new() -> Self

Returns a new, empty linked list.

pub(crate) unsafe fn insert<'g>( &'g self, container: Shared<'g, T>, guard: &'g Guard, )

Inserts entry into the head of the list.

Safety

You should guarantee that:

• container is not null
• container is immovable, e.g. inside an Owned
• the same Entry is not inserted more than once
• the inserted object will be removed before the list is dropped

pub(crate) fn iter<'g>(&'g self, guard: &'g Guard) -> Iter<'g, T, C>

Returns an iterator over all objects.

Caveat

Every object that is inserted at the moment this function is called and persists at least until the end of iteration will be returned. Since this iterator traverses a lock-free linked list that may be concurrently modified, some additional caveats apply:

1. If a new object is inserted during iteration, it may or may not be returned.
2. If an object is deleted during iteration, it may or may not be returned.
3. The iteration may be aborted when it lost in a race condition. In this case, the winning thread will continue to iterate over the same list.

Trait Implementations

impl<T: Debug, C: Debug + IsElement<T>> Debug for List<T, C>

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

Formats the value using the given formatter.

impl<T, C: IsElement<T>> Drop for List<T, C>

fn drop(&mut self)

Executes the destructor for this type.