Struct scc::LinkedEntry

pub struct LinkedEntry<T> { /* private fields */ }

Entry stores an instance of T and a link to the next entry.

Implementations

impl<T> Entry<T>

pub unsafe fn take_inner(&mut self) -> T

Extracts the inner instance of T.

Safety

This method has to be called at most once per Entry, and the caller needs to make sure that the Entry is not accessed via LinkedList methods.

Examples

use scc::Stack;

let stack: Stack<usize> = Stack::default();

stack.push(37);

let mut entry = stack.pop().unwrap();
let pushed = unsafe { entry.get_mut().unwrap().take_inner() };
assert_eq!(pushed, 37);

Trait Implementations

impl<T> AsMut<T> for Entry<T>

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

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

impl<T> AsRef<T> for Entry<T>

fn as_ref(&self) -> &T

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

impl<T: Clone> Clone for Entry<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Entry<T>

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

Formats the value using the given formatter.

impl<T> Deref for Entry<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Entry<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Display> Display for Entry<T>

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

Formats the value using the given formatter.

impl<T> Drop for Entry<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> LinkedList for Entry<T>

fn link_ref(&self) -> &AtomicShared<Self>

Returns a reference to the forward link.

fn is_clear(&self, order: Ordering) -> bool

Returns true if self is reachable and not marked.

fn mark(&self, order: Ordering) -> bool

Marks self with an internal flag to denote that self is in a special state.

fn unmark(&self, order: Ordering) -> bool

Removes any mark from self.

fn is_marked(&self, order: Ordering) -> bool

Returns true if self has a mark on it.

fn delete_self(&self, order: Ordering) -> bool

Deletes self.

fn is_deleted(&self, order: Ordering) -> bool

Returns true if self has been deleted.

fn push_back<'g>( &self, entry: Shared<Self>, mark: bool, order: Ordering, guard: &'g Guard, ) -> Result<Ptr<'g, Self>, Shared<Self>>

Appends the given entry to self and returns a pointer to the entry.

fn next_ptr<'g>(&self, order: Ordering, guard: &'g Guard) -> Ptr<'g, Self>

Returns the closest next valid entry.

fn next_shared(&self, order: Ordering, guard: &Guard) -> Option<Shared<Self>>

Returns a Shared handle to the closest next valid entry.

impl<T: PartialEq> PartialEq for Entry<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Entry<T>