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

const ASSERTION: ()

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

#[must_use]

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,