Struct pal::HeaderVec

pub struct HeaderVec<T, U: FixedArray> { /* private fields */ }

Implements a Vec-like type for building structures with a fixed-sized prefix before a dynamic number of elements.

To avoid allocations in common cases, the header and elements are stored internally without allocating until the element count would exceed the statically determined capacity.

Only a small portion of the Vec interface is supported. Additional methods can be added as needed.

The data managed by this type must be Copy. This simplifies the resource management and should be sufficient for most use cases.

Example

#[derive(Copy, Clone)]
struct Header { x: u32 }
let mut v = HeaderVec::<Header, [u8; 10]>::new(Header{ x: 1234 });
v.push(5);
v.push(6);
assert_eq!(v.x, 1234);
assert_eq!(&v[..], &[5, 6]);

Implementations

impl<T: Copy, U: FixedArray> HeaderVec<T, U>

pub fn new(head: T) -> Self

Constructs a new HeaderVec with a header of head and no tail elements.

pub fn with_capacity(head: T, cap: usize) -> Self

Constructs a new HeaderVec with a header of head and no tail elements, but with a dynamically allocated capacity for cap elements.

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

pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<U::Element>]

Returns the remaining spare capacity of the tail as a slice of MaybeUninit<U::Element>.

The returned slice can be used to fill the tail with data before marking the data as initialized using `Self::set_len.

pub fn push(&mut self, val: U::Element)

Pushes a tail element, reallocating if necessary.

pub fn extend_from_slice(&mut self, other: &[U::Element])

Extends the tail elements from the given slice.

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

Retrieves a pointer to the head. The tail is guaranteed to immediately after the head (with appropriate padding).

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

Retrieves a mutable pointer to the head. The tail is guaranteed to immediately after the head (with appropriate padding).

pub fn as_slice(&self) -> &[U::Element]

Returns a slice of the tail elements.

pub fn as_mut_slice(&mut self) -> &mut [U::Element]

Returns a mutable slice of the tail elements.

pub fn len(&self) -> usize

Returns the number of tail elements.

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

Returns true if there are no tail elements.

pub fn clear(&mut self)

Sets the number of tail elements to 0.

pub fn truncate(&mut self, len: usize)

Truncates the tail to len elements. Has no effect if there are already fewer than len tail elements.

pub unsafe fn set_len(&mut self, len: usize)

Sets the number of tail elements.

Panics if len is greater than the capacity.

Safety

The caller must ensure that all len elements have been initialized.

pub fn total_byte_len(&self) -> usize

Returns the total contiguous byte length of the structure, including both the head and tail elements.

pub fn total_byte_capacity(&self) -> usize

Returns the total contiguous byte length of the structure, including both the head and tail elements, including the tail’s capacity.

pub fn iter(&self) -> Iter<'_, U::Element>

Returns an iterator of the tail elements.

pub fn iter_mut(&mut self) -> IterMut<'_, U::Element>

Returns a mutable iterator of the tail elements.

Trait Implementations

impl<T: Debug, U: Debug + FixedArray> Debug for HeaderVec<T, U>

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

Formats the value using the given formatter.

impl<T: Copy + Default, U: FixedArray> Default for HeaderVec<T, U>

fn default() -> Self

Returns the “default value” for a type.

impl<T, U: FixedArray> Deref for HeaderVec<T, U>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, U: FixedArray> DerefMut for HeaderVec<T, U>

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

Mutably dereferences the value.

impl<T: Copy, U: FixedArray> Extend<<U as FixedArray>::Element> for HeaderVec<T, U>

fn extend<I: IntoIterator<Item = U::Element>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Copy, U: FixedArray, I: SliceIndex<[U::Element]>> Index<I> for HeaderVec<T, U>

type Output = <I as SliceIndex<[<U as FixedArray>::Element]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Copy, U: FixedArray, I: SliceIndex<[U::Element]>> IndexMut<I> for HeaderVec<T, U>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.