Struct rustc_data_structures::tagged_ptr::copy::CopyTaggedPtr

pub struct CopyTaggedPtr<P, T, const COMPARE_PACKED: bool> where
    P: Pointer,
    T: Tag,  {
    packed: NonZeroUsize,
    data: PhantomData<(P, T)>,
}

A Copy TaggedPtr.

You should use this instead of the TaggedPtr type in all cases where P: Copy.

If COMPARE_PACKED is true, then the pointers will be compared and hashed without unpacking. Otherwise we don’t implement PartialEq/Eq/Hash; if you want that, wrap the TaggedPtr.

Fields

packed: NonZeroUsize

data: PhantomData<(P, T)>

Implementations

impl<P, T, const COMPARE_PACKED: bool> CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer,
    T: Tag, 

const TAG_BIT_SHIFT: usize = usize::BITS as usize - T::BITS

const ASSERTION: () = { assert!(T::BITS <= P::BITS); // Used for the transmute_copy's below assert!(std::mem::size_of::<&P::Target>() == std::mem::size_of::()); }

pub fn new(pointer: P, tag: T) -> Self

pub(super) fn pointer_raw(&self) -> usize

pub fn pointer(self) -> P where
    P: Copy, 

pub fn pointer_ref(&self) -> &P::Target

pub fn pointer_mut(&mut self) -> &mut P::Target where
    P: DerefMut, 

pub fn tag(&self) -> T

pub fn set_tag(&mut self, tag: T)

Trait Implementations

impl<P, T, const COMPARE_PACKED: bool> Clone for CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer,
    T: Tag,
    P: Copy, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, T, const COMPARE_PACKED: bool> Debug for CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer,
    P::Target: Debug,
    T: Tag + Debug, 

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

Formats the value using the given formatter.

impl<P, T, const COMPARE_PACKED: bool> Deref for CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer,
    T: Tag, 

type Target = <P as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<P, T, const COMPARE_PACKED: bool> DerefMut for CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer + DerefMut,
    T: Tag, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<P, T> Hash for CopyTaggedPtr<P, T, true> where
    P: Pointer,
    T: Tag, 

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, 

Feeds a slice of this type into the given Hasher.

impl<P, T, HCX, const COMPARE_PACKED: bool> HashStable<HCX> for CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer + HashStable<HCX>,
    T: Tag + HashStable<HCX>, 

fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher)

impl<P, T> PartialEq<CopyTaggedPtr<P, T, true>> for CopyTaggedPtr<P, T, true> where
    P: Pointer,
    T: Tag, 

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 !=.

impl<P, T, const COMPARE_PACKED: bool> Copy for CopyTaggedPtr<P, T, COMPARE_PACKED> where
    P: Pointer,
    T: Tag,
    P: Copy, 

impl<P, T> Eq for CopyTaggedPtr<P, T, true> where
    P: Pointer,
    T: Tag, 

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes