Struct ManagedMutPtr

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

A wrapper of NonNullExt that can be used to manage a mutable pointer.

When the check feature is enabled, the crate tracks whether ManagedMutPtr or ManagedConstPtr that has the same address is being created while the pointer is alive. This could be useful when you need extra debugging facility than NonNullExt.

Safety

The pointer is used as a mutable reference without unsafe function such as NonNull::as_mut because the pointer is completely managed. Therefore, You must make sure that the pointer will not violate any conditions of Pointer to reference conversion in std::ptr document.

Implementations

impl<T: ?Sized> ManagedMutPtr<T>

pub unsafe fn new(ptr: NonNullExt<T>) -> Self

Creates a ManagedMutPtr from the given pointer.

Safety

See ManagedMutPtr safety section.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0;
let ptr = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(ptr) };

pub const fn dangling() -> Self

where T: Sized,

Creates a ManagedMutPtr that is dangling, but well-aligned.

In many Rust functions, they require aligned pointers even if they are some trash values. This function will be usuful in that cases.

Examples

use my_ecs::ds::ManagedMutPtr;

let dangling = ManagedMutPtr::<i32>::dangling();

pub fn is_dangling(&self) -> bool

where T: Sized,

Returns true if the pointer is dangling.

Examples

use my_ecs::ds::ManagedMutPtr;

let dangling = ManagedMutPtr::<i32>::dangling();
assert!(dangling.is_dangling());

pub fn as_nonnullext(&self) -> NonNullExt<T>

Creates a NonNullExt from this pointer.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };
assert_eq!(ptr.as_nonnullext(), nne);

pub fn as_nonnull(&self) -> NonNull<T>

Creates a NonNull from this pointer.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };
assert_eq!(ptr.as_nonnull(), *nne);

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

Creates a raw poitner from this pointer.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };
assert_eq!(ptr.as_ptr(), nne.as_ptr());

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

Converts the pointer into a mutable reference.

Note that trace of the address by check feature ends by consuming the pointer.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };
assert_eq!(ptr.into_mut(), &0);

pub fn cast<U>(self) -> ManagedMutPtr<U>

Casts the pointer to another type.

This method doesn’t break the trace of the address by check feature. But internal type information is reset. See NonNullExt::cast.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0x1234_5678;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };

let ptr = ptr.cast::<[u8; 4]>();
let ref_v = ptr.into_mut();
assert_eq!(*ref_v, i32::to_ne_bytes(v));

pub fn cast_const(self) -> ManagedConstPtr<T>

Changes constness without changing the type.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let mut v = 0;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };
let ptr = ptr.cast_const();

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

where T: Sized,

Adds an offset to the pointer then returns the result.

Note that count is in units of T. For example, count = 3 means 12 bytes offset if T is i32.

Safety

See NonNull::add.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let arr: [char; 2] = ['a', 'b'];
let nne = NonNullExt::new(arr.as_ptr().cast_mut()).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };
unsafe { assert_eq!(*ptr.add(1), 'b') };

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

where T: Sized,

Subtracts an offset from the pointer then returns the result.

Note that count is in units of T. For example, count = 3 means 12 bytes offset if T is i32.

Safety

See NonNull::sub.

Examples

use my_ecs::ds::{NonNullExt, ManagedMutPtr};

let arr: [char; 2] = ['a', 'b'];
let nne = NonNullExt::new((&arr[1] as *const char).cast_mut()).unwrap();
let ptr = unsafe { ManagedMutPtr::new(nne) };

unsafe { assert_eq!(*ptr.sub(1), 'a') };

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T: ?Sized> Deref for ManagedMutPtr<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized> DerefMut for ManagedMutPtr<T>

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

Mutably dereferences the value.

impl<T: ?Sized> Hash for ManagedMutPtr<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 ManagedMutPtr<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 ManagedMutPtr<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 ManagedMutPtr<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> Eq for ManagedMutPtr<T>

impl<T: ?Sized + Send> Send for ManagedMutPtr<T>