Struct reclaim::MarkedNonNull

pub struct MarkedNonNull<T, N> { /* fields omitted */ }

A non-nullable marked raw pointer type like NonNull.

Note, that unlike MarkedPtr this also excludes marked null-pointers.

Methods

impl<T, N> MarkedNonNull<T, N>

pub const fn cast<U>(self) -> MarkedNonNull<U, N>

Cast to a pointer of another type.

pub const fn dangling() -> Self

Creates a new MarkedNonNull that is dangling, but well-aligned.

This is useful for initializing types which lazily allocate, like Vec::new does.

Note that the pointer value may potentially represent a valid pointer to a T, which means this must not be used as a "not yet initialized" sentinel value. Types that lazily allocate must track initialization by some other means.

impl<T, N: Unsigned> MarkedNonNull<T, N>

pub const MARK_BITS: usize

The number of available mark bits for this type.

pub const MARK_MASK: usize

The bitmask for the lower markable bits.

pub const POINTER_MASK: usize

The bitmask for the (higher) pointer bits.

pub fn into_non_null(self) -> NonNull<T>

Returns the inner pointer as is, meaning potential tags are not stripped.

pub fn convert<M: Unsigned>(other: MarkedNonNull<T, M>) -> Self where
    N: IsGreaterOrEqual<M, Output = True>, 

Converts a marked non-null pointer with M potential mark bits to the same marked pointer with N potential mark bits, requires that N >= M.

pub unsafe fn new_unchecked(ptr: MarkedPtr<T, N>) -> Self

Creates a new MarkedNonNull from a marked pointer without checking for null.

Safety

ptr may be marked, but must be be neither an unmarked nor a marked null pointer.

pub fn new(ptr: MarkedPtr<T, N>) -> Marked<Self>

Creates a new MarkedNonNull wrapped in a Marked if ptr is non-null.

pub fn clear_tag(self) -> Self

Clears the tag of self and returns the same but untagged pointer.

pub fn with_tag(self, tag: usize) -> Self

Clears the tag of self and replaces it with tag.

pub fn into_marked_ptr(self) -> MarkedPtr<T, N>

Converts the pointer to the equivalent MarkedPtr.

pub fn compose(ptr: NonNull<T>, tag: usize) -> Self

Composes a new marked non-null pointer from a non-null pointer and a tag value.

pub fn decompose(self) -> (NonNull<T>, usize)

Decomposes the marked pointer, returning the separated raw NonNull pointer and its tag.

pub fn decompose_ptr(self) -> *mut T

Decomposes the marked pointer, returning only the separated raw pointer.

pub fn decompose_non_null(self) -> NonNull<T>

Decomposes the marked pointer, returning only the separated raw NonNull pointer.

pub fn decompose_tag(self) -> usize

Decomposes the marked pointer, returning only the separated tag.

pub unsafe fn decompose_ref(&self) -> (&T, usize)

Decomposes the marked pointer, dereferences the the raw pointer and returns both the reference and the separated tag.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use e.g. &*my_ptr.decompose_ptr().

Safety

This is unsafe because it cannot verify the validity of the returned pointer.

pub unsafe fn decompose_ref_unbounded<'a>(self) -> (&'a T, usize)

Decomposes the marked pointer, dereferences the the raw pointer and returns both the reference and the separated tag. The returned reference is not bound to the lifetime of the MarkedNonNull.

Safety

This is unsafe because it cannot verify the validity of the returned pointer, nor can it ensure that the lifetime 'a returned is indeed a valid lifetime for the contained data.

pub unsafe fn decompose_mut(&mut self) -> (&mut T, usize)

Decomposes the marked pointer, mutably dereferences the the raw pointer and returns both the mutable reference and the separated tag.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use e.g. &mut *my_ptr.decompose_ptr().

Safety

This is unsafe because it cannot verify the validity of the returned pointer.

pub unsafe fn decompose_mut_unbounded<'a>(&mut self) -> (&'a mut T, usize)

Decomposes the marked pointer, mutably dereferences the the raw pointer and returns both the mutable reference and the separated tag. The returned reference is not bound to the lifetime of the MarkedNonNull.

Safety

This is unsafe because it cannot verify the validity of the returned pointer, nor can it ensure that the lifetime 'a returned is indeed a valid lifetime for the contained data.

pub unsafe fn as_ref(&self) -> &T

Decomposes the marked pointer, returning only the de-referenced raw pointer.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use e.g. &*my_ptr.decompose_ptr() or as_ref_unbounded.

Safety

This is unsafe because it cannot verify the validity of the returned pointer.

pub unsafe fn as_ref_unbounded<'a>(self) -> &'a T

Decomposes the marked pointer, returning only the de-referenced raw pointer, which is not bound to the lifetime of the MarkedNonNull.

Safety

This is unsafe because it cannot verify the validity of the returned pointer, nor can it ensure that the lifetime 'a returned is indeed a valid lifetime for the contained data.

pub unsafe fn as_mut(&mut self) -> &mut T

Decomposes the marked pointer, returning only the mutably de-referenced raw pointer.

The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use e.g. &mut *my_ptr.decompose_ptr() or as_mut_unbounded.

Safety

This is unsafe because it cannot verify the validity of the returned pointer.

pub unsafe fn as_mut_unbounded<'a>(self) -> &'a mut T

Decomposes the marked pointer, returning only the mutably de-referenced raw pointer, which is not bound to the lifetime of the MarkedNonNull.

Safety

This is unsafe because it cannot verify the validity of the returned pointer, nor can it ensure that the lifetime 'a returned is indeed a valid lifetime for the contained data.

Trait Implementations

impl<T, N: Unsigned> NonNullable for MarkedNonNull<T, N>

type Item = T

The pointed-to type.

type MarkBits = N

Number of bits available for tagging.

fn into_marked_non_null(self) -> MarkedNonNull<Self::Item, Self::MarkBits>

Converts the given Self into a equivalent marked non-null pointer.

impl<T, N> From<NonNull<T>> for MarkedNonNull<T, N>

fn from(ptr: NonNull<T>) -> Self

Performs the conversion.

impl<'a, T, N: Unsigned> From<&'a T> for MarkedNonNull<T, N>

fn from(reference: &'a T) -> Self

Performs the conversion.

impl<'a, T, N: Unsigned> From<&'a mut T> for MarkedNonNull<T, N>

fn from(reference: &'a mut T) -> Self

Performs the conversion.

impl<T, N> PartialEq<MarkedNonNull<T, N>> for MarkedNonNull<T, N>

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<T, N> PartialEq<MarkedPtr<T, N>> for MarkedNonNull<T, N>

fn eq(&self, other: &MarkedPtr<T, N>) -> 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<T, N> PartialEq<MarkedNonNull<T, N>> for MarkedPtr<T, N>

fn eq(&self, other: &MarkedNonNull<T, N>) -> 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<T, N> Clone for MarkedNonNull<T, N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, N> PartialOrd<MarkedNonNull<T, N>> for MarkedNonNull<T, N>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, N> PartialOrd<MarkedPtr<T, N>> for MarkedNonNull<T, N>

fn partial_cmp(&self, other: &MarkedPtr<T, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, N> PartialOrd<MarkedNonNull<T, N>> for MarkedPtr<T, N>

fn partial_cmp(&self, other: &MarkedNonNull<T, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, N> Eq for MarkedNonNull<T, N>

impl<T, N> Ord for MarkedNonNull<T, N>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T, N> Copy for MarkedNonNull<T, N>

impl<T, N: Unsigned> Debug for MarkedNonNull<T, N>

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

Formats the value using the given formatter.

impl<T, N: Unsigned> TryFrom<MarkedPtr<T, N>> for MarkedNonNull<T, N>

type Error = InvalidNullError

The type returned in the event of a conversion error.

fn try_from(ptr: MarkedPtr<T, N>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, N: Unsigned> Pointer for MarkedNonNull<T, N>

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

Formats the value using the given formatter.