ghost-gc 0.2.1

A safe garbage collected arena.
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

use core::ops::Deref;
use std::{fmt::Debug, hash::Hash};

use crate::{
    context::Mutation, gc_box::GcBox, locked::Unlock, Collect, Invariant, UniqueGc, Weak, Write,
};

/// A thin, copyable, garbage collected pointer type.
pub struct Gc<'b, T: ?Sized>(GcBox<T>, Invariant<'b>);

impl<'b, T: Collect> Gc<'b, T> {
    /// Allocates garbage collected memory on the heap and then places `val`
    /// into it.
    ///
    /// This allocates regardless of if `T` is zero-sized.
    ///
    /// If initialization of a more complex type is required, see [`UniqueGc`].
    pub fn new(val: T, mt: &Mutation<'b>) -> Gc<'b, T> {
        let this = UniqueGc::new(val, mt);
        UniqueGc::into_gc(this)
    }
}

impl<'b> Gc<'b, str> {
    pub fn from_str(s: &str, mt: &Mutation<'b>) -> Gc<'b, str> {
        UniqueGc::into_gc(UniqueGc::from_str(s, mt))
    }
}

impl<'b, T: ?Sized> Gc<'b, T> {
    pub fn write(&self) -> &Write<T> {
        unsafe { Write::new_unchecked(self) }
    }

    pub fn unlock(&self) -> &T::Unlocked
    where
        T: Unlock,
    {
        self.write().unlock()
    }

    pub fn as_ptr(&self) -> *mut T {
        self.0.data_ptr()
    }

    /// Returns a reference to the contained value, which lasts for as long as
    /// the current view is active.
    pub fn long_ref(&self) -> &'b T {
        unsafe { &*self.as_ptr() }
    }

    pub fn downgrade(this: Gc<'b, T>) -> Weak<'b, T> {
        unsafe { Weak::from_box(this.0) }
    }

    // pub(crate) fn into_box(self) -> GcBox<T> {
    //     self.0
    // }

    pub(crate) unsafe fn from_box(ptr: GcBox<T>) -> Gc<'b, T> {
        Gc(ptr, Invariant)
    }
}

impl<T: ?Sized> Deref for Gc<'_, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { self.0.data() }
    }
}

unsafe impl<T: ?Sized> Collect for Gc<'_, T> {
    const NEEDS_TRACE: bool = true;

    fn trace(&self, c: &crate::Collector) {
        use crate::gc_box::Colour;

        match self.0.colour() {
            Colour::Gray | Colour::White | Colour::Weak => {
                unsafe { self.0.set_colour(Colour::Gray) };

                c.context().push_box(self.0.erase());
            }
            Colour::Black => {}
        }
    }
}

impl<T: ?Sized> Clone for Gc<'_, T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T: ?Sized> Copy for Gc<'_, T> {}

impl<T: Debug + ?Sized> Debug for Gc<'_, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        (**self).fmt(f)
    }
}

impl<T: ?Sized + PartialEq> PartialEq for Gc<'_, T> {
    fn eq(&self, other: &Self) -> bool {
        **self == **other
    }
}

impl<T: ?Sized + Eq> Eq for Gc<'_, T> {}

impl<T: ?Sized + PartialOrd> PartialOrd for Gc<'_, T> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        (**self).partial_cmp(other)
    }
}

impl<T: ?Sized + Ord> Ord for Gc<'_, T> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        (**self).cmp(other)
    }
}

impl<T: ?Sized + Hash> Hash for Gc<'_, T> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        (**self).hash(state);
    }
}