Trait generic_vec::raw::Storage

pub unsafe trait Storage<T> {
    pub const IS_ALIGNED: bool;

    pub fn capacity(&self) -> usize;
    pub fn as_ptr(&self) -> *const T;
    pub fn as_mut_ptr(&mut self) -> *mut T;
    pub fn reserve(&mut self, new_capacity: usize);
    pub fn try_reserve(&mut self, new_capacity: usize) -> bool;
}

A type that can hold Ts, and potentially reserve space for more Self::Itemss

Associated Constants

pub const IS_ALIGNED: bool

Is the pointer from as_ptr guaranteed to be aligned to T

Ideally this would be a where clause to prevent alignment issues at compile time, but that can't happen until const-generics allows predicates in where bounds (like where align_of::<T>() >= align_of::<U>())

Loading content...

Required methods

pub fn capacity(&self) -> usize

The number of elements that it is valid to write to this Storage

i.e. as_mut_ptr()..as_mut_ptr() + capacity() should be valid to write Ts

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

Returns a pointer to the first element

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

Returns a mutable pointer to the first element

pub fn reserve(&mut self, new_capacity: usize)

Reserves space for at least new_capacity elements

Safety

After this call successfully ends, the capacity must be at least new_capacity

Panic/Abort

Maybe panic or abort if it is impossible to set the capacity to at least new_capacity

pub fn try_reserve(&mut self, new_capacity: usize) -> bool

Tries to reserve space for at least new_capacity elements

Returns Ok(()) on success, Err(AllocError) if it is impossible to set the capacity to at least new_capacity

Safety

If Ok(()) is returned, the capacity must be at least new_capacity

Loading content...

Implementations on Foreign Types

impl<T: Copy> Storage<T> for [T; 0]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 1]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 2]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 3]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 4]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 5]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 6]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 7]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 8]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 9]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 10]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 11]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 12]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 13]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 14]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 15]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 16]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 17]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 18]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 19]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 20]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 21]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 22]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 23]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 24]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 25]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 26]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 27]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 28]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 29]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 30]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 31]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T; 32]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T: Copy> Storage<T> for [T]

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T, S: ?Sized + Storage<T>, '_> Storage<T> for &'_ mut S

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, new_capacity: usize)

pub fn try_reserve(&mut self, new_capacity: usize) -> bool

impl<T, S: ?Sized + Storage<T>> Storage<T> for Box<S>

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

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

pub fn reserve(&mut self, new_capacity: usize)

pub fn try_reserve(&mut self, new_capacity: usize) -> bool

Loading content...

Implementors

impl<T> Storage<T> for ZeroSized<T>

pub const CONST_CAPACITY: Option<usize>

pub const IS_ALIGNED: bool

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

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

pub fn reserve(&mut self, _: usize)

pub fn try_reserve(&mut self, _: usize) -> bool

pub fn capacity(&self) -> usize

impl<T, U> Storage<U> for UninitSlice<T>

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

pub fn as_mut_ptr(&mut self) -> *mut U

pub fn reserve(&mut self, new_capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

impl<T, U, A: ?Sized + AllocRef> Storage<U> for Heap<T, A>

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

pub fn as_mut_ptr(&mut self) -> *mut U

pub fn reserve(&mut self, new_capacity: usize)

pub fn try_reserve(&mut self, new_capacity: usize) -> bool

impl<U, T, A> Storage<U> for UninitBuffer<T, A>

pub const IS_ALIGNED: bool

pub fn capacity(&self) -> usize

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

pub fn as_mut_ptr(&mut self) -> *mut U

pub fn reserve(&mut self, new_capacity: usize)

pub fn try_reserve(&mut self, capacity: usize) -> bool

Loading content...