#[repr(transparent)]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
sourceimpl<T, F, P> Replaced<T, F, P>
impl<T, F, P> Replaced<T, F, P>
sourcepub fn into_inner(self) -> NonNull<T>
pub fn into_inner(self) -> NonNull<T>
Extract the pointer originally stored in the AtomicPtr
.
sourceimpl<T, P> Replaced<T, Global, P> where
P: Pointer<T>,
impl<T, P> Replaced<T, Global, P> where
P: Pointer<T>,
sourcepub unsafe fn retire(self) -> usize
pub unsafe fn retire(self) -> usize
Retire the referenced object, and reclaim it once it is safe to do so.
Safety
- The pointed-to object will never again be returned by any
AtomicPtr::load
. - The pointed-to object has not already been retired.
sourceimpl<T, F, P> Replaced<T, F, P> where
P: Pointer<T>,
impl<T, F, P> Replaced<T, F, P> where
P: Pointer<T>,
sourcepub unsafe fn retire_in(self, domain: &Domain<F>) -> usize
pub unsafe fn retire_in(self, domain: &Domain<F>) -> usize
Retire the referenced object, and reclaim it once it is safe to do so, through the given
domain
.
Safety
- The pointed-to object will never again be returned by any
AtomicPtr::load
. - The pointed-to object has not already been retired.
- All calls to
load
that can have seen the pointed-to object were using hazard pointers fromdomain
.
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>>
sourcepub unsafe fn as_uninit_ref<'a>(&self) -> &'a MaybeUninit<T>
🔬 This is a nightly-only experimental API. (ptr_as_uninit
)
pub unsafe fn as_uninit_ref<'a>(&self) -> &'a MaybeUninit<T>
ptr_as_uninit
)Returns a shared references to the value. In contrast to as_ref
, this does not require
that the value has to be initialized.
For the mutable counterpart see as_uninit_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.
-
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, for the duration of this lifetime, the memory the pointer points to must not get mutated (except insideUnsafeCell
).
This applies even if the result of this method is unused!
sourcepub unsafe fn as_uninit_mut<'a>(&mut self) -> &'a mut MaybeUninit<T>
🔬 This is a nightly-only experimental API. (ptr_as_uninit
)
pub unsafe fn as_uninit_mut<'a>(&mut self) -> &'a mut MaybeUninit<T>
ptr_as_uninit
)Returns a unique references to the value. In contrast to as_mut
, this does not require
that the value has to be initialized.
For the shared counterpart see as_uninit_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.
-
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, for the duration of this lifetime, 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!
1.25.0 · sourcepub unsafe fn as_ref<'a>(&self) -> &'a T
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, for the duration of this lifetime, the memory the pointer points to must not get mutated (except insideUnsafeCell
).
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 · sourcepub unsafe fn as_mut<'a>(&mut self) -> &'a mut T
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, for the duration of this lifetime, 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);
sourcepub unsafe fn as_uninit_slice<'a>(&self) -> &'a [MaybeUninit<T>]
🔬 This is a nightly-only experimental API. (ptr_as_uninit
)
pub unsafe fn as_uninit_slice<'a>(&self) -> &'a [MaybeUninit<T>]
ptr_as_uninit
)Returns a shared reference to a slice of possibly uninitialized values. In contrast to
as_ref
, this does not require that the value has to be initialized.
For the mutable counterpart see as_uninit_slice_mut
.
Safety
When calling this method, you have to ensure that all of the following is true:
-
The pointer must be valid for reads for
ptr.len() * mem::size_of::<T>()
many bytes, and it must be properly aligned. This means in particular:-
The entire memory range of this slice must be contained within a single allocated object! Slices can never span across multiple allocated objects.
-
The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as
data
for zero-length slices usingNonNull::dangling()
.
-
-
The total size
ptr.len() * mem::size_of::<T>()
of the slice must be no larger thanisize::MAX
. See the safety documentation ofpointer::offset
. -
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, for the duration of this lifetime, the memory the pointer points to must not get mutated (except insideUnsafeCell
).
This applies even if the result of this method is unused!
See also slice::from_raw_parts
.
sourcepub unsafe fn as_uninit_slice_mut<'a>(&self) -> &'a mut [MaybeUninit<T>]
🔬 This is a nightly-only experimental API. (ptr_as_uninit
)
pub unsafe fn as_uninit_slice_mut<'a>(&self) -> &'a mut [MaybeUninit<T>]
ptr_as_uninit
)Returns a unique reference to a slice of possibly uninitialized values. In contrast to
as_mut
, this does not require that the value has to be initialized.
For the shared counterpart see as_uninit_slice
.
Safety
When calling this method, you have to ensure that all of the following is true:
-
The pointer must be valid for reads and writes for
ptr.len() * mem::size_of::<T>()
many bytes, and it must be properly aligned. This means in particular:-
The entire memory range of this slice must be contained within a single allocated object! Slices can never span across multiple allocated objects.
-
The pointer must be aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as
data
for zero-length slices usingNonNull::dangling()
.
-
-
The total size
ptr.len() * mem::size_of::<T>()
of the slice must be no larger thanisize::MAX
. See the safety documentation ofpointer::offset
. -
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, for the duration of this lifetime, 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!
See also slice::from_raw_parts_mut
.
Examples
#![feature(allocator_api, ptr_as_uninit)]
use std::alloc::{Allocator, Layout, Global};
use std::mem::MaybeUninit;
use std::ptr::NonNull;
let memory: NonNull<[u8]> = Global.allocate(Layout::new::<[u8; 32]>())?;
// This is safe as `memory` is valid for reads and writes for `memory.len()` many bytes.
// Note that calling `memory.as_mut()` is not allowed here as the content may be uninitialized.
let slice: &mut [MaybeUninit<u8>] = unsafe { memory.as_uninit_slice_mut() };
Trait Implementations
impl<T, F, P> Copy for Replaced<T, F, P>
Auto Trait Implementations
impl<T, F, P> RefUnwindSafe for Replaced<T, F, P> where
F: RefUnwindSafe,
P: RefUnwindSafe,
T: RefUnwindSafe,
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> where
F: UnwindSafe,
P: UnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more