Struct GcTraceCtx 

pub struct GcTraceCtx<'a> { /* private fields */ }

Implementations

impl<'a> GcTraceCtx<'a>

pub const fn opaque(&self) -> *mut u8

pub fn add_node(&mut self, node: NonNull<GcHead>)

Submit a node to collected list regardless its color state.

pub fn add<T: GcNode>(&mut self, gc_ref: GcRef<T>)

Submit a GcRef to collected list

Examples found in repository

examples/error_handling.rs (line 216)

    fn trace(&self, tr: &mut GcTraceCtx) {
        if let Some(next) = self.next {
            tr.add(next);
        }
    }

examples/performance_benchmark.rs (line 286)

    fn trace(&self, tr: &mut GcTraceCtx) {
        for neighbor in &self.neighbors {
            tr.add(*neighbor);
        }
    }

examples/advanced_features.rs (line 356)

    fn trace(&self, tr: &mut GcTraceCtx) {
        if let Some(partner) = self.partner {
            tr.add(partner);
        }
    }
}

impl std::fmt::Display for CyclicNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "CyclicNode({})", self.name)
    }
}

/// Tree node
#[derive(Debug)]
struct TreeNode {
    name: String,
    children: Vec<GcRef<TreeNode>>,
}

impl TreeNode {
    fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            children: Vec::new(),
        }
    }

    fn add_child(&mut self, child: GcRef<TreeNode>) {
        self.children.push(child);
    }
}

impl GcTrace for TreeNode {
    fn trace(&self, tr: &mut GcTraceCtx) {
        for child in &self.children {
            tr.add(*child);
        }
    }
}

impl std::fmt::Display for TreeNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "TreeNode({}, {} children)",
            self.name,
            self.children.len()
        )
    }
}

/// Data container
#[derive(Debug)]
struct DataContainer {
    root: GcRef<TreeNode>,
    metadata: Vec<i32>,
    optional_data: Option<GcRef<TreeNode>>,
}

impl GcTrace for DataContainer {
    fn trace(&self, tr: &mut GcTraceCtx) {
        tr.add(self.root);
        if let Some(data) = self.optional_data {
            tr.add(data);
        }
    }

examples/basic_usage.rs (line 246)

    fn trace(&self, tr: &mut GcTraceCtx) {
        // Trace all child nodes
        for child in &self.children {
            tr.add(*child);
        }
    }

pub fn take_nodes(&mut self) -> Vec<NonNull<GcHead>>