Struct shredder::Gc

pub struct Gc<T: Scan> { /* fields omitted */ }

A smart-pointer for data tracked by shredder garbage collector

Implementations

impl<T: Scan> Gc<T>

pub fn new(v: T) -> Self where
    T: 'static, 

Create a new Gc containing the given data. T: 'static in order to create a Gc<T> with this method. If your T is not static, consider new_with_finalizer.

When this data is garbage collected, its drop implementation will be run.

It is possible for this data not to be collected before the program terminates, or for the program to terminate before the background thread runs its destructor. So be careful when relying on this guarantee.

pub fn new_no_drop(v: T) -> Self

Create a new Gc containing the given data. (But specifying not to run its destructor.) This is useful because T: 'static is no longer necessary!

When this data is garbage collected, its drop implementation will NOT be run. Be careful using this method! It can lead to memory leaks!

pub fn new_with_finalizer(v: T) -> Self where
    T: Finalize, 

Create a new Gc containing the given data. (But specifying to call finalize on it instead of running its destructor.) This is useful because T: 'static is no longer necessary!

As long as finalize does what you think it does, this is probably what you want for non-'static data!

It is possible for this data not to be collected before the program terminates, or for the program to terminate before the background thread runs finalize. So be careful!

#[must_use]pub fn get(&self) -> GcGuard<T>

get lets you get a GcGuard, which will deref to the underlying data.

get is used to get a GcGuard. This is usually what you want when accessing non-Sync data in a Gc. The API is very analogous to the Mutex API. It may block if the data is being scanned

impl<T: Scan + 'static> Gc<RefCell<T>>

#[must_use]pub fn borrow(&self) -> GcRef<T>

Call the underlying borrow method on the RefCell.

This is just a nice method so you don't have to call get manually.

pub fn try_borrow(&self) -> Result<GcRef<T>, BorrowError>

Call the underlying try_borrow method on the RefCell.

This is just a nice method so you don't have to call get manually.

Errors

Propagates a BorrowError if the underlying RefCell is already borrowed mutably

#[must_use]pub fn borrow_mut(&self) -> GcRefMut<T>

Call the underlying borrow_mut method on the RefCell.

This is just a nice method so you don't have to call get manually.

pub fn try_borrow_mut(&self) -> Result<GcRefMut<T>, BorrowMutError>

Call the underlying try_borrow_mut method on the RefCell.

This is just a nice method so you don't have to call get manually.

Errors

Propagates a BorrowError if the underlying RefCell is already borrowed

impl<T: Scan + 'static> Gc<Mutex<T>>

pub fn lock(&self) -> Result<GcMutexGuard<T>, GcPoisonError<GcMutexGuard<T>>>

Call the underlying lock method on the inner Mutex

This is just a nice method so you don't have to get manually

Errors

Returns a GcPoisonError if the underlying .lock method returns a poison error. You may use into_inner in order to recover the guard from that error.

pub fn try_lock(
    &self
) -> Result<GcMutexGuard<T>, GcTryLockError<GcMutexGuard<T>>>

Call the underlying try_lock method on the inner Mutex

This is just a nice method so you don't have to get manually

Errors

Returns a GcTryLockError if the underlying .try_lock method returns an error

impl<T: Scan + 'static> Gc<RwLock<T>>

pub fn read(
    &self
) -> Result<GcRwLockReadGuard<T>, GcPoisonError<GcRwLockReadGuard<T>>>

Call the underlying read method on the inner RwLock

This is just a nice method so you don't have to get manually

Errors

Returns a GcPoisonError if the underlying read method returns a poison error. You may use into_inner in order to recover the guard from that error.

pub fn write(
    &self
) -> Result<GcRwLockWriteGuard<T>, GcPoisonError<GcRwLockWriteGuard<T>>>

Call the underlying write method on the inner RwLock

This is just a nice method so you don't have to get manually

Errors

Returns a GcPoisonError if the underlying write method returns a poison error. You may use into_inner in order to recover the guard from that error.

pub fn try_read(
    &self
) -> Result<GcRwLockReadGuard<T>, GcTryLockError<GcRwLockReadGuard<T>>>

Call the underlying try_read method on the inner RwLock

This is just a nice method so you don't have to get manually

Errors

Returns a GcTryLockError if the underlying try_read method returns an error

pub fn try_write(
    &self
) -> Result<GcRwLockWriteGuard<T>, GcTryLockError<GcRwLockWriteGuard<T>>>

Call the underlying try_write method on the inner RwLock

This is just a nice method so you don't have to get manually

Errors

Returns a GcTryLockError if the underlying try_write method returns an error

Trait Implementations

impl<T: Scan> Clone for Gc<T>

#[must_use]fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Scan> Debug for Gc<T>

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

Formats the value using the given formatter.

impl<T: Scan> Default for Gc<T> where
    T: Default + 'static, 

#[must_use]fn default() -> Self

Returns the "default value" for a type.

impl<T: Scan> Display for Gc<T> where
    T: Display, 

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

Formats the value using the given formatter.

impl<T: Scan> Drop for Gc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Scan> Eq for Gc<T> where
    T: Eq, 

impl<T: Scan> Finalize for Gc<T>

unsafe fn finalize(&mut self)

Do cleanup on this data, potentially leaving it in an invalid state. (See trait documentation for the rules for implementing this method.)

impl<T: Scan> GcSafe for Gc<T>

impl<T: Scan> Hash for Gc<T> where
    T: Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Scan> Ord for Gc<T> where
    T: Ord, 

#[must_use]fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: Scan> PartialEq<Gc<T>> for Gc<T> where
    T: PartialEq, 

#[must_use]fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Self) -> bool

This method tests for !=.

impl<T: Scan> PartialOrd<Gc<T>> for Gc<T> where
    T: PartialOrd, 

#[must_use]fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Self) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Self) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Self) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Self) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Scan> Pointer for Gc<T>

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

Formats the value using the given formatter.

impl<T: Scan> Scan for Gc<T>

fn scan(&self, scanner: &mut Scanner)

scan should use the scanner to scan all of its directly owned data

impl<T: Scan> Send for Gc<T> where
    T: Sync + Send, 

impl<T: Scan> Sync for Gc<T> where
    T: Sync + Send,