Struct ptr_union::Union4

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

A pointer union of four pointer types.

This is a tagged union of four 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 u32 (align(4)). This is enforced through the use of Builder4.

The fourth pointer type may be omitted to create a three pointer union. The default type, NeverPtr, will be an alias for ! once it is stable. This will not be considered a breaking change.

Implementations

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

pub fn new_a(a: A) -> Result<Self, A>

Construct a varaint of this union with a dynamic alignment check.

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 new_b(b: B) -> Result<Self, B>

Construct a varaint of this union with a dynamic alignment check.

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 new_c(c: C) -> Result<Self, C>

Construct a varaint of this union with a dynamic alignment check.

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 new_d(d: D) -> Result<Self, D>

Construct a varaint of this union with a dynamic alignment check.

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 unpack(self) -> Enum4<A, B, C, D>

Unpack this union into an enum.

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: Builder4<&'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.

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 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 as_untagged_ptr(&self) -> ErasedPtr

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

pub fn try_deref<'a>(
    &'a self
) -> Option<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.

Performs a dynamic alignment check on the dereferenced pointer.

Trait Implementations

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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

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, B, C, D> Hash for Union4<A, B, C, D>where
    A: Hash + ErasablePtr,
    B: Hash + ErasablePtr,
    C: Hash + ErasablePtr,
    D: Hash + ErasablePtr,

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

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<A, B, C, D> PartialEq<Union4<A, B, C, D>> for Union4<A, B, C, D>where
    A: PartialEq + ErasablePtr,
    B: PartialEq + ErasablePtr,
    C: PartialEq + ErasablePtr,
    D: PartialEq + ErasablePtr,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

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