Struct scc::ebr::Arc

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

Arc is a reference-counted handle to an instance.

Implementations

impl<T: 'static> Arc<T>

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

Creates a new instance of Arc.

Examples

use scc::ebr::Arc;

let arc: Arc<usize> = Arc::new(31);

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

Generates a Ptr out of the Arc.

Examples

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

let arc: Arc<usize> = Arc::new(37);
let barrier = Barrier::new();
let ptr = arc.ptr(&barrier);
assert_eq!(*ptr.as_ref().unwrap(), 37);

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

Returns a mutable reference to the underlying instance if the instance is exclusively owned.

Safety

If there is no Ptr to the underlying instance, it is safe.

Examples

use scc::ebr::Arc;

let mut arc: Arc<usize> = Arc::new(38);
unsafe {
    *arc.get_mut().unwrap() += 1;
}
assert_eq!(*arc, 39);

pub fn as_ptr(&self) -> *const T

Provides a raw pointer to the underlying instance.

Examples

use scc::ebr::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;

let arc: Arc<usize> = Arc::new(10);
let arc_cloned: Arc<usize> = arc.clone();

assert_eq!(arc.as_ptr(), arc_cloned.as_ptr());
assert_eq!(unsafe { *arc.as_ptr() }, unsafe { *arc_cloned.as_ptr() });

pub unsafe fn drop_in_place(self)

Drops the underlying instance if the last reference is dropped.

The instance is not passed to the garbage collector when the last reference is dropped, instead the method drops the instance immediately. The semantics is the same as that of std::sync::Arc.

Safety

The caller must ensure that there is no Ptr pointing to the instance.

Examples

use scc::ebr::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;

static DROPPED: AtomicBool = AtomicBool::new(false);
struct T(&'static AtomicBool);
impl Drop for T {
    fn drop(&mut self) {
        self.0.store(true, Relaxed);
    }
}

let arc: Arc<T> = Arc::new(T(&DROPPED));

unsafe {
    arc.drop_in_place();
}
assert!(DROPPED.load(Relaxed));

Trait Implementations

impl<T: 'static> Clone for Arc<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 + 'static> Debug for Arc<T>

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

Formats the value using the given formatter.

impl<T: 'static> Deref for Arc<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<'b, T: 'static> TryFrom<Ptr<'b, T>> for Arc<T>

type Error = Ptr<'b, T>

The type returned in the event of a conversion error.

fn try_from(ptr: Ptr<'b, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: 'static + Send> Send for Arc<T>

impl<T: 'static + Sync> Sync for Arc<T>