Struct RawVecInner 

struct RawVecInner<A: Allocator = Global> {
    ptr: Unique<u8>,
    cap: UsizeNoHighBit,
    alloc: A,
}

🔬This is a nightly-only experimental API. (raw_vec_internals)

Like a RawVec, but only generic over the allocator, not the type.

As such, all the methods need the layout passed-in as a parameter.

Having this separation reduces the amount of code we need to monomorphize, as most operations don’t need the actual type, just its layout.

Fields

ptr: Unique<u8>

🔬This is a nightly-only experimental API. (raw_vec_internals)

cap: UsizeNoHighBit

🔬This is a nightly-only experimental API. (raw_vec_internals)

Never used for ZSTs; it’s capacity()’s responsibility to return usize::MAX in that case.

Safety

cap must be in the 0..=isize::MAX range.

alloc: A

🔬This is a nightly-only experimental API. (raw_vec_internals)

Implementations

impl RawVecInner<Global>

fn with_capacity(capacity: usize, elem_layout: Layout) -> Self

🔬This is a nightly-only experimental API. (raw_vec_internals)

impl<A: Allocator> RawVecInner<A>

const fn new_in(alloc: A, align: Alignment) -> Self

🔬This is a nightly-only experimental API. (raw_vec_internals)

fn with_capacity_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self

🔬This is a nightly-only experimental API. (raw_vec_internals)

fn try_with_capacity_in( capacity: usize, alloc: A, elem_layout: Layout, ) -> Result<Self, TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

fn with_capacity_zeroed_in( capacity: usize, alloc: A, elem_layout: Layout, ) -> Self

🔬This is a nightly-only experimental API. (raw_vec_internals)

fn try_allocate_in( capacity: usize, init: AllocInit, alloc: A, elem_layout: Layout, ) -> Result<Self, TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

unsafe fn from_raw_parts_in(ptr: *mut u8, cap: UsizeNoHighBit, alloc: A) -> Self

🔬This is a nightly-only experimental API. (raw_vec_internals)

unsafe fn from_nonnull_in( ptr: NonNull<u8>, cap: UsizeNoHighBit, alloc: A, ) -> Self

🔬This is a nightly-only experimental API. (raw_vec_internals)

const fn ptr<T>(&self) -> *mut T

🔬This is a nightly-only experimental API. (raw_vec_internals)

const fn non_null<T>(&self) -> NonNull<T>

🔬This is a nightly-only experimental API. (raw_vec_internals)

const fn capacity(&self, elem_size: usize) -> usize

🔬This is a nightly-only experimental API. (raw_vec_internals)

fn allocator(&self) -> &A

🔬This is a nightly-only experimental API. (raw_vec_internals)

unsafe fn current_memory( &self, elem_layout: Layout, ) -> Option<(NonNull<u8>, Layout)>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment

unsafe fn reserve(&mut self, len: usize, additional: usize, elem_layout: Layout)

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment

unsafe fn grow_one(&mut self, elem_layout: Layout)

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment

unsafe fn try_reserve( &mut self, len: usize, additional: usize, elem_layout: Layout, ) -> Result<(), TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment

unsafe fn reserve_exact( &mut self, len: usize, additional: usize, elem_layout: Layout, )

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment

unsafe fn try_reserve_exact( &mut self, len: usize, additional: usize, elem_layout: Layout, ) -> Result<(), TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment

unsafe fn shrink_to_fit(&mut self, cap: usize, elem_layout: Layout)

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment
• cap must be less than or equal to self.capacity(elem_layout.size())

fn needs_to_grow( &self, len: usize, additional: usize, elem_layout: Layout, ) -> bool

🔬This is a nightly-only experimental API. (raw_vec_internals)

unsafe fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize)

🔬This is a nightly-only experimental API. (raw_vec_internals)

unsafe fn grow_amortized( &mut self, len: usize, additional: usize, elem_layout: Layout, ) -> Result<(), TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment
• The sum of len and additional must be greater than the current capacity

unsafe fn grow_exact( &mut self, len: usize, additional: usize, elem_layout: Layout, ) -> Result<(), TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment
• The sum of len and additional must be greater than the current capacity

unsafe fn finish_grow( &self, cap: usize, elem_layout: Layout, ) -> Result<NonNull<[u8]>, TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment
• cap must be greater than the current capacity

unsafe fn shrink( &mut self, cap: usize, elem_layout: Layout, ) -> Result<(), TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

• elem_layout must be valid for self, i.e. it must be the same elem_layout used to initially construct self
• elem_layout’s size must be a multiple of its alignment
• cap must be less than or equal to self.capacity(elem_layout.size())

unsafe fn shrink_unchecked( &mut self, cap: usize, elem_layout: Layout, ) -> Result<(), TryReserveError>

🔬This is a nightly-only experimental API. (raw_vec_internals)

shrink, but without the capacity check.

This is split out so that shrink can inline the check, since it optimizes out in things like shrink_to_fit, without needing to also inline all this code, as doing that ends up failing the vec-shrink-panic codegen test when shrink_to_fit ends up being too big for LLVM to be willing to inline.

Safety

cap <= self.capacity()

unsafe fn deallocate(&mut self, elem_layout: Layout)

🔬This is a nightly-only experimental API. (raw_vec_internals)

Safety

This function deallocates the owned allocation, but does not update ptr or cap to prevent double-free or use-after-free. Essentially, do not do anything with the caller after this function returns. Ideally this function would take self by move, but it cannot because it exists to be called from a Drop impl.