cabbage_collector 0.1.1

ready
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
127
128

#![allow(unused)]

use cabbage_collector::{COLLECTOR, CabbageBox};

#[derive(Debug, Clone)]
struct SampleChild {
    pub value: CabbageBox<i32>,
}

fn step1() {
    println!("----------------");
    println!("---- STEP 1 ----");

    {
        #[derive(Debug, Clone)]
        struct A {
            pub value: i32,
        }

        let child_obj = CabbageBox::new_root(A { value: 1 });
        println!("{:?}", child_obj);
    }
    println!("Before GC");
    COLLECTOR.print_for_debug();
    COLLECTOR.run_cabbage_collection();
    println!("After GC");
    COLLECTOR.print_for_debug();
}

fn step2() {
    println!("----------------");
    println!("---- STEP 2 ----");

    {
        #[derive(Debug, Clone)]
        struct A {
            pub value: i32,
        }

        let child_obj = CabbageBox::new_root(A { value: 1 });
        println!("{:?}", child_obj);

        let cloned_obj = child_obj.clone();
        println!("{:?}", cloned_obj);

        COLLECTOR.print_for_debug();
    }
    println!("Before GC");
    COLLECTOR.print_for_debug();
    COLLECTOR.run_cabbage_collection();
    println!("After GC");
    COLLECTOR.print_for_debug();
}

fn step3() {
    println!("----------------");
    println!("---- STEP 3 ----");

    {
        #[derive(Debug, Clone)]
        struct Child {
            pub value: i32,
        }

        #[derive(Debug, Clone)]
        struct Parent {
            pub child: CabbageBox<Child>,
        }

        let child_obj = CabbageBox::new_non_root(Child { value: 1 });

        let mut parent_obj = CabbageBox::new_root(Parent {
            child: child_obj.clone(),
        });
        parent_obj.adopt_child(child_obj);

        COLLECTOR.print_for_debug();
    }
    println!("Before GC");
    COLLECTOR.print_for_debug();
    COLLECTOR.run_cabbage_collection();
    println!("After GC");
    COLLECTOR.print_for_debug();
}

// circular reference
fn step4() {
    println!("----------------");
    println!("---- STEP 4 ----");

    {
        #[derive(Debug, Clone)]
        struct A {
            pub value: Option<CabbageBox<B>>,
        }

        #[derive(Debug, Clone)]
        struct B {
            pub value: Option<CabbageBox<A>>,
        }

        let mut a_obj = CabbageBox::new_root(A { value: None });
        let mut b_obj = CabbageBox::new_root(B { value: None });

        a_obj.value = Some(b_obj.clone());
        a_obj.adopt_child(b_obj.clone());

        b_obj.value = Some(a_obj.clone());
        b_obj.adopt_child(a_obj.clone());

        COLLECTOR.print_for_debug();
    }
    println!("Before GC");
    COLLECTOR.print_for_debug();
    COLLECTOR.run_cabbage_collection();
    println!("After GC");
    COLLECTOR.print_for_debug();
}

fn main() {
    // step1();

    // step2();

    step3();

    // step4();
}