Struct ptr_union::Union2

pub struct Union2<A: ErasablePtr, B: ErasablePtr> { /* fields omitted */ }

A pointer union of two pointer types.

This is a tagged union of two pointer types such as Box, Arc, or & that is only as big as a single pointer. This is accomplished by storing the tag in the alignment bits of the pointer.

As such, the pointer must be aligned to at least u16 (align(2)). This is enforced through the use of Builder2.

Implementations

impl<A: ErasablePtr, B: ErasablePtr> Union2<A, B>

pub fn is_a(&self) -> bool

Check if the union is this variant.

pub fn into_a(self) -> Result<A, Self>

Extract this variant from the union.

Returns the union on error.

pub fn with_a<R>(&self, f: impl FnOnce(&A) -> R) -> Option<R>

Run a closure with this variant.

pub fn a(&self) -> Option<&A::Target> where
    A: Deref, 

Get a reference to this variant's target.

pub fn clone_a(&self) -> Option<A> where
    A: Clone, 

Clone this variant out of the union.

pub fn copy_a(&self) -> Option<A> where
    A: Copy, 

Copy this variant out of the union.

pub fn is_b(&self) -> bool

Check if the union is this variant.

pub fn into_b(self) -> Result<B, Self>

Extract this variant from the union.

Returns the union on error.

pub fn with_b<R>(&self, f: impl FnOnce(&B) -> R) -> Option<R>

Run a closure with this variant.

pub fn b(&self) -> Option<&B::Target> where
    B: Deref, 

Get a reference to this variant's target.

pub fn clone_b(&self) -> Option<B> where
    B: Clone, 

Clone this variant out of the union.

pub fn copy_b(&self) -> Option<B> where
    B: Copy, 

Copy this variant out of the union.

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

Check if two unions are the same variant and point to the same value (not that the values compare as equal).

pub fn as_deref<'a>(
    &'a self,
    builder: Builder2<&'a A::Target, &'a B::Target>
) -> Union2<&'a A::Target, &'a B::Target> where
    A: Deref,
    B: Deref,
    &'a A::Target: ErasablePtr,
    &'a B::Target: ErasablePtr, 

Dereference the current pointer.

pub unsafe fn as_deref_unchecked<'a>(
    &'a self
) -> Union2<&'a A::Target, &'a B::Target> where
    A: Deref,
    B: Deref,
    &'a A::Target: ErasablePtr,
    &'a B::Target: ErasablePtr, 

Dereference the current pointer.

Safety

The reference produced must be properly aligned. Note that only the actually produced reference is restricted, not the result of dereferencing any of the other types in this union.

pub fn unpack(self) -> Enum2<A, B>

Unpack this union into an enum.

pub fn as_untagged_ptr(&self) -> ErasedPtr

Get the raw type-erased untagged pointer to the payload.

Trait Implementations

impl<A: ErasablePtr, B: ErasablePtr> Clone for Union2<A, B> where
    A: Clone,
    B: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: ErasablePtr, B: ErasablePtr> Debug for Union2<A, B> where
    A: Debug,
    B: Debug, 

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

Formats the value using the given formatter.

impl<A: ErasablePtr, B: ErasablePtr> Drop for Union2<A, B>

fn drop(&mut self)

Executes the destructor for this type.

impl<A: ErasablePtr, B: ErasablePtr> Eq for Union2<A, B> where
    A: Eq,
    B: Eq, 

impl<A: ErasablePtr, B: ErasablePtr> ErasablePtr for Union2<A, B>

fn erase(this: Self) -> ErasedPtr

Turn this erasable pointer into an erased pointer.

unsafe fn unerase(this: ErasedPtr) -> Self

Unerase this erased pointer.

impl<A: ErasablePtr, B: ErasablePtr> Hash for Union2<A, B> where
    A: Hash,
    B: Hash, 

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

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<A: ErasablePtr, B: ErasablePtr> PartialEq<Union2<A, B>> for Union2<A, B> where
    A: PartialEq,
    B: PartialEq, 

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: &Rhs) -> bool

This method tests for !=.

impl<A: ErasablePtr, B: ErasablePtr> Send for Union2<A, B> where
    A: Send,
    B: Send, 

impl<A: ErasablePtr, B: ErasablePtr> Sync for Union2<A, B> where
    A: Sync,
    B: Sync,