Struct ptr_union::Union4

pub struct Union4<A, B, C, D = NeverPtr> { /* fields omitted */ }

A pointer union of three or four pointer types.

This is a tagged union of two pointer types such as Box<T>, Arc<T>, or &T that is only as big as a 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 u32 (#[repr(align(4))]). This is enforced through the use of UnionBuilder.

The last type may be omitted for a three pointer union. Just specify a Union4<A, B, C> instead of Union4<A, B, C, D>. The used NeverPtr type will be changed to ! once it stabilizes. This will not be considered a breaking change.

Methods

impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr> Union4<A, B, C, D>

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 is_c(&self) -> bool

Check if the union is this variant.

pub fn into_c(self) -> Result<C, Self>

Extract this variant from the union.

Returns the union on error.

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

Run a closure with this variant.

pub fn c(&self) -> Option<&C::Target> where
    C: Deref, 

Get a reference to this variant's target.

pub fn clone_c(&self) -> Option<C> where
    C: Clone, 

Clone this variant out of the union.

pub fn copy_c(&self) -> Option<C> where
    C: Copy, 

Copy this variant out of the union.

pub fn is_d(&self) -> bool

Check if the union is this variant.

pub fn into_d(self) -> Result<D, Self>

Extract this variant from the union.

Returns the union on error.

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

Run a closure with this variant.

pub fn d(&self) -> Option<&D::Target> where
    D: Deref, 

Get a reference to this variant's target.

pub fn clone_d(&self) -> Option<D> where
    D: Clone, 

Clone this variant out of the union.

pub fn copy_d(&self) -> Option<D> where
    D: 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,
    proof: UnionBuilder<Union4<&'a A::Target, &'a B::Target, &'a C::Target, &'a D::Target>>
) -> Union4<&'a A::Target, &'a B::Target, &'a C::Target, &'a D::Target> where
    A: Deref,
    B: Deref,
    C: Deref,
    D: Deref,
    &'a A::Target: ErasablePtr,
    &'a B::Target: ErasablePtr,
    &'a C::Target: ErasablePtr,
    &'a D::Target: ErasablePtr, 

Dereference the current pointer.

impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr> Union4<A, B, C, D>

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

Dereference the current pointer.

Safety

The reference produced by dereferencing must align to at least u32 (4 bytes).

pub fn unpack(self) -> Enum4<A, B, C, D>

Unpack this union into an enum.

Trait Implementations

impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr> Clone for Union4<A, B, C, D> where
    A: Clone,
    B: Clone,
    C: Clone,
    D: 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, C: ErasablePtr, D: ErasablePtr> Copy for Union4<A, B, C, D> where
    A: Copy,
    B: Copy,
    C: Copy,
    D: Copy, 

impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr> Debug for Union4<A, B, C, D> where
    A: Debug,
    B: Debug,
    C: Debug,
    D: Debug, 

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

Formats the value using the given formatter.

impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr> Eq for Union4<A, B, C, D> where
    A: Eq,
    B: Eq,
    C: Eq,
    D: Eq, 

impl<A: ErasablePtr, B: ErasablePtr, C: ErasablePtr, D: ErasablePtr> Hash for Union4<A, B, C, D> where
    A: Hash,
    B: Hash,
    C: Hash,
    D: 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, C: ErasablePtr, D: ErasablePtr> PartialEq<Union4<A, B, C, D>> for Union4<A, B, C, D> where
    A: PartialEq,
    B: PartialEq,
    C: PartialEq,
    D: 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 !=.