Struct TaggedPointer 

#[repr(transparent)]
pub struct TaggedPointer<T: ?Sized> {
    pub raw: *mut T,
}

Structure wrapping a raw, tagged pointer.

Fields

raw: *mut T

Implementations

impl<T> TaggedPointer<T>

pub fn new(raw: *mut T) -> TaggedPointer<T>

Returns a new TaggedPointer without setting any bits.

pub fn with_bit(raw: *mut T, bit: usize) -> TaggedPointer<T>

Returns a new TaggedPointer with the given bit set.

pub fn unset_bit(&mut self, bit: usize)

pub const fn null() -> TaggedPointer<T>

Returns a null pointer.

pub fn untagged(self) -> *mut T

Returns the wrapped pointer without any tags.

pub fn without_tags(self) -> Self

Returns a new TaggedPointer using the current pointer but without any tags.

pub fn bit_is_set(self, bit: usize) -> bool

Returns true if the given bit is set.

pub fn set_bit(&mut self, bit: usize)

Sets the given bit.

pub fn is_null(self) -> bool

Returns true if the current pointer is a null pointer.

pub fn as_ref<'a>(self) -> Option<&'a T>

Returns an immutable to the pointer’s value.

pub fn as_mut<'a>(self) -> Option<&'a mut T>

Returns a mutable reference to the pointer’s value.

pub fn compare_and_swap(&self, current: *mut T, other: *mut T) -> bool

Atomically swaps the internal pointer with another one.

This boolean returns true if the pointer was swapped, false otherwise.

pub fn atomic_store(&self, other: *mut T)

Atomically replaces the current pointer with the given one.

pub fn atomic_load(&self) -> *mut T

Atomically loads the pointer.

pub fn atomic_bit_is_set(&self, bit: usize) -> bool

Checks if a bit is set using an atomic load.

Trait Implementations

impl<T> Clone for TaggedPointer<T>

fn clone(&self) -> TaggedPointer<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for TaggedPointer<T>

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

Formats the value using the given formatter.

impl<T> Hash for TaggedPointer<T>

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<T> PartialEq for TaggedPointer<T>

fn eq(&self, other: &TaggedPointer<T>) -> 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<T> Copy for TaggedPointer<T>

impl<T> Eq for TaggedPointer<T>