Struct RefCount 

#[repr(C)]
pub struct RefCount {
    pub ptr: *const RefCountInner,
    pub run_destructor: bool,
}

Wrapper around a heap-allocated RefCountInner.

This is the shared metadata that all RefAny clones point to. The RefCount is responsible for all memory management:

• RefCount::clone() increments num_copies in RefCountInner
• RefCount::drop() decrements num_copies and, if it reaches 0:
  1. Frees the RefCountInner
  2. Calls the custom destructor on the data
  3. Deallocates the data memory

Why run_destructor: bool

This flag tracks whether this RefCount instance should decrement num_copies when dropped. Set to true for all clones (including those created by RefAny::clone() and AZ_REFLECT macros). Set to false after the decrement has been performed to prevent double-decrement.

Fields

ptr: *const RefCountInner

run_destructor: bool

Implementations

impl RefCount

pub fn can_be_shared(&self) -> bool

Runtime check: can we create a shared borrow?

Returns true if there are no active mutable borrows. Multiple shared borrows can coexist (like &T in Rust).

Memory Ordering

Uses SeqCst to ensure we see the most recent state from all threads. If another thread just released a mutable borrow, we’ll see it.

pub fn can_be_shared_mut(&self) -> bool

Runtime check: can we create a mutable borrow?

Returns true only if there are ZERO active borrows of any kind. This enforces Rust’s exclusive mutability rule (like &mut T).

Memory Ordering

Uses SeqCst to ensure we see all recent borrows from all threads. Both counters must be checked atomically to prevent races.

pub fn increase_ref(&self)

Increments the shared borrow counter.

Called when a Ref<T> is created. The Ref::drop will decrement it.

Memory Ordering

SeqCst ensures this increment is visible to all threads before they try to acquire a mutable borrow (which checks this counter).

pub fn decrease_ref(&self)

Decrements the shared borrow counter.

Called when a Ref<T> is dropped, indicating the borrow is released.

Underflow guard

Saturates at 0: an unmatched decrement — e.g. a C caller running FooRef_delete after a FAILED downcast with a pre-0.2.1 copy of azul.h (whose macro did not skip the decrease), or a plain double-delete — must not wrap num_refs to usize::MAX, which would make can_be_shared_mut() return false for the rest of the process (callbacks silently stop mutating state).

Memory Ordering

SeqCst ensures this decrement is immediately visible to other threads waiting to acquire a mutable borrow.

pub fn increase_refmut(&self)

Increments the mutable borrow counter.

Called when a RefMut<T> is created. Should only succeed when this counter and num_refs are both 0.

Memory Ordering

SeqCst ensures this increment is visible to all other threads, blocking them from acquiring any borrow (shared or mutable).

pub fn decrease_refmut(&self)

Decrements the mutable borrow counter.

Called when a RefMut<T> is dropped, releasing exclusive access.

Underflow guard

Saturates at 0 (see Self::decrease_ref): a double FooRefMut_delete from C must not wrap num_mutable_refs, which would corrupt the runtime borrow checker and let a second thread or timer callback obtain an aliasing mutable borrow.

Memory Ordering

SeqCst ensures this decrement is immediately visible, allowing other threads to acquire borrows.

Trait Implementations

impl Clone for RefCount

fn clone(&self) -> Self

Clones the RefCount and increments the reference count.

Safety

This is safe because:

• The ptr is valid (created from Box::into_raw)
• num_copies is atomically incremented with SeqCst ordering
• This ensures the RefCountInner is not freed while clones exist

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

Performs copy-assignment from source.

impl Debug for RefCount

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

Formats the value using the given formatter.

impl Drop for RefCount

fn drop(&mut self)

Decrements the reference count when a RefCount clone is dropped.

If this was the last reference (num_copies reaches 0), this will also free the RefCountInner and call the custom destructor.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for RefCount

impl Hash for RefCount

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for RefCount

fn cmp(&self, other: &RefCount) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for RefCount

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for RefCount

fn partial_cmp(&self, other: &RefCount) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl StructuralPartialEq for RefCount