Struct ManagedConstPtr

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

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

When the check feature is enabled, the crate tracks whether ManagedMutPtr 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 shared reference without unsafe function such as NonNull::as_ref 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> ManagedConstPtr<T>

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

Creates a ManagedConstPtr from the given pointer.

Safety

See ManagedConstPtr safety section.

Examples

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

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

pub const fn dangling() -> Self

where T: Sized,

Creates a ManagedConstPtr 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::ManagedConstPtr;

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

pub fn is_dangling(&self) -> bool

where T: Sized,

Returns true if the pointer is dangling.

Examples

use my_ecs::ds::ManagedConstPtr;

let dangling = ManagedConstPtr::<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, ManagedConstPtr};

let mut v = 0;
let nne = NonNullExt::new(&mut v as *mut i32).unwrap();
let ptr = unsafe { ManagedConstPtr::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, ManagedConstPtr};

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

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

Creates a raw poitner from this pointer.

Examples

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

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

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

Converts the pointer into a shared reference.

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

Examples

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

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

pub fn cast<U>(self) -> ManagedConstPtr<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, ManagedConstPtr};

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

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

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, ManagedConstPtr};

let arr: [char; 3] = ['a', 'b', 'c'];
let nne = NonNullExt::new(arr.as_ptr().cast_mut()).unwrap();
let ptr = unsafe { ManagedConstPtr::new(nne) };

unsafe {
    assert_eq!(*ptr.add(1), 'b');
    assert_eq!(*ptr.add(2), 'c');
}

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, ManagedConstPtr};

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

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

Trait Implementations

impl<T: ?Sized> Clone for ManagedConstPtr<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 ManagedConstPtr<T>

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

Formats the value using the given formatter.

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

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized> Hash for ManagedConstPtr<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 ManagedConstPtr<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 ManagedConstPtr<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 ManagedConstPtr<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> Copy for ManagedConstPtr<T>

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

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