Struct safer_ffi::ptr::NonNullMut

#[repr(transparent)]
pub struct NonNullMut<T>(pub NonNull<T>, pub PhantomInvariant<T>);

Tuple Fields

0: NonNull<T>

1: PhantomInvariant<T>

Implementations

impl<T> NonNullMut<T>

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

pub fn cast<U>(self: NonNullMut<T>) -> NonNullMut<U>

impl<T> NonNullMut<T>

pub fn as_mut_ptr(&mut self) -> *mut T

pub fn copy(self: &mut NonNullMut<T>) -> NonNullMut<T>

Methods from Deref<Target = NonNull<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, 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}");

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

impl<T> Debug for NonNullMut<T>

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

Formats the value using the given formatter.

impl<T> Deref for NonNullMut<T>

type Target = NonNull<T>

The resulting type after dereferencing.

fn deref(self: &NonNullMut<T>) -> &NonNull<T>

Dereferences the value.

impl<T> DerefMut for NonNullMut<T>

fn deref_mut(self: &mut NonNullMut<T>) -> &mut NonNull<T>

Mutably dereferences the value.

impl<'lt, T: 'lt> From<&'lt mut T> for NonNullMut<T>

fn from(it: &'lt mut T) -> NonNullMut<T>

Converts to this type from the input type.

impl<T> From<NonNull<T>> for NonNullMut<T>

fn from(it: NonNull<T>) -> Self

Converts to this type from the input type.

impl<T: ReprC> ReprC for NonNullMut<T>

type CLayout = *mut <T as ReprC>::CLayout

The CType having the same layout as Self.

fn is_valid(it: &*mut T::CLayout) -> bool

Sanity checks that can be performed on an instance of the CType layout.