Struct stackarc::ArcInner

#[repr(C)]pub struct ArcInner<T> { /* fields omitted */ }

A type with the same layout as the allocated value of Arc that it's initialized once you convert a mutable reference to it.

This type consist of the strong,weak count of the Arc and a MaybeUninit holding the data.The strong it's set to zero until you cast to the first Arc with to_arc or to_arc_with thus upgrading the count.

Examples

The first use-case of this type is lazy-init an mutable static across threads and drop it when all ceases to use it.

use stackarc::ArcInner;
use std::thread::{sleep, spawn};
use std::time::Duration;
 
static mut A: ArcInner<String> = ArcInner::uninit();
 
fn main() {
    let x = spawn(|| unsafe { 
        let _a = A.to_arc_with(|| format!("foobar")); 
        sleep(Duration::from_secs(2)); 
    });
 
    let y = spawn(|| unsafe {
        let _a = A.to_arc_with(|| format!("barfoo"));  
        sleep(Duration::from_secs(2)); 
    });
 
    // wait one second to wait for the threads to initialize the value
    // which in turn wait another to maintain their reference alive
    // and don't drop the count until create another
    sleep(Duration::from_secs(1)); 
    let z = unsafe { A.to_arc_with(|| format!("baz")) };
  
    assert_ne!(*z, "baz");
 
    drop(z);
    x.join().unwrap();
    y.join().unwrap();
    let z = unsafe { A.to_arc_with(|| format!("foo")) };
     
    assert_eq!(*z, "foo");
}

Implementations

impl<T> ArcInner<T>

pub const fn uninit() -> Self

Declares a new ArcInner in an uninit state,use to_arc_with or to_arc to initialize it.

pub fn to_arc_with<F: FnOnce() -> T>(&mut self, default: F) -> Arc<T>

Returns an Arc after upgrading the counts and initialize the value calling default if the strong is zero.

A good example is at the type docs.

pub fn to_arc(&mut self, x: T) -> Arc<T>

Returns an Arc after upgrading the counts and initialize the value with x if the strong is zero.

A good example is at the type docs.

pub fn as_mut_ptr(&mut self) -> *mut T

Returns a raw mutable pointer to the inner data.

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

Extracts a raw pointer to the inner data.