Struct haphazard::Replaced

source ·
pub struct Replaced<T, F, P> { /* private fields */ }
Expand description

A *mut T that was previously stored in an AtomicPtr.

This type exists primarily to capture the family and pointer type of the AtomicPtr the value was previously stored in, so that callers don’t need to provide F and P to Replaced::retire and Replaced::retire_in.

This type has the same in-memory representation as a std::ptr::NonNull.

Implementations§

source§

impl<T, F, P> Replaced<T, F, P>

source

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

Extract the pointer originally stored in the AtomicPtr.

source§

impl<T, P> Replaced<T, Global, P>
where P: Pointer<T>,

source

pub unsafe fn retire(self) -> usize
where T: Send,

Retire the referenced object, and reclaim it once it is safe to do so.

T must be Send since it may be reclaimed by a different thread.

Safety
  1. The pointed-to object will never again be returned by any AtomicPtr::load.
  2. The pointed-to object has not already been retired.
source§

impl<T, F, P> Replaced<T, F, P>
where P: Pointer<T>,

source

pub unsafe fn retire_in(self, domain: &Domain<F>) -> usize
where T: Send,

Retire the referenced object, and reclaim it once it is safe to do so, through the given domain.

T must be Send since it may be reclaimed by a different thread.

Safety
  1. The pointed-to object will never again be returned by any AtomicPtr::load.
  2. The pointed-to object has not already been retired.
  3. All calls to load that can have seen the pointed-to object were using hazard pointers from domain.

Note that requirement #3 is partially enforced by the domain family (F), but it’s on you to ensure that you don’t “cross the streams” between multiple Domain<F>, if those can arise in your application.

Methods from Deref<Target = NonNull<T>>§

1.25.0 · source

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

Returns a shared reference to the value. If the value may be uninitialized, as_uninit_ref must be used instead.

For the mutable counterpart see as_mut.

Safety

When calling this method, you have to ensure that all of the following is true:

  • The pointer must be properly aligned.

  • It must be “dereferenceable” in the sense defined in the module documentation.

  • The pointer must point to an initialized instance of T.

  • You must enforce Rust’s aliasing rules, since the returned lifetime 'a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, while this reference exists, the memory the pointer points to must not get mutated (except inside UnsafeCell).

This applies even if the result of this method is unused! (The part about being initialized is not yet fully decided, but until it is, the only safe approach is to ensure that they are indeed initialized.)

Examples
use std::ptr::NonNull;

let mut x = 0u32;
let ptr = NonNull::new(&mut x as *mut _).expect("ptr is null!");

let ref_x = unsafe { ptr.as_ref() };
println!("{ref_x}");
1.25.0 · source

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

Returns a unique reference to the value. If the value may be uninitialized, as_uninit_mut must be used instead.

For the shared counterpart see as_ref.

Safety

When calling this method, you have to ensure that all of the following is true:

  • The pointer must be properly aligned.

  • It must be “dereferenceable” in the sense defined in the module documentation.

  • The pointer must point to an initialized instance of T.

  • You must enforce Rust’s aliasing rules, since the returned lifetime 'a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, while this reference exists, the memory the pointer points to must not get accessed (read or written) through any other pointer.

This applies even if the result of this method is unused! (The part about being initialized is not yet fully decided, but until it is, the only safe approach is to ensure that they are indeed initialized.)

Examples
use std::ptr::NonNull;

let mut x = 0u32;
let mut ptr = NonNull::new(&mut x).expect("null pointer");

let x_ref = unsafe { ptr.as_mut() };
assert_eq!(*x_ref, 0);
*x_ref += 2;
assert_eq!(*x_ref, 2);

Trait Implementations§

source§

impl<T, F, P> AsRef<NonNull<T>> for Replaced<T, F, P>

source§

fn as_ref(&self) -> &NonNull<T>

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<T, F, P> Clone for Replaced<T, F, P>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<T, F, P> Debug for Replaced<T, F, P>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T, F, P> Deref for Replaced<T, F, P>

§

type Target = NonNull<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

impl<T, F, P> DerefMut for Replaced<T, F, P>

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<T, F, P> Copy for Replaced<T, F, P>

Auto Trait Implementations§

§

impl<T, F, P> RefUnwindSafe for Replaced<T, F, P>

§

impl<T, F, P> !Send for Replaced<T, F, P>

§

impl<T, F, P> !Sync for Replaced<T, F, P>

§

impl<T, F, P> Unpin for Replaced<T, F, P>
where F: Unpin, P: Unpin,

§

impl<T, F, P> UnwindSafe for Replaced<T, F, P>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> Reclaim for T