Struct rustc_data_structures::tagged_ptr::TaggedPtr

pub struct TaggedPtr<P, T, const COMPARE_PACKED: bool>where
    P: Pointer,
    T: Tag,{
    raw: CopyTaggedPtr<P, T, COMPARE_PACKED>,
}

A TaggedPtr implementing Drop.

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

raw: CopyTaggedPtr<P, T, COMPARE_PACKED>

Implementations

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

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

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

pub fn tag(&self) -> T

Trait Implementations

impl<P, T, const COMPARE_PACKED: bool> Clone for TaggedPtr<P, T, COMPARE_PACKED>where
    P: Pointer + Clone,
    T: Tag,

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 TaggedPtr<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 TaggedPtr<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 TaggedPtr<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, const COMPARE_PACKED: bool> Drop for TaggedPtr<P, T, COMPARE_PACKED>where
    P: Pointer,
    T: Tag,

fn drop(&mut self)

Executes the destructor for this type.

impl<P, T> Hash for TaggedPtr<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,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P, T, HCX, const COMPARE_PACKED: bool> HashStable<HCX> for TaggedPtr<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<TaggedPtr<P, T, true>> for TaggedPtr<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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, T> Eq for TaggedPtr<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