Struct dumpster::unsync::Gc

pub struct Gc<T: Collectable + ?Sized + 'static> { /* private fields */ }

A garbage-collected pointer.

This garbage-collected pointer may be used for data which is not safe to share across threads (such as a std::cell::RefCell). It can also be used for variably sized data.

Examples

use dumpster::unsync::Gc;

let x: Gc<u8> = Gc::new(3);

println!("{}", *x); // prints '3'
                    // x is then freed automatically!

Implementations

impl<T: Collectable + ?Sized> Gc<T>

pub fn new(value: T) -> Gc<T>where T: Sized,

Construct a new garbage-collected allocation, with value as its value.

Trait Implementations

impl<T: Collectable + ?Sized> AsRef<T> for Gc<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Collectable + ?Sized> Borrow<T> for Gc<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: Collectable + ?Sized> Clone for Gc<T>

fn clone(&self) -> Self

Create a duplicate reference to the same data pointed to by self. This does not duplicate the data.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Collectable + ?Sized> Collectable for Gc<T>

fn accept<V: Visitor>(&self, visitor: &mut V) -> Result<(), ()>

Accept a visitor to this garbage-collected value.

impl<T: Debug + Collectable + ?Sized + 'static> Debug for Gc<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Collectable + Default> Default for Gc<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Collectable + ?Sized> Deref for Gc<T>

fn deref(&self) -> &Self::Target

Dereference this pointer, creating a reference to the contained value T.

Panics

This function may panic if it is called from within the implementation of std::ops::Drop of its owning value, since returning such a reference could cause a use-after-free. It is not guaranteed to panic.

Examples

The following is a correct time to dereference a Gc.

use dumpster::unsync::Gc;

let my_gc = Gc::new(0u8);
let my_ref: &u8 = &my_gc;

Dereferencing a Gc while dropping is not correct.

// This is wrong!
use std::cell::RefCell;
use dumpster::{unsync::Gc, Collectable};

#[derive(Collectable)]
struct Bad {
    s: String,
    cycle: RefCell<Option<Gc<Bad>>>,
}

impl Drop for Bad {
    fn drop(&mut self) {
        // The second time this `print` is executed it will try to
        // print a `String` that has already been dropped.
        println!("{}", self.cycle.borrow().as_ref().unwrap().s)
    }
}

let foo = Gc::new(Bad {
    s: "foo".to_string(),
    cycle: RefCell::new(None),
});

type Target = T

The resulting type after dereferencing.

impl<T: Collectable + ?Sized> Drop for Gc<T>

fn drop(&mut self)

Destroy this garbage-collected pointer.

If this is the last reference which can reach the pointed-to data, the allocation that it points to will be destroyed.

impl<T: Collectable + ?Sized> Pointer for Gc<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.