Struct GcHeap

#[repr(C)]
pub(crate) struct GcHeap<T: ?Sized> {
    header: UnsafeCell<GcHeader>,
    data: T,
}

A block of memory allocated on the heap that is managed by the garbage collector.

Fields

header: UnsafeCell<GcHeader>

data: T

Implementations

impl GcHeap<SymbolCellInner>

const NULL: *mut u8 = {0x0 as *mut u8}

const EMTPTY: AtomicPtr<u8> = _

fn new_normal(name: &'static str, block: &Block<true>) -> Self

pub(in core) const fn new_static( name: &'static str, ) -> Self

pub(in core) const fn new_static_special( name: &'static str, ) -> Self

fn new_const(name: &'static str, _block: &Block<true>) -> Self

pub(in core) const fn new_static_const( name: &'static str, ) -> Self

fn new_uninterned<const C: bool>(name: &str, bk: &Block<C>) -> Self

impl<T> GcHeap<T>

pub(in core) const fn new( data: T, constant: bool, ) -> Self

pub(in core) const fn new_pure( data: T, ) -> Self

Allocate a new object that is not managed by the garbage collector. This is used for “pure” storage of objects that are allocated at the start of the program and never freed. Only used for the Symbol map at the moment.

fn header(&self) -> &GcHeader

pub(in core) fn forward( &self, fwd_ptr: NonNull<u8>, )

pub(in core) fn allocation_state( &self, ) -> AllocState

fn is_marked(&self) -> bool

Trait Implementations

impl IntoObject for GcHeap<SymbolCellInner>

type Out<'ob> = Symbol<'ob>

fn into_obj<const C: bool>(self, block: &Block<C>) -> Gc<Self::Out<'_>>

impl<T> Markable for GcHeap<T>

type Value = NonNull<GcHeap<T>>

fn move_value(&self, to_space: &Bump) -> Option<(Self::Value, bool)>

impl<T: PartialEq> PartialEq<T> for GcHeap<T>

fn eq(&self, other: &T) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for GcHeap<SymbolCellInner>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialEq> PartialEq for GcHeap<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Trace> Trace for GcHeap<T>

fn trace(&self, state: &mut GcState)

impl<T: Debug + ?Sized> Debug for GcHeap<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for GcHeap<T>

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

Formats the value using the given formatter.

impl<T> Deref for GcHeap<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for GcHeap<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Eq> Eq for GcHeap<T>

impl<T: Sync> Sync for GcHeap<T>