Struct ConstPtr 

pub struct ConstPtr<T: ?Sized>(/* private fields */);

A pointer that references immutable data and is never Null.

Implementations

impl<T: ?Sized> ConstPtr<T>

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

Creates a new ConstPtr. This is a const fn.

Safety

ptr must be non-null.

Examples

use constptr::ConstPtr;

static x: u32 = 0u32;
let ptr = unsafe { ConstPtr::new_unchecked(&x) };

pub const fn from(reference: &T) -> Self

Creates a new ConstPtr from a reference which makes it safe. This is a const fn.

Examples

use constptr::ConstPtr;

static x: u32 = 0u32;
let ptr = ConstPtr::from(&x);

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

Creates a new ConstPtr if ptr is non-null.

Examples

use constptr::ConstPtr;

let x = 0u32;
let ptr = ConstPtr::new(&x).expect("ptr is null!");

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

pub fn addr(self) -> NonZeroUsize

Gets the “address” portion of the pointer.

For more details see the equivalent method on a raw pointer pointer::addr.

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

Acquires the underlying *const pointer.

Examples

use constptr::ConstPtr;

let mut x = 0u32;
let ptr = ConstPtr::new(&mut x).expect("ptr is null!");

let x_value = unsafe { *ptr.as_ptr() };
assert_eq!(x_value, 0);

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

Returns a shared reference to the value.

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”.

• 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 constptr::ConstPtr;

let x = 0u32;
let ptr = ConstPtr::new(&x).expect("ptr is null!");

let ref_x = unsafe { ptr.as_ref() };
println!("{ref_x}");

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

Casts to a pointer of another type.

Examples

use constptr::ConstPtr;

let  x = 0u32;
let ptr = ConstPtr::new(&x).expect("null pointer");

let casted_ptr = ptr.cast::<i8>();
let raw_ptr: *const i8 = casted_ptr.as_ptr();

Trait Implementations

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

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

Formats the value using the given formatter.

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

fn from(reference: &T) -> Self

Converts a &T to a ConstPtr<T>.

This conversion is safe and infallible since references cannot be null.

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

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

Converts a &mut T to a ConstPtr<T>.

This conversion is safe and infallible since references cannot be null.

Safety

Creating a ConstPtr from a mutable reference is safe. However, you must ensure that the ConstPtr is not used while the mutable reference is still in use. The other safety requirements for ConstPtr still apply. Eg the object must still be valid at the time of dereferencing, even after the mutable reference is dropped.

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

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

Formats the value using the given formatter.

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

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

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

ConstPtr pointers can be Send because they are constant.

impl<T: ?Sized + Send + Sync> Sync for ConstPtr<T>

ConstPtr pointers can be Sync because they are constant.