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 tagged pointer that supports pointers that implement Drop.

This is essentially { pointer: P, tag: T } packed in a single pointer.

You should use CopyTaggedPtr instead of the this type in all cases where P implements Copy.

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

Fields

raw: CopyTaggedPtr<P, T, COMPARE_PACKED>

Implementations

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

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

Tags pointer with tag.

pub fn tag(&self) -> T

Retrieves the tag.

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

Sets the tag to a new value.

Trait Implementations

impl<P, T, const CP: bool> Clone for TaggedPtr<P, T, CP>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 CP: bool> Debug for TaggedPtr<P, T, CP>where P: Pointer + Debug, T: Tag + Debug,

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

Formats the value using the given formatter.

impl<P, T, const CP: bool> Deref for TaggedPtr<P, T, CP>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 CP: bool> DerefMut for TaggedPtr<P, T, CP>where P: Pointer + DerefMut, T: Tag,

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

Mutably dereferences the value.

impl<P, T, const CP: bool> Drop for TaggedPtr<P, T, CP>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 CP: bool> HashStable<HCX> for TaggedPtr<P, T, CP>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: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.