Struct TraitObjectPtr 

#[repr(transparent)]
pub struct TraitObjectPtr(pub *const TraitObjectStorage);

Owning newtype around *const TraitObjectStorage carrying one v2-raw refcount share on the pointed-to allocation’s HeapHeader.

Wave 2 Round 4 D4 ckpt-final-prime² (2026-05-14): mirrors the TypedObjectPtr precedent (above) for TraitObjectStorage. Carrier shape used as both:

• HeapValue::TraitObject(TraitObjectPtr) variant payload
• Future TypedArrayData::TraitObject element type (if/when the §Q25.A monomorphic specialization for trait-object-element arrays lands; not under this ckpt’s scope)

#[repr(transparent)] so the in-memory layout is identical to *const TraitObjectStorage — zero ABI cost vs the raw pointer; the wrapper exists only to localize the manual Send/Sync impl + the Drop/Clone refcount discipline. Same auto-trait suppression rule applies as for TypedObjectPtr — per-T newtype is the canonical workaround for raw-ptr inner elements in HeapValue variant payloads without disabling Rust’s auto-derived Send/Sync/Clone/Drop on the enclosing HeapValue enum.

Construction-side contract: callers transfer one strong-count share on the v2-raw HeapHeader (initialized to 1 via TraitObjectStorage::_new) to the new TraitObjectPtr. Reads via as_ptr() return the underlying pointer without bumping refcount.

Tuple Fields

0: *const TraitObjectStorage

Implementations

impl TraitObjectPtr

pub fn new(ptr: *const TraitObjectStorage) -> Self

Construct from a raw pointer obtained via TraitObjectStorage::_new. The caller transfers one strong-count share to the wrapper.

pub fn as_ptr(&self) -> *const TraitObjectStorage

Recover the underlying raw pointer. Does NOT bump refcount; the returned pointer is borrowed for the wrapper’s lifetime.

pub fn is_null(&self) -> bool

Whether the pointer is null.

pub fn into_raw(self) -> *const TraitObjectStorage

Consume the wrapper without running Drop, returning the raw pointer. The caller takes over the one refcount share. Mirror of Arc::into_raw.

Methods from Deref<Target = TraitObjectStorage>

pub fn method(&self, name: &str) -> Option<&VTableEntry>

Convenience: look up a method by name in the vtable. Returns None for an unknown method (the dispatch tier surfaces this as a runtime error — under universal-dyn there is no compile- time ETO-002 for “method not in trait” since the trait’s declared method set is the surface checked at compile time; runtime lookup failures indicate a vtable-construction bug).

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

Identity check for the §Q25.C.2 Self-arg runtime contract. Arc::ptr_eq on vtable Arcs is the tightest comparison; both TraitObjectStorage instances must share the same vtable allocation (which happens when both came from the same (impl Trait for Type) pair).

Trait Implementations

impl Clone for TraitObjectPtr

fn clone(&self) -> Self

v2-raw refcount bump via v2_retain on the pointed-to HeapHeader. The clone owns its own share, retired at its own Drop.

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

Performs copy-assignment from source.

impl Debug for TraitObjectPtr

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

Formats the value using the given formatter.

impl Default for TraitObjectPtr

fn default() -> Self

Null pointer default — used by container types that need a Default impl. Callers must not dereference a default-constructed TraitObjectPtr. No refcount share is owed; Drop on a null pointer is a no-op.

impl Deref for TraitObjectPtr

type Target = TraitObjectStorage

The resulting type after dereferencing.

fn deref(&self) -> &TraitObjectStorage

Dereferences the value.

impl Drop for TraitObjectPtr

fn drop(&mut self)

Retire the owned share via TraitObjectStorage::release_elem (HeapElement trait — calls v2_release and, on refcount=0, runs _drop to dealloc the allocation + retire inner shares). No-op on null wrappers.

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 Hash for TraitObjectPtr

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 HashMapValueElem for TraitObjectPtr

unsafe fn release_typed_array(ptr: *mut TypedArray<Self>)

Mirror of the TypedObjectPtr impl above; per-element Drop runs release_elem on *const TraitObjectStorage.

unsafe fn share_clone(elem: &Self) -> Self

Clone a single element with proper refcount-share semantics.

unsafe fn release_owned(_value: Self)

Release a single owned value (one refcount share). For POD V it is a no-op (byte copy falls out of scope). For HeapElement V the share is retired via release_elem on the pointer. For Ptr-newtype V the wrapper’s Drop runs automatically when the value drops.

impl PartialEq for TraitObjectPtr

fn eq(&self, other: &TraitObjectPtr) -> 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 Eq for TraitObjectPtr

impl Send for TraitObjectPtr

impl StructuralPartialEq for TraitObjectPtr

impl Sync for TraitObjectPtr