Struct Union2

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

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 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 unpack(self) -> Enum2<A, B>

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

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

pub fn try_deref<'a>(&'a self) -> Option<Union2<&'a A::Target, &'a B::Target>>

where A: Deref, B: Deref, &'a A::Target: ErasablePtr, &'a B::Target: ErasablePtr,

Dereference the current pointer.

Performs a dynamic alignment check on the dereferenced pointer.

Trait Implementations

impl<A, B> Clone for Union2<A, B>

where A: Clone + ErasablePtr, B: Clone + ErasablePtr,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, B> Debug for Union2<A, B>

where A: Debug + ErasablePtr, B: Debug + ErasablePtr,

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> 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, B> Hash for Union2<A, B>

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

where A: PartialEq + ErasablePtr, B: PartialEq + ErasablePtr,

fn eq(&self, other: &Self) -> 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<A, B> Eq for Union2<A, B>

where A: Eq + ErasablePtr, B: Eq + ErasablePtr,

impl<A, B> Send for Union2<A, B>

where A: Send + ErasablePtr, B: Send + ErasablePtr,

impl<A, B> Sync for Union2<A, B>

where A: Sync + ErasablePtr, B: Sync + ErasablePtr,