Struct Atomic 

pub struct Atomic<T: Well>(/* private fields */);

Atomic potential well.

Internally, this just wraps a pointer to <T as Deref>::Target and uses atomic pointer operations to access it. However, the number of operations on the pointer is limited to ensure correctness in safe code.

Implementations

impl<T: Well> Atomic<T>

pub fn new(well: T) -> Atomic<T>

Creates atomic with a value.

pub unsafe fn as_raw_unchecked(&self) -> &AtomicPtr<<T as Deref>::Target>

Gives access to the underlying AtomicPtr.

Safety

The pointer inside the atomic must always a valid pointer from Well::remove and therefore must not be null. Additionally, keep in mind that this atomic owns the pointer, and if you want to move it out, you must put a different pointer in its place first.

pub fn load(&self, ordering: Ordering) -> &<T as Deref>::Target

Loads the inner data as an immutable reference.

This is equivalent to an atomic load.

pub fn swap(&self, well: T, ordering: Ordering) -> T

Atomically swaps the data inside the well.

This is equivalent to an atomic swap.

impl<T: WellMut<Target: Unpin>> Atomic<T>

pub fn load_mut(&mut self) -> &mut <T as Deref>::Target

Loads the inner data as a mutable reference.

This performs a non-atomic access since the atomic is mutably borrowed.

impl<T: WellMut> Atomic<Pin<T>>

where Pin<T>: Well,

pub fn load_mut_pinned(&mut self) -> Pin<&mut <Pin<T> as Deref>::Target>

Loads the inner data as a mutable reference.

This is a version of load_mut that works with pinned values.

impl<T: Well + Clone> Atomic<T>

pub fn load_clone(&self, ordering: Ordering) -> T

Loads a clone of the inner data.

This still performs an atomic load, but instead of offering a reference, the smart pointer is cloned instead.

Trait Implementations

impl<T: Well<Target: Debug>> Debug for Atomic<T>

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

Formats the value using the given formatter.

impl<T: Well + Default> Default for Atomic<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Well> Drop for Atomic<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Well> From<T> for Atomic<T>

fn from(well: T) -> Self

Converts to this type from the input type.