Struct AtomicOption 

pub struct AtomicOption<W: Well> { /* private fields */ }

Potentially empty atomic potential well.

Internally, this just wraps a pointer to Bucket<T> 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<W: Well> AtomicOption<W>

pub fn none() -> AtomicOption<W>

Creates atomic without anything inside.

pub fn some(well: W) -> AtomicOption<W>

Creates atomic with something inside.

pub fn new(well: Option<W>) -> AtomicOption<W>

Creates atomic.

pub unsafe fn as_raw_unchecked(&self) -> &AtomicPtr<Target<W>>

Gives access to the underlying AtomicPtr.

Safety

The pointer inside the atomic must always be null, or a valid pointer from Well::remove. 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 swap(&self, well: W, ordering: Ordering) -> Option<W>

Atomically swaps the data inside the well.

This is equivalent to an atomic swap.

pub fn take(&self, ordering: Ordering) -> Option<W>

Takes the data out of the well.

This is equivalent to an atomic swap with a null pointer.

pub fn insert( &self, well: W, success: Ordering, failure: Ordering, ) -> Result<(), W>

Inserts data into the well.

This uses compare_exchange to avoid inserting into the well if it’s already full. If you want to use compare_exchange_weak instead, use insert_weak.

pub fn insert_weak( &self, well: W, success: Ordering, failure: Ordering, ) -> Result<(), W>

Inserts data into the well, sometimes failing spuriously.

This uses compare_exchange_weak to avoid inserting into the well if it’s already full, which may spuriously fail. If you want to use compare_exchange instead, use insert.

impl<W: WeakWell> AtomicOption<W>

pub fn try_load(&self, ordering: Ordering) -> Option<<W as WeakWell>::Strong>

Tries to load the inner data.

This is equivalent to an atomic load, but it may fail due to the weak reference. If the reference fails to upgrade, it will still remain inside the well.

impl<W: StrongWell> AtomicOption<W>

pub fn load(&self, ordering: Ordering) -> Option<&Target<W>>

Loads the inner data as an immutable reference.

This is equivalent to an atomic load.

pub fn swap_get(&self, well: W, ordering: Ordering) -> (Option<W>, &Target<W>)

Atomically swaps the data inside the well and returns a reference to the new data.

This is swap, but with the unsafe deref hidden behind a safe API.

pub fn insert_get( &self, well: W, success: Ordering, failure: Ordering, ) -> Result<&Target<W>, W>

Inserts data into the well and returns a reference to the new data.

This is insert, but with the unsafe deref hidden behind a safe API.

pub fn insert_weak_get( &self, well: W, success: Ordering, failure: Ordering, ) -> Result<&Target<W>, W>

Inserts data into the well, returns reference to the new data, sometimes failing spuriously.

This is insert_weak, but with the unsafe deref hidden behind a safe API.

impl<W: StrongWellMut + DerefMut<Target: Unpin>> AtomicOption<W>

pub fn load_mut(&mut self) -> Option<&mut Target<W>>

Loads the inner data as a mutable reference.

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

impl<W: StrongWellMut> AtomicOption<Pin<W>>

pub fn load_mut_pinned(&mut self) -> Option<Pin<&mut <Pin<W> as Well>::Target>>

Loads the inner data as a pinned mutable reference.

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

impl<W: Well + Clone> AtomicOption<W>

pub fn load_clone(&self, ordering: Ordering) -> Option<W>

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<W: Well + Debug> Debug for AtomicOption<W>

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

Formats the value using the given formatter.

impl<W: Well> Default for AtomicOption<W>

By default, nothing is stored in the atomic.

fn default() -> Self

Returns the “default value” for a type.

impl<W: Well> Drop for AtomicOption<W>

fn drop(&mut self)

Executes the destructor for this type.

impl<W: Well> From<Option<W>> for AtomicOption<W>

fn from(well: Option<W>) -> Self

Converts to this type from the input type.

impl<W: Well> From<W> for AtomicOption<W>

fn from(well: W) -> Self

Converts to this type from the input type.