Struct scc::ebr::AtomicArc

pub struct AtomicArc<T: 'static> { /* private fields */ }

AtomicArc owns the underlying instance, and allows users to perform atomic operations on the pointer to it.

Implementations

impl<T: 'static> AtomicArc<T>

pub fn new(t: T) -> AtomicArc<T>

Creates a new AtomicArc from an instance of T.

Examples

use scc::ebr::AtomicArc;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(10);

pub fn from(arc: Arc<T>) -> AtomicArc<T>

Creates a new AtomicArc from an Arc of T.

Examples

use scc::ebr::{Arc, AtomicArc};

let arc: Arc<usize> = Arc::new(10);
let atomic_arc: AtomicArc<usize> = AtomicArc::from(arc);

pub fn null() -> AtomicArc<T>

Creates a null AtomicArc.

Examples

use scc::ebr::AtomicArc;

let atomic_arc: AtomicArc<usize> = AtomicArc::null();

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

Returns true if the AtomicArc is null.

Examples

use scc::ebr::{AtomicArc, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::null();
atomic_arc.update_tag_if(Tag::Both, |t| t == Tag::None, Relaxed);
assert!(atomic_arc.is_null(Relaxed));

pub fn load<'b>(&self, order: Ordering, _barrier: &'b Barrier) -> Ptr<'b, T>

Loads a pointer value from the AtomicArc.

Examples

use scc::ebr::{AtomicArc, Barrier};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(11);
let barrier = Barrier::new();
let ptr = atomic_arc.load(Relaxed, &barrier);
assert_eq!(*ptr.as_ref().unwrap(), 11);

pub fn swap(
    &self,
    new: (Option<Arc<T>>, Tag),
    order: Ordering
) -> Option<Arc<T>>

Stores the given value into the AtomicArc and returns the original value.

Examples

use scc::ebr::{Arc, AtomicArc, Barrier, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(14);
let barrier = Barrier::new();
let old = atomic_arc.swap((Some(Arc::new(15)), Tag::Second), Relaxed);
assert_eq!(*old.unwrap(), 14);
let old = atomic_arc.swap((None, Tag::First), Relaxed);
assert_eq!(*old.unwrap(), 15);
let old = atomic_arc.swap((None, Tag::None), Relaxed);
assert!(old.is_none());

pub fn tag(&self, order: Ordering) -> Tag

Returns its Tag.

Examples

use scc::ebr::{AtomicArc, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::null();
assert_eq!(atomic_arc.tag(Relaxed), Tag::None);

pub fn update_tag_if<F: FnMut(Tag) -> bool>(
    &self,
    tag: Tag,
    condition: F,
    order: Ordering
) -> bool

Sets a new Tag if the given condition is met.

It returns true if the condition is met.

Examples

use scc::ebr::{AtomicArc, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::null();
assert!(atomic_arc.update_tag_if(Tag::Both, |t| t == Tag::None, Relaxed));
assert_eq!(atomic_arc.tag(Relaxed), Tag::Both);

pub fn compare_exchange<'b>(
    &self,
    current: Ptr<'b, T>,
    new: (Option<Arc<T>>, Tag),
    success: Ordering,
    failure: Ordering
) -> Result<(Option<Arc<T>>, Ptr<'b, T>), (Option<Arc<T>>, Ptr<'b, T>)>

Performs CAS on the AtomicArc.

It returns Ok with the previously held Arc and the updated Ptr upon a successful operation.

Errors

It returns Err with the supplied Arc and the current Ptr.

Examples

use scc::ebr::{Arc, AtomicArc, Barrier, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(17);
let barrier = Barrier::new();

let mut ptr = atomic_arc.load(Relaxed, &barrier);
assert_eq!(*ptr.as_ref().unwrap(), 17);

atomic_arc.update_tag_if(Tag::Both, |_| true, Relaxed);
assert!(atomic_arc.compare_exchange(
    ptr, (Some(Arc::new(18)), Tag::First), Relaxed, Relaxed).is_err());

ptr.set_tag(Tag::Both);
let old: Arc<usize> = atomic_arc.compare_exchange(
    ptr, (Some(Arc::new(18)), Tag::First), Relaxed, Relaxed).unwrap().0.unwrap();
assert_eq!(*old, 17);
drop(old);

assert!(atomic_arc.compare_exchange(
    ptr, (Some(Arc::new(19)), Tag::None), Relaxed, Relaxed).is_err());
assert_eq!(*ptr.as_ref().unwrap(), 17);

pub fn clone(&self, order: Ordering, _barrier: &Barrier) -> AtomicArc<T>

Clones self including tags.

Examples

use scc::ebr::{Arc, AtomicArc, Barrier};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(59);
let barrier = Barrier::new();
let atomic_arc_cloned = atomic_arc.clone(Relaxed, &barrier);
let ptr = atomic_arc_cloned.load(Relaxed, &barrier);
assert_eq!(*ptr.as_ref().unwrap(), 59);

pub fn get_arc(&self, order: Ordering, _barrier: &Barrier) -> Option<Arc<T>>

Tries to create an Arc out of self.

Examples

use scc::ebr::{Arc, AtomicArc, Barrier};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(47);
let barrier = Barrier::new();
let arc: Arc<usize> = atomic_arc.get_arc(Relaxed, &barrier).unwrap();
assert_eq!(*arc, 47);

pub fn try_into_arc(self, order: Ordering) -> Option<Arc<T>>

Tries to convert self into an Arc.

Examples

use scc::ebr::{Arc, AtomicArc};
use std::sync::atomic::Ordering::Relaxed;

let atomic_arc: AtomicArc<usize> = AtomicArc::new(55);
let arc: Arc<usize> = atomic_arc.try_into_arc(Relaxed).unwrap();
assert_eq!(*arc, 55);

Trait Implementations

impl<T: 'static> Clone for AtomicArc<T>

fn clone<'b>(&self) -> AtomicArc<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + 'static> Debug for AtomicArc<T>

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

Formats the value using the given formatter.

impl<T> Default for AtomicArc<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: 'static> Drop for AtomicArc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: 'static> Send for AtomicArc<T>