elise 0.1.1

A concurrent GC.
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

use std::pin::Pin;

use gc::{GcPtr, Trace};

use crate::root::Reroot;
use crate::Gc;

pub struct Root<'root> {
    root: Pin<&'root mut gc::Root>,
}

impl<'root> Root<'root> {
    #[doc(hidden)]
    pub unsafe fn new(root: &'root mut gc::Root) -> Root<'root> {
        Root {
            root: Pin::new_unchecked(root),
        }
    }

    pub fn gc<T>(self, data: T) -> Gc<'root, T::Rerooted>
    where
        T: Reroot<'root> + Trace,
        T::Rerooted: Trace,
    {
        unsafe { self.make(gc::alloc_unmanaged(data)) }
    }

    pub fn reroot<T>(self, gc: Gc<'_, T>) -> Gc<'root, T::Rerooted>
    where
        T: Reroot<'root> + ?Sized,
        T::Rerooted: Trace,
    {
        unsafe { self.make(Gc::raw(gc)) }
    }

    pub(crate) unsafe fn make<T>(mut self, ptr: GcPtr<T>) -> Gc<'root, T::Rerooted>
    where
        T: Reroot<'root> + ?Sized,
        T::Rerooted: Trace,
    {
        let ptr = super::reroot(ptr);
        self.emplace(ptr);
        Gc::rooted(ptr)
    }

    unsafe fn emplace<T: Trace + ?Sized>(&mut self, ptr: GcPtr<T>) {
        Pin::get_mut(Pin::as_mut(&mut self.root)).enroot(ptr)
    }
}

#[macro_export]
macro_rules! letroot {
    ($($root:ident)*) => {$(
        // Ensure the root is owned
        let mut $root = $crate::raw::Root::new();

        // Shadow the original binding so that it can't be directly accessed
        // ever again.
        #[allow(unused_mut)]
        let mut $root = unsafe {
            $crate::Root::new(&mut $root)
        };
    )*}
}