use core::ptr::{self, NonNull};
use crate::arena::{Arena, ArenaExhausted};
mod sealed {
pub trait Sealed {}
}
pub trait FixedLeScalar: Copy + sealed::Sealed {}
macro_rules! impl_fixed_le_scalar {
($($t:ty),* $(,)?) => {
$(
impl sealed::Sealed for $t {}
impl FixedLeScalar for $t {}
)*
};
}
impl_fixed_le_scalar!(u32, i32, f32, u64, i64, f64);
const FIRST_CAP: usize = 4;
pub struct DecodeVec<'a, T> {
arena: &'a Arena<'a>,
ptr: NonNull<T>, len: usize,
cap: usize,
}
impl<'a, T> DecodeVec<'a, T> {
#[inline]
#[must_use]
pub fn new(arena: &'a Arena<'a>) -> Self {
Self {
arena,
ptr: NonNull::dangling(),
len: 0,
cap: 0,
}
}
#[inline]
pub fn push(&mut self, value: T) -> Result<(), ArenaExhausted> {
if self.len == self.cap {
self.grow()?;
}
unsafe { self.ptr.as_ptr().add(self.len).write(value) };
self.len += 1;
Ok(())
}
#[inline(always)]
pub fn emplace<E, F>(&mut self, f: F) -> Result<(), E>
where
E: From<ArenaExhausted>,
F: for<'id> FnOnce(
crate::decode_slot::Slot<'id, T>,
) -> Result<crate::decode_slot::Init<'id>, E>,
{
if self.len == self.cap {
self.grow()?;
}
let slot = unsafe { crate::decode_slot::Slot::new(self.ptr.add(self.len)) };
let _init = f(slot)?;
self.len += 1;
Ok(())
}
#[inline]
pub fn reserve(&mut self, additional: usize) -> Result<(), ArenaExhausted> {
let needed = self.len.checked_add(additional).ok_or(ArenaExhausted)?;
if needed > self.cap {
self.grow_to(needed)?;
}
Ok(())
}
#[inline]
pub fn shrink_to_fit(&mut self) {
if self.cap > self.len {
let size = core::mem::size_of::<T>();
if size != 0 {
unsafe {
self.arena
.shrink_last(self.ptr.cast::<u8>(), self.cap * size, self.len * size);
}
}
self.cap = self.len;
}
}
#[inline]
pub(crate) fn spare_capacity_ptr(&mut self) -> *mut T {
unsafe { self.ptr.as_ptr().add(self.len) }
}
#[inline]
pub(crate) unsafe fn advance_len(&mut self, additional: usize) {
debug_assert!(self.len + additional <= self.cap);
self.len += additional;
}
#[cold]
fn grow(&mut self) -> Result<(), ArenaExhausted> {
let new_cap = if self.cap == 0 {
FIRST_CAP
} else {
self.cap.checked_mul(2).ok_or(ArenaExhausted)?
};
self.grow_to(new_cap)
}
fn grow_to(&mut self, new_cap: usize) -> Result<(), ArenaExhausted> {
debug_assert!(new_cap > self.cap);
let new = self.arena.alloc_array::<T>(new_cap)?;
if self.len > 0 {
unsafe { ptr::copy_nonoverlapping(self.ptr.as_ptr(), new.as_ptr(), self.len) };
}
self.ptr = new;
self.cap = new_cap;
Ok(())
}
#[inline]
#[must_use]
pub fn into_slice(self) -> &'a [T] {
if self.len == 0 {
return &[];
}
unsafe { core::slice::from_raw_parts(self.ptr.as_ptr(), self.len) }
}
}
impl<'a, T: FixedLeScalar> DecodeVec<'a, T> {
#[inline]
pub fn extend_from_le_bytes(&mut self, bytes: &[u8]) -> Result<(), ArenaExhausted> {
let size = core::mem::size_of::<T>();
debug_assert!(size != 0 && bytes.len().is_multiple_of(size));
let count = bytes.len() / size;
if count == 0 {
return Ok(());
}
self.reserve(count)?;
unsafe {
ptr::copy_nonoverlapping(
bytes.as_ptr(),
self.ptr.as_ptr().add(self.len).cast::<u8>(),
count * size,
);
}
self.len += count;
Ok(())
}
}
#[cfg(all(test, feature = "alloc"))]
mod tests {
use super::*;
#[test]
fn grows_and_preserves_order_across_reallocations() {
let arena = Arena::new();
let mut v = DecodeVec::<u32>::new(&arena);
assert_eq!(v.len, 0);
for i in 0..100u32 {
v.push(i * 3).unwrap();
}
assert_eq!(v.len, 100);
let s = v.into_slice();
assert_eq!(s.len(), 100);
for (i, &x) in s.iter().enumerate() {
assert_eq!(x, i as u32 * 3);
}
}
#[test]
fn empty_is_an_empty_slice_and_allocates_nothing() {
let arena = Arena::new();
let v = DecodeVec::<u64>::new(&arena);
assert_eq!(v.into_slice(), &[] as &[u64]);
assert_eq!(arena.bytes_used(), 0);
}
#[test]
fn works_for_a_non_copy_relocatable_value() {
#[derive(PartialEq, Debug)]
struct Pair(u32, u64);
let arena = Arena::new();
let mut v = DecodeVec::<Pair>::new(&arena);
for i in 0..20u32 {
v.push(Pair(i, u64::from(i) << 40)).unwrap();
}
let s = v.into_slice();
for (i, p) in s.iter().enumerate() {
assert_eq!(*p, Pair(i as u32, (i as u64) << 40));
}
}
#[test]
fn reserve_pre_sizes_in_one_allocation_so_pushes_do_not_regrow() {
let arena = Arena::new();
let mut v = DecodeVec::<u64>::new(&arena);
v.reserve(100).unwrap();
assert_eq!(arena.bytes_used(), 100 * 8);
for i in 0..100u64 {
v.push(i).unwrap();
}
assert_eq!(arena.bytes_used(), 100 * 8);
let s = v.into_slice();
assert_eq!(s.len(), 100);
for (i, &x) in s.iter().enumerate() {
assert_eq!(x, i as u64);
}
}
#[test]
fn shrink_to_fit_reclaims_the_unused_tail_and_keeps_contents() {
let arena = Arena::new();
let mut v = DecodeVec::<u64>::new(&arena);
v.reserve(100).unwrap();
for i in 0..10u64 {
v.push(i * 7).unwrap();
}
assert_eq!(arena.bytes_used(), 100 * 8);
v.shrink_to_fit();
assert_eq!(arena.bytes_used(), 10 * 8);
v.push(999).unwrap();
let s = v.into_slice();
assert_eq!(s.len(), 11);
for (i, &x) in s.iter().take(10).enumerate() {
assert_eq!(x, i as u64 * 7);
}
assert_eq!(s[10], 999);
}
#[test]
fn shrink_to_fit_is_a_noop_when_not_the_last_allocation() {
let arena = Arena::new();
let mut v = DecodeVec::<u64>::new(&arena);
v.reserve(100).unwrap();
for i in 0..10u64 {
v.push(i).unwrap();
}
let _other = arena.alloc_array::<u64>(4).unwrap();
let before = arena.bytes_used();
v.shrink_to_fit();
assert_eq!(arena.bytes_used(), before);
let s = v.into_slice();
assert_eq!(s.len(), 10);
for (i, &x) in s.iter().enumerate() {
assert_eq!(x, i as u64);
}
}
#[test]
fn push_reports_arena_exhaustion_without_panicking() {
let arena = Arena::new();
arena.set_capacity_limit(256);
let mut v = DecodeVec::<u64>::new(&arena);
let mut pushed = 0usize;
while v.push(pushed as u64).is_ok() {
pushed += 1;
assert!(pushed <= 10_000, "expected the capped arena to exhaust");
}
let got = pushed;
let s = v.into_slice();
assert_eq!(s.len(), got);
for (i, &x) in s.iter().enumerate() {
assert_eq!(x, i as u64);
}
}
#[test]
fn extend_from_le_bytes_bulk_copies_fixed_elements_in_one_allocation() {
let arena = Arena::new();
let mut v = DecodeVec::<u64>::new(&arena);
let vals: [u64; 50] = core::array::from_fn(|i| (i as u64) << 40 | i as u64);
let mut bytes = alloc::vec::Vec::new();
for x in vals {
bytes.extend_from_slice(&x.to_le_bytes());
}
v.extend_from_le_bytes(&bytes).unwrap();
assert_eq!(arena.bytes_used(), 50 * 8);
let s = v.into_slice();
assert_eq!(s, &vals[..]);
}
#[test]
fn extend_from_le_bytes_decodes_float_bits_and_appends_after_existing() {
let arena = Arena::new();
let mut v = DecodeVec::<f64>::new(&arena);
v.push(2.5f64).unwrap();
let vals = [1.0f64, -0.0, f64::INFINITY, 12345.6789];
let mut bytes = alloc::vec::Vec::new();
for x in vals {
bytes.extend_from_slice(&x.to_le_bytes());
}
v.extend_from_le_bytes(&bytes).unwrap();
let s = v.into_slice();
assert_eq!(s.len(), 5);
assert_eq!(s[0], 2.5);
assert_eq!(s[1], 1.0);
assert_eq!(s[2], -0.0);
assert_eq!(s[3], f64::INFINITY);
assert_eq!(s[4], 12345.6789);
}
#[test]
fn extend_from_le_bytes_empty_is_a_noop() {
let arena = Arena::new();
let mut v = DecodeVec::<u32>::new(&arena);
v.extend_from_le_bytes(&[]).unwrap();
assert_eq!(v.len, 0);
assert_eq!(arena.bytes_used(), 0);
assert_eq!(v.into_slice(), &[] as &[u32]);
}
#[test]
fn emplace_publishes_on_ok_and_abandons_the_slot_on_err() {
let arena = Arena::new();
let mut v = DecodeVec::<u64>::new(&arena);
v.emplace::<ArenaExhausted, _>(|slot| Ok(slot.write(42)))
.unwrap();
assert_eq!(v.len, 1);
let r = v.emplace::<ArenaExhausted, _>(|slot| {
slot.write(999);
Err(ArenaExhausted)
});
assert!(r.is_err());
assert_eq!(v.len, 1);
assert_eq!(v.into_slice(), &[42]); }
}