Struct sdd::Ptr

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

Ptr points to an instance.

Implementations

impl<'g, T> Ptr<'g, T>

pub const fn null() -> Self

Creates a null Ptr.

Examples

use sdd::Ptr;

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

pub fn is_null(&self) -> bool

Returns true if the Ptr is null.

Examples

use sdd::Ptr;

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

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

Tries to create a reference to the underlying instance.

Examples

use sdd::{AtomicShared, Guard};
use std::sync::atomic::Ordering::Relaxed;

let atomic_shared: AtomicShared<usize> = AtomicShared::new(21);
let guard = Guard::new();
let ptr = atomic_shared.load(Relaxed, &guard);
assert_eq!(*ptr.as_ref().unwrap(), 21);

pub fn as_ptr(&self) -> *const T

Provides a raw pointer to the instance.

Examples

use sdd::{Guard, Shared};
use std::sync::atomic::Ordering::Relaxed;

let shared: Shared<usize> = Shared::new(29);
let guard = Guard::new();
let ptr = shared.get_guarded_ptr(&guard);
drop(shared);

assert_eq!(unsafe { *ptr.as_ptr() }, 29);

pub fn tag(&self) -> Tag

Returns its Tag.

Examples

use sdd::{Ptr, Tag};

let ptr: Ptr<usize> = Ptr::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::{Ptr, Tag};

let mut ptr: Ptr<usize> = Ptr::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::{Ptr, Tag};

let mut ptr: Ptr<usize> = Ptr::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::{Ptr, Tag};

let mut ptr: Ptr<usize> = Ptr::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, Tag};

let mut ptr: Ptr<usize> = Ptr::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 fn get_shared(self) -> Option<Shared<T>>

Tries to convert itself into a Shared.

Examples

use sdd::{Guard, Shared};

let shared: Shared<usize> = Shared::new(83);
let guard = Guard::new();
let ptr = shared.get_guarded_ptr(&guard);
let shared_restored = ptr.get_shared().unwrap();
assert_eq!(*shared_restored, 83);

drop(shared);
drop(shared_restored);

assert!(ptr.get_shared().is_none());

Trait Implementations

impl<'g, T> Clone for Ptr<'g, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<'g, T> Default for Ptr<'g, T>

fn default() -> Self

Returns the “default value” for a type.

impl<'g, T> PartialEq for Ptr<'g, T>

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<'g, T> TryFrom<Ptr<'g, T>> for Shared<T>

type Error = Ptr<'g, T>

The type returned in the event of a conversion error.

fn try_from(ptr: Ptr<'g, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'g, T> Copy for Ptr<'g, T>

impl<'g, T> Eq for Ptr<'g, T>

impl<'g, T: UnwindSafe> UnwindSafe for Ptr<'g, T>