Struct nolock::hazard_ptr::Guard

pub struct Guard<T> { /* private fields */ }

A Guard protects a single Memory address and provides secure access to it, as long as the Guard is not dropped

Implementations

impl<T> Guard<T>

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

Gets the underlying PTR to the Data protected by the Guard

pub fn protect(&mut self, atom_ptr: &AtomicPtr<T>, load_order: Ordering)

Loads the most recent Ptr-Value from the given AtomicPtr and updates the current Guard to now protect this new Ptr.

Usage

This should be used when you already have Guard, but no longer need the original Guard/Value and now need to protect another new Memory- Location, as this method reuses an already owned Hazard-Pointer/Guard and therefore does not need to acquire a Hazard-Pointer beforehand.

This is especially useful when iterating a Datastruture, as you often only have one Node you are currently processing and then move on to another one.

pub unsafe fn convert<O>(self) -> Guard<O>

Converts the Guard into a Guard for a differnt underlying Type

Safety

You must make sure that the underlying Ptr is valid for the Type O

Trait Implementations

impl<T> Debug for Guard<T>

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

Formats the value using the given formatter.

impl<T> Deref for Guard<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Drop for Guard<T>

fn drop(&mut self)

Executes the destructor for this type.