Trait scc::ebr::Collectible

source · [−]

pub trait Collectible {
    fn next_ptr_mut(&mut self) -> &mut Option<NonNull<dyn Collectible>>;

    fn drop_and_dealloc(&mut self) { ... }
}

Expand description

Collectible defines key methods for Self to be reclaimed by the EBR garbage collector.

The ebr module provides managed handles which implement Collectible in tandem with atomic reference counting, however it is also possible to manually implement the Collectible trait for a type to pass an instance of the type to the EBR garbage collector via Barrier::defer.

Examples

use scc::ebr::{Barrier, Collectible};
use std::ptr::NonNull;

struct LazyString(String, Option<NonNull<dyn Collectible>>);

impl Collectible for LazyString {
    fn next_ptr_mut(&mut self) -> &mut Option<NonNull<dyn Collectible>> {
        &mut self.1
    }
}

let boxed: Box<LazyString> = Box::new(LazyString(String::from("Lazy"), None));

let static_ref: &'static LazyString = unsafe { std::mem::transmute(&*boxed) };
let barrier_for_ref = Barrier::new();

let barrier_to_drop = Barrier::new();
barrier_to_drop.defer(boxed);
drop(barrier_to_drop);

// The reference is valid as long as a `Barrier` that had been created before `boxed` was
// passed to a `Barrier` survives.
assert_eq!(static_ref.0, "Lazy");

Required Methods

source

fn next_ptr_mut(&mut self) -> &mut Option<NonNull<dyn Collectible>>

Returns a mutable reference to the next Collectible pointer.

Provided Methods

source

fn drop_and_dealloc(&mut self)

Drops itself and frees the memory.