Struct AtomPtr 

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

A safe atomic pointer wrapper

Implementations

impl<T> AtomPtr<T>

pub fn new(t: T) -> Self

Create a new atomic pointer for a type

pub fn get_ref(&self) -> Ref<T>

Get an immutable reference to the current value

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

Load the current value and return a mutable reference to it in-place access to the underlying memory location.

This function returns None if the data is missing. In those cases you must still setup the initial value manually.

pub fn swap(&self, new: T) -> Ref<T>

Swap the data entry with a new value, returning the old

pub fn compare_exchange(&self, prev: Ref<T>, new: T) -> CasResult<T>

Compare and swap this pointer for a new one

This API takes two pieces of data: a previously handed out data reference, and a new piece of data. The reference data will be compared to the existing value, and if they match, the new data is inserted into the pointer.

This API follows the AtomicPtr::compare_exchange API. The deprecated compare_and_swap API is not implemented.

pub fn compare_exchange_weak(&self, prev: Ref<T>, new: T) -> CasResult<T>

Compare and swap this pointer for a new one

Use this variant when called in a loop

Trait Implementations

impl<T: Clone> Clone for AtomPtr<T>

fn clone(&self) -> AtomPtr<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AtomPtr<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for AtomPtr<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for AtomPtr<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> PartialEq for AtomPtr<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.