Struct AllocPtr

#[repr(C)]
pub struct AllocPtr<T, Alloc> {
    pub ptr: NonNull<T>,
    pub marker: PhantomData<Alloc>,
}

A non-null pointer guaranteed to be preceded by a valid AllocPrefix unless the pointer is dangling.

This means that unless T is a ZST, the pointer is guaranteed to be aligned to the maximum of T’s alignment and the alignment of the prefix, which itself is ptr-size aligned.

Fields

ptr: NonNull<T>

The pointer to the data.

marker: PhantomData<Alloc>

Remember the allocator’s type.

Implementations

impl<T, Alloc> AllocPtr<T, Alloc>

where Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>>: IStable, PhantomData<Alloc>: IStable, NonNull<T>: IStable,

pub const fn has_optimal_layout() -> bool

Returns true if the layout for AllocPtr is smaller or equal to that Rust would have generated for it.

impl<T, Alloc> AllocPtr<MaybeUninit<T>, Alloc>

pub const unsafe fn assume_init(self) -> AllocPtr<T, Alloc>

Assumes the internals of the pointer have been initialized.

Safety

The internals of the pointer must have been initialized.

impl<T, Alloc> AllocPtr<T, Alloc>

pub const fn dangling() -> Self

Constructs a dangling pointer.

pub const fn cast<U>(self) -> AllocPtr<U, Alloc>

Casts an allocated pointer.

pub const unsafe fn prefix(&self) -> &AllocPrefix<Alloc>

A reference to the prefix for this allocation.

Safety

self must not be dangling, and have been properly allocated, using Self::alloc or Self::realloc for example.

pub const unsafe fn prefix_mut(&mut self) -> &mut AllocPrefix<Alloc>

A mutable reference to the prefix for this allocation.

Safety

self must not be dangling, and have been properly allocated, using Self::alloc or Self::realloc for example. Since this type is Copy, the &mut self is not a sufficient guarantee of uniqueness.

pub const unsafe fn split_mut(&mut self) -> (&mut AllocPrefix<Alloc>, &mut T)

Returns mutable access to the prefix and the data.

Safety

self must not be dangling, and have been properly allocated, using Self::alloc or Self::realloc for example.

pub unsafe fn init(ptr: NonNull<()>, capacity: usize) -> Self

Initializes any given pointer:

• The returned pointer is guaranteed to be correctly aligned for T
• It is guaranteed to preceded without padding by an AllocPrefix<Alloc>

Safety

ptr MUST be word-aligned, and MUST be valid for writes for at least the size of #[repr(C)] struct { prefix: AllocPrefix<Alloc>, data: [T; capacity] }

impl<T, Alloc: IAlloc> AllocPtr<T, Alloc>

pub fn alloc(alloc: &mut Alloc) -> Option<Self>

Allocates a pointer to a single element of T, prefixed by an AllocPrefix

pub fn alloc_array(alloc: &mut Alloc, capacity: usize) -> Option<Self>

Allocates a pointer to an array of capacity T, prefixed by an AllocPrefix

pub unsafe fn realloc( self, alloc: &mut Alloc, prev_capacity: usize, new_capacity: usize, ) -> Option<Self>

Reallocates a pointer to an array of capacity T, prefixed by an AllocPrefix.

In case of failure of the allocator, this will return None and self will not have been freed.

Safety

self must not be dangling

pub unsafe fn free(self, alloc: &mut Alloc)

Reallocates a pointer to an array of capacity T, prefixed by an AllocPrefix

Safety

self must not be dangling, and is freed after this returns.

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 the pointer is convertible to a reference.

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 the pointer is convertible to a reference.

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, Alloc> Clone for AllocPtr<T, Alloc>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Alloc: Debug> Debug for AllocPtr<T, Alloc>

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

Formats the value using the given formatter.

impl<T, Alloc> Deref for AllocPtr<T, Alloc>

type Target = NonNull<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, Alloc> DerefMut for AllocPtr<T, Alloc>

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

Mutably dereferences the value.

impl<T, Alloc> IStable for AllocPtr<T, Alloc>

where Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>>: IStable, PhantomData<Alloc>: IStable, NonNull<T>: IStable,

const REPORT: &'static TypeReport

A compile-time generated report of the fields of the type, allowing for compatibility inspection.

const ID: u64

A stable (and ideally unique) identifier for the type. Often generated using crate::report::gen_id, but can be manually set.

type ForbiddenValues = <Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>> as IStable>::ForbiddenValues

The values that the annotated type cannot occupy.

type UnusedBits = <Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>> as IStable>::UnusedBits

The padding bits in the annotated types

type Size = <Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>> as IStable>::Size

The size of the annotated type in bytes.

type Align = <Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>> as IStable>::Align

The alignment of the annotated type in bytes.

type HasExactlyOneNiche = <Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>> as IStable>::HasExactlyOneNiche

Allows the detection of whether or not core::option::Options are stable:

type ContainsIndirections = <Struct<FieldPair<NonNull<T>, PhantomData<Alloc>>> as IStable>::ContainsIndirections

Whether or not the type contains indirections (pointers, indices in independent data-structures…)

fn size() -> usize

Returns the size of the type.

fn align() -> usize

Returns the alignment of the type.

unsafe fn is_invalid(ptr: *const u8) -> bool

Returns true if ptr points to memory that cannot be a valid value of Self.

impl<T: Ord, Alloc: Ord> Ord for AllocPtr<T, Alloc>

fn cmp(&self, other: &AllocPtr<T, Alloc>) -> 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: PartialEq, Alloc: PartialEq> PartialEq for AllocPtr<T, Alloc>

fn eq(&self, other: &AllocPtr<T, Alloc>) -> 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: PartialOrd, Alloc: PartialOrd> PartialOrd for AllocPtr<T, Alloc>

fn partial_cmp(&self, other: &AllocPtr<T, Alloc>) -> 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, Alloc> Copy for AllocPtr<T, Alloc>

impl<T: Eq, Alloc: Eq> Eq for AllocPtr<T, Alloc>

impl<T, Alloc> StructuralPartialEq for AllocPtr<T, Alloc>