Struct ArcIllegal

pub struct ArcIllegal<T> { /* private fields */ }

ArcIllegal is an Arc that’s illegal

ArcIllegal can always use it’s contents as mutable, it sounds unsafe and is unsafe too, but now without unsafe code blocks (they’re just hidden in this lib), because that’s what we’re Measuring these days

use eater_arc_illegal::ArcIllegal;
use std::time::Duration;
use std::thread::{spawn, sleep};

let mut x = ArcIllegal::new("hewwo".to_string());
let mut y = x.clone();
let mut z = y.dup();
let a = &mut *x;
let b = &mut *y.dup();
let c = &mut *z.dup();
c.push_str(" wo");
b.push_str("rl");
a.push_str("d!");
y.push_str(" :)");

let mut zz = z.dup();

spawn(move || {
    z.push_str(" :OOO");
});

spawn(move || {
    zz.push_str("race!!!");
});

println!("{}", a);
delay(Duration::from_millis(50));
println!("{}", a);

Implementations

impl<T> ArcIllegal<T>

pub fn new(inner: T) -> ArcIllegal<T>

Creates a new ArcIllegal for given object

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

Returns the raw pointer of the value

pub fn ref_count(&self) -> usize

Return the amount of references that hold this object

pub fn weak_ref_count(&self) -> usize

Return the amount of weak references that hold this object

pub fn strong_ref_count(&self) -> usize

Return the amount of “strong” references that hold this object

pub fn dup(&self) -> Self

Clones the ArcIllegal, convenience function for when the held type can be cloned

Examples found in repository

examples/thread_num.rs (line 5)

fn main() {
    let mut shared_num = arc(4);
    let mut cloned = shared_num.dup();
    *shared_num += 2;

    std::thread::spawn(move || {
        *cloned += 2;
    });

    std::thread::sleep(std::time::Duration::from_secs(1));

    assert_eq!(8, *shared_num);
}

pub fn weak(&self) -> WeakIllegal<T>

Get a Weak reference to the value inside the IllegalArc

pub fn dismantle(self) -> Result<T, Self>

If we’re the only reference, destroy it and give the object back as owned

pub fn dismantle_with_weak(self) -> Result<T, Self>

Trait Implementations

impl<T> Clone for ArcIllegal<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> Debug for ArcIllegal<T>

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

Formats the value using the given formatter.

impl<T> Deref for ArcIllegal<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for ArcIllegal<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: Display> Display for ArcIllegal<T>

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

Formats the value using the given formatter.

impl<T> Drop for ArcIllegal<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for ArcIllegal<T>

impl<T> Sync for ArcIllegal<T>