Struct NonNullMut 

pub struct NonNullMut<T: ?Sized> { /* private fields */ }

NonNull<T>, but T is invariant like *mut T

Like NonNull<T>, but T is invariant like *mut T

Examples

use nonnull_mut::NonNullMut;

assert_eq!(size_of::<NonNullMut<i16>>(), size_of::<Option<NonNullMut<i16>>>());
assert_eq!(align_of::<NonNullMut<i16>>(), align_of::<Option<NonNullMut<i16>>>());

assert_eq!(size_of::<NonNullMut<str>>(), size_of::<Option<NonNullMut<str>>>());
assert_eq!(align_of::<NonNullMut<str>>(), align_of::<Option<NonNullMut<str>>>());

Implementations

impl<T> NonNullMut<T>

pub const fn dangling() -> Self

Like NonNull::dangling

Examples

use nonnull_mut::NonNullMut;

let ptr = NonNullMut::<u32>::dangling();
// Important: don't try to access the value of `ptr` without
// initializing it first! The pointer is not null but isn't valid either!

impl<T: ?Sized> NonNullMut<T>

pub const fn new(ptr: *mut T) -> Option<Self>

Like NonNull::new

Examples

use nonnull_mut::NonNullMut;

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

if let Some(ptr) = NonNullMut::<u32>::new(std::ptr::null_mut()) {
    unreachable!();
}

pub const unsafe fn new_unchecked(ptr: *mut T) -> Self

Like NonNull::new_unchecked

Safety

See NonNull::new_unchecked for safety concerns and examples.

pub const fn from_inner(inner: NonNull<T>) -> Self

Create NonNullMut<T> from NonNull<T>

pub fn addr(self) -> NonZeroUsize

Like NonNull::addr

pub fn with_addr(self, addr: NonZeroUsize) -> Self

Like NonNull::with_addr

pub fn map_addr(self, f: impl FnOnce(NonZeroUsize) -> NonZeroUsize) -> Self

Like NonNull::map_addr

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

Like NonNull::as_ptr

pub const fn as_inner(self) -> NonNull<T>

Get inner NonNull<T>

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

Like NonNull::as_ref

Safety

See NonNull::as_ref for safety concerns and examples.

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

Like NonNull::as_mut

Safety

See NonNull::as_mut for safety concerns and examples.

pub const fn cast<U>(self) -> NonNull<U>

Like NonNull::cast

pub const unsafe fn offset(self, count: isize) -> Self

where T: Sized,

Like NonNull::offset

Safety

See NonNull::offset for safety concerns and examples.

pub const unsafe fn byte_offset(self, count: isize) -> Self

Like NonNull::byte_offset

Safety

See NonNull::byte_offset for safety concerns and examples.

pub const unsafe fn add(self, count: usize) -> Self

where T: Sized,

Like NonNull::add

Safety

See NonNull::add for safety concerns and examples.

pub const unsafe fn byte_add(self, count: usize) -> Self

Like NonNull::byte_add

Safety

See NonNull::byte_add for safety concerns and examples.

pub const unsafe fn sub(self, count: usize) -> Self

where T: Sized,

Like NonNull::sub

Safety

See NonNull::sub for safety concerns and examples.

pub const unsafe fn byte_sub(self, count: usize) -> Self

Like NonNull::byte_sub

Safety

See NonNull::byte_sub for safety concerns and examples.

pub const unsafe fn offset_from(self, origin: NonNull<T>) -> isize

where T: Sized,

Like NonNull::offset_from

Safety

See NonNull::offset_from for safety concerns and examples.

pub const unsafe fn byte_offset_from<U: ?Sized>( self, origin: NonNull<U>, ) -> isize

Like NonNull::byte_offset_from

Safety

See NonNull::byte_offset_from for safety concerns and examples.

pub const unsafe fn read(self) -> T

where T: Sized,

Like NonNull::read

Safety

See NonNull::read for safety concerns and examples.

pub unsafe fn read_volatile(self) -> T

where T: Sized,

Like NonNull::read_volatile

Safety

See NonNull::read_volatile for safety concerns and examples.

pub const unsafe fn read_unaligned(self) -> T

where T: Sized,

Like NonNull::read_unaligned

Safety

See NonNull::read_unaligned for safety concerns and examples.

pub const unsafe fn copy_to(self, dest: NonNull<T>, count: usize)

where T: Sized,

Like NonNull::copy_to

Safety

See NonNull::copy_to for safety concerns and examples.

pub const unsafe fn copy_to_nonoverlapping(self, dest: NonNull<T>, count: usize)

where T: Sized,

Like NonNull::copy_to_nonoverlapping

Safety

See NonNull::copy_to_nonoverlapping for safety concerns and examples.

pub const unsafe fn copy_from(self, src: NonNull<T>, count: usize)

where T: Sized,

Like NonNull::copy_from

Safety

See NonNull::copy_from for safety concerns and examples.

pub const unsafe fn copy_from_nonoverlapping( self, src: NonNull<T>, count: usize, )

where T: Sized,

Like NonNull::copy_from_nonoverlapping

Safety

See NonNull::copy_from_nonoverlapping for safety concerns and examples.

pub unsafe fn drop_in_place(self)

Like NonNull::drop_in_place

Safety

See NonNull::drop_in_place for safety concerns and examples.

pub const unsafe fn write(self, val: T)

where T: Sized,

Like NonNull::write

Safety

See NonNull::write for safety concerns and examples.

pub const unsafe fn write_bytes(self, val: u8, count: usize)

where T: Sized,

Like NonNull::write_bytes

Safety

See NonNull::write_bytes for safety concerns and examples.

pub unsafe fn write_volatile(self, val: T)

where T: Sized,

Like NonNull::write_volatile

Safety

See NonNull::write_volatile for safety concerns and examples.

pub const unsafe fn write_unaligned(self, val: T)

where T: Sized,

Like NonNull::write_unaligned

Safety

See NonNull::write_unaligned for safety concerns and examples.

pub unsafe fn replace(self, src: T) -> T

where T: Sized,

Like NonNull::replace

Safety

See NonNull::replace for safety concerns and examples.

pub const unsafe fn swap(self, with: NonNull<T>)

where T: Sized,

Like NonNull::swap

Safety

See NonNull::swap for safety concerns and examples.

pub fn align_offset(self, align: usize) -> usize

where T: Sized,

Like NonNull::align_offset

pub fn is_aligned(self) -> bool

where T: Sized,

Like NonNull::is_aligned

impl<T> NonNullMut<[T]>

pub const fn slice_from_raw_parts(data: NonNull<T>, len: usize) -> Self

Like NonNull::slice_from_raw_parts

pub const fn len(self) -> usize

Like NonNull::len

pub const fn is_empty(self) -> bool

Like NonNull::is_empty

Trait Implementations

impl<T: ?Sized> Clone for NonNullMut<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> Debug for NonNullMut<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> From<&T> for NonNullMut<T>

fn from(r: &T) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<&mut T> for NonNullMut<T>

fn from(r: &mut T) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<NonNull<T>> for NonNullMut<T>

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

Converts to this type from the input type.

impl<T: ?Sized> From<NonNullMut<T>> for NonNull<T>

fn from(value: NonNullMut<T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> Hash for NonNullMut<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: ?Sized> Ord for NonNullMut<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: ?Sized> PartialEq for NonNullMut<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ?Sized> PartialOrd for NonNullMut<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: ?Sized> Pointer for NonNullMut<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Copy for NonNullMut<T>

impl<T: ?Sized> Eq for NonNullMut<T>