Struct RawPtr 

pub struct RawPtr<'g, T> { /* private fields */ }

RawPtr is a raw pointer where the lifetime of the pointed-to instance is not managed.

RawPtr cannot dereference the pointed-to instance unless it is converted into Ptr through RawPtr::into_ptr.

Implementations

impl<'g, T> RawPtr<'g, T>

pub const fn null() -> Self

Creates a null RawPtr.

Examples

use sdd::RawPtr;

let ptr: RawPtr<usize> = RawPtr::null();

pub fn is_null(&self) -> bool

Returns true if the RawPtr is null.

Examples

use sdd::RawPtr;

let ptr: RawPtr<usize> = RawPtr::null();
assert!(ptr.is_null());

pub fn tag(&self) -> Tag

Returns its Tag.

Examples

use sdd::{RawPtr, Tag};

let ptr: RawPtr<usize> = RawPtr::null();
assert_eq!(ptr.tag(), Tag::None);

pub fn set_tag(&mut self, tag: Tag) -> Tag

Sets a Tag, overwriting its existing Tag.

Returns the previous tag value.

Examples

use sdd::{RawPtr, Tag};

let mut ptr: RawPtr<usize> = RawPtr::null();
assert_eq!(ptr.set_tag(Tag::Both), Tag::None);
assert_eq!(ptr.tag(), Tag::Both);

pub fn unset_tag(&mut self) -> Tag

Clears its Tag.

Returns the previous tag value.

Examples

use sdd::{RawPtr, Tag};

let mut ptr: RawPtr<usize> = RawPtr::null().with_tag(Tag::Both);
assert_eq!(ptr.unset_tag(), Tag::Both);

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

Returns a copy of self with a Tag set.

Examples

use sdd::{RawPtr, Tag};

let mut ptr: RawPtr<usize> = RawPtr::null();
assert_eq!(ptr.tag(), Tag::None);

let ptr_with_tag = ptr.with_tag(Tag::First);
assert_eq!(ptr_with_tag.tag(), Tag::First);

pub fn without_tag(self) -> Self

Returns a copy of self with its Tag erased.

Examples

use sdd::{Ptr, RawPtr, Tag};

let mut ptr: RawPtr<usize> = RawPtr::null();
ptr.set_tag(Tag::Second);
assert_eq!(ptr.tag(), Tag::Second);

let ptr_without_tag = ptr.without_tag();
assert_eq!(ptr_without_tag.tag(), Tag::None);

pub const unsafe fn into_ptr(self) -> Ptr<'g, T>

Converts itself into a Ptr to dereference the instance.

Safety

The pointed-to instance must be valid for the lifetime 'g.

Examples

use sdd::Owned;

let owned: Owned<usize> = Owned::new(83);
let ptr = owned.into_raw();
assert_eq!(unsafe { ptr.into_ptr().as_ref() }, Some(&83));
drop(unsafe { Owned::from_raw(ptr) });

Trait Implementations

impl<T> Clone for RawPtr<'_, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'g, T: Debug> Debug for RawPtr<'g, T>

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

Formats the value using the given formatter.

impl<T> Default for RawPtr<'_, T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> PartialEq for RawPtr<'_, T>

fn eq(&self, other: &Self) -> 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 RawPtr<'_, T>

impl<T> Eq for RawPtr<'_, T>

impl<T: UnwindSafe> UnwindSafe for RawPtr<'_, T>