Struct ArcGc 

pub struct ArcGc<T: ?Sized + Send + Sync + 'static, C: Collector = GlobalRtGc> { /* private fields */ }

A realtime-safe wrapper around Arc that when dropped, automatically has its contents collected and later deallocated on another non-realtime thread.

The performance characteristics of ArcGc are equivalant to Arc when reading (but constructing an ArcGc is a bit more expensive).

Equality checking between instances of ArcGc relies only on pointer equivalence. If you need to evaluate the equality of the values contained by ArcGc, you’ll need to be careful to ensure you explicitly take references of the inner data.

Example

let value: ArcGc<String> = ArcGc::new(String::from("foo"));

// A simulated "realtime thread"
let rt_thread = std::thread::spawn(move || {
    std::thread::sleep(Duration::from_millis(15));

    // Dropping the values on the realtime thread is realtime-safe
    // because the contents are automatically collected and
    // deallocated on a separate non-realtime thread.
    let _ = value;
});

// A simulated update loop on the main thread
for _ in 0..4 {
    // Call `GlobalRtGc::collect()` periodically to deallocate
    // any resources that were dropped on the realtime thread.
    GlobalRtGc::collect();

    std::thread::sleep(Duration::from_millis(15));
}

Implementations

impl<T: Send + Sync + 'static> ArcGc<T, LocalRtGc>

pub fn new_loc(value: T, handle: &LocalRtGcHandle) -> Self

Construct a new ArcGc.

let collector = LocalRtGc::new();
let handle = collector.handle();

let value: ArcGc<String, LocalRtGc> = ArcGc::new_loc(String::from("foo"), &handle);

impl<T: ?Sized + Send + Sync + 'static> ArcGc<T, LocalRtGc>

pub fn new_unsized_loc( f: impl FnOnce() -> Arc<T>, handle: &LocalRtGcHandle, ) -> Self

Construct a new ArcGc with unsized data, such as [T] or dyn Trait.

let collector = LocalRtGc::new();
let handle = collector.handle();

let value_1: ArcGc<[f32], LocalRtGc> = ArcGc::new_unsized_loc(
    || Arc::<[f32]>::from([1.0, 2.0, 3.0]),
    &handle
);

trait Foo: Send + Sync {}
struct Bar {}
impl Foo for Bar {}

let value_2: ArcGc<dyn Foo, LocalRtGc> = ArcGc::new_unsized_loc(
    || Arc::new(Bar {}) as Arc<dyn Foo>,
    &handle
);

impl ArcGc<dyn Any + Send + Sync + 'static, LocalRtGc>

pub fn new_any_loc<T: Send + Sync + 'static>( value: T, handle: &LocalRtGcHandle, ) -> Self

Construct a type-erased ArcGc.

let collector = LocalRtGc::new();
let handle = collector.handle();

let value: ArcGc<dyn Any + Send + Sync + 'static, LocalRtGc> =
    ArcGc::new_any_loc(String::new(), &handle);

impl<T: Send + Sync + 'static> ArcGc<T, GlobalRtGc>

pub fn new(value: T) -> Self

Construct a new ArcGc.

let value: ArcGc<String> = ArcGc::new(String::from("foo"));

impl<T: ?Sized + Send + Sync + 'static> ArcGc<T, GlobalRtGc>

pub fn new_unsized(f: impl FnOnce() -> Arc<T>) -> Self

Construct a new ArcGc with unsized data, such as [T] or dyn Trait.

let value_1: ArcGc<[f32]> = ArcGc::new_unsized(
    || Arc::<[f32]>::from([1.0, 2.0, 3.0]),
);

trait Foo: Send + Sync {}
struct Bar {}
impl Foo for Bar {}

let value_2: ArcGc<dyn Foo> = ArcGc::new_unsized(
    || Arc::new(Bar {}) as Arc<dyn Foo>,
);

impl ArcGc<dyn Any + Send + Sync + 'static, GlobalRtGc>

pub fn new_any<T: Send + Sync + 'static>(value: T) -> Self

Construct a type-erased ArcGc.

let value: ArcGc<dyn Any + Send + Sync + 'static> =
    ArcGc::new_any(String::from("foo"));

impl<T: ?Sized + Send + Sync + 'static> ArcGc<T>

pub fn ptr_eq(this: &Self, other: &Self) -> bool

A wrapper around std::sync::Arc::ptr_eq.

Trait Implementations

impl<T: ?Sized + Send + Sync + 'static> Clone for ArcGc<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized + Send + Sync + 'static> Debug for ArcGc<T>

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

Formats the value using the given formatter.

impl<T: ?Sized + Send + Sync + 'static> Deref for ArcGc<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized + Send + Sync + 'static, C: Collector> Drop for ArcGc<T, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized + Send + Sync + 'static> PartialEq for ArcGc<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: ?Sized + Send + Sync + 'static> Eq for ArcGc<T>