Enum reclaim::Marked

pub enum Marked<T: NonNullable> {
    Value(T),
    Null(usize),
}

A value that represents the possible states of a nullable marked pointer.

This type is similar to Option<T> but can also express null pointers with mark bits.

Variants

Value(T)

A marked, non-nullable pointer or reference value.

Null(usize)

A null pointer that may be marked, in which case the usize is non-zero.

Methods

impl<T: NonNullable> Marked<T>

pub fn is_value(&self) -> bool

Returns true if the marked value contains a Value.

pub fn is_null(&self) -> bool

Returns true if the marked value is a Null.

pub fn as_ref(&self) -> Marked<&T>

Converts from Marked<T> to Marked<&T>.

pub fn as_mut(&mut self) -> Marked<&mut T>

Converts from Marked<T> to Marked<&mut T>.

pub fn unwrap_value(self) -> T

Moves the pointer out of the Marked if it is Value(ptr).

pub fn unwrap_null(self) -> usize

Extracts the tag out of the Marked if it is Null(tag).

pub fn unwrap_value_or_else(self, func: impl FnOnce(usize) -> T) -> T

Returns the contained value or the result of the given func.

pub fn map<U: NonNullable>(self, func: impl FnOnce(T) -> U) -> Marked<U>

Maps a Marked<T> to Marked<U> by applying a function to a contained value.

pub fn map_or_else<U: NonNullable>(
    self,
    default: impl FnOnce(usize) -> U,
    func: impl FnOnce(T) -> U
) -> U

Applies a function to the contained value (if any), or computes a default value using func, if no value is contained.

pub fn value(self) -> Option<T>

Converts self from Marked<T> to Option<T>.

pub fn take(&mut self) -> Self

Takes the value of the Marked, leaving a Null variant in its place.

pub fn replace(&mut self, value: T) -> Self

Replaces the actual value in the Marked with the given value, returning the old value.

impl<T: NonNullable + MarkedPointer> Marked<T>

pub fn decompose_tag(&self) -> usize

Decomposes the inner marked pointer, returning only the separated tag.

Trait Implementations

impl<U, T, N: Unsigned> MarkedPointer for Marked<U> where
    U: MarkedPointer<Pointer = U, Item = T, MarkBits = N> + NonNullable<Item = T, MarkBits = N>, 

type Pointer = U

The pointer type.

type Item = T

The pointed-to type.

type MarkBits = N

Number of bits available for tagging.

fn as_marked_ptr(&self) -> MarkedPtr<Self::Item, Self::MarkBits>

Returns the equivalent raw marked pointer.

fn into_marked_ptr(self) -> MarkedPtr<Self::Item, Self::MarkBits>

Consumes self and returns the equivalent raw marked pointer.

fn marked(marked: Self, tag: usize) -> Marked<Self::Pointer>

Consumes the Self and returns the same value with the specified tag wrapped in a Marked.

fn unmarked(marked: Self) -> Self

Consumes the Self and returns the same value but without any tag.

fn decompose(marked: Self) -> (Self, usize)

Decomposes the Self, returning the original value without its previous tag and the separated tag.

unsafe fn from_marked_ptr(marked: MarkedPtr<Self::Item, Self::MarkBits>) -> Self

Constructs a Self from a raw marked pointer.

unsafe fn from_marked_non_null(
    marked: MarkedNonNull<Self::Item, Self::MarkBits>
) -> Self

Constructs a Self from a raw non-null marked pointer

impl<T: NonNullable> From<Option<T>> for Marked<T>

fn from(opt: Option<T>) -> Self

Performs the conversion.

impl<T: PartialEq + NonNullable> PartialEq<Marked<T>> for Marked<T>

fn eq(&self, other: &Marked<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Marked<T>) -> bool

This method tests for !=.

impl<T: Clone + NonNullable> Clone for Marked<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: NonNullable> Default for Marked<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: PartialOrd + NonNullable> PartialOrd<Marked<T>> for Marked<T>

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

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

fn lt(&self, other: &Marked<T>) -> bool

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

fn le(&self, other: &Marked<T>) -> bool

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

fn gt(&self, other: &Marked<T>) -> bool

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

fn ge(&self, other: &Marked<T>) -> bool

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

impl<T: Eq + NonNullable> Eq for Marked<T>

impl<T: Ord + NonNullable> Ord for Marked<T>

fn cmp(&self, other: &Marked<T>) -> 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: Copy + NonNullable> Copy for Marked<T>

impl<T: Debug + NonNullable> Debug for Marked<T>

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

Formats the value using the given formatter.