osom_lib_arc 0.1.21

ABI-stable atomic reference counted pointers for osom_lib.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#![cfg(feature = "std")]

use std::sync::{Arc, Mutex, atomic::AtomicU32};

use osom_lib_arc::std::{StdCArc, StdCWeak};

#[test]
fn test_carc() {
    let arc = StdCArc::new(42).unwrap();
    assert_eq!(StdCArc::strong_count(&arc), 1);
    assert_eq!(StdCArc::weak_count(&arc), 1);
    let weak = StdCArc::downgrade(&arc).unwrap();
    assert_eq!(StdCArc::strong_count(&arc), 1);
    assert_eq!(StdCArc::weak_count(&arc), 2);
    let up = weak.upgrade().unwrap();
    assert_eq!(StdCArc::strong_count(&arc), 2);
    assert_eq!(StdCArc::weak_count(&arc), 2);
    drop(weak);
    assert_eq!(StdCArc::strong_count(&arc), 2);
    assert_eq!(StdCArc::weak_count(&arc), 1);
    drop(up);
    assert_eq!(StdCArc::strong_count(&arc), 1);
    assert_eq!(StdCArc::weak_count(&arc), 1);

    let arc_clone = arc.clone();
    assert_eq!(StdCArc::strong_count(&arc), 2);
    assert_eq!(StdCArc::weak_count(&arc), 1);
    assert_eq!(StdCArc::strong_count(&arc_clone), 2);
    assert_eq!(StdCArc::weak_count(&arc_clone), 1);
    assert_eq!(StdCArc::data(&arc), &42);
    assert_eq!(StdCArc::data(&arc_clone), &42);
}

#[test]
fn test_drop() {
    struct Data {
        pub counter: Arc<AtomicU32>,
    }

    impl Drop for Data {
        fn drop(&mut self) {
            self.counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        }
    }

    let counter = Arc::new(AtomicU32::new(0));
    let get = || counter.load(std::sync::atomic::Ordering::SeqCst);

    let data = StdCArc::new(Data {
        counter: counter.clone(),
    })
    .unwrap();
    assert_eq!(get(), 0);
    let data2 = data.clone();
    assert_eq!(get(), 0);
    drop(data2);
    assert_eq!(get(), 0);
    drop(data);
    assert_eq!(get(), 1);
}

#[test]
#[allow(unused)]
fn test_cyclic_dependencies() {
    struct Counter {
        inner: Arc<AtomicU32>,
    }

    impl Counter {
        pub fn new() -> Self {
            Self {
                inner: Arc::new(AtomicU32::new(0)),
            }
        }

        pub fn get(&self) -> u32 {
            self.inner.load(std::sync::atomic::Ordering::SeqCst)
        }
    }

    impl Drop for Counter {
        fn drop(&mut self) {
            self.inner.fetch_sub(1, std::sync::atomic::Ordering::SeqCst);
        }
    }

    impl Clone for Counter {
        fn clone(&self) -> Self {
            self.inner.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
            Self {
                inner: self.inner.clone(),
            }
        }
    }

    struct Parent {
        children: Arc<Mutex<Vec<StdCArc<Child>>>>,
        counter: Counter,
    }

    struct Child {
        parent: StdCWeak<Parent>,
        counter: Counter,
    }

    let counter = Counter::new();
    let parent = Parent {
        children: Arc::new(Mutex::new(Vec::new())),
        counter: counter.clone(),
    };
    let parent = StdCArc::new(parent).unwrap();

    for _ in 0..10 {
        let child = Child {
            parent: StdCArc::downgrade(&parent).unwrap(),
            counter: counter.clone(),
        };
        let child = StdCArc::new(child).unwrap();
        let mut children = parent.children.lock().unwrap();
        children.push(child);
    }

    assert_eq!(counter.get(), 11);
    drop(parent);
    assert_eq!(counter.get(), 0);
}