You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

113 lines
2.4 KiB

//! A `Vec`-like wrapper type that only allocates if a provided buffer is first exhausted.
use std::mem::{
MaybeUninit,
ManuallyDrop,
};
use std::marker::{Send, Sync, PhantomData};
use std::ops::Drop;
use std::slice;
#[repr(C)]
#[derive(Debug)]
struct StackBuffer<T>
{
fill_ptr: usize,
buf_ptr: *mut MaybeUninit<T>,
}
impl<T> Clone for StackBuffer<T>
{
fn clone(&self) -> Self {
Self{
fill_ptr: self.fill_ptr,
buf_ptr: self.buf_ptr,
}
}
}
impl<T> Copy for StackBuffer<T>{}
#[repr(C)]
#[derive(Debug, Clone)]
struct HeapBuffer<T>
{
_fill_ptr: usize, // vec.len()
buf: Vec<T>,
}
#[repr(C)]
union Internal<T>
{
stack: StackBuffer<T>,
heap: ManuallyDrop<HeapBuffer<T>>,
}
/// A growable vector with a backing slice that will move its elements to the heap if the slice space is exhausted.
pub struct AVec<'a, T>
{
/// max size of `inner.stack` before it's moved to `inner.heap`.
stack_sz: usize,
inner: Internal<T>,
_stack: PhantomData<&'a mut [MaybeUninit<T>]>,
}
unsafe impl<'a, T> Send for AVec<'a, T>{}
unsafe impl<'a, T> Sync for AVec<'a, T>{}
impl<'a, T> Drop for AVec<'a, T>
{
fn drop(&mut self) {
if self.is_allocated() {
// All stack elements have been moved to the heap. Drop the heap buffer.
unsafe {
ManuallyDrop::drop(&mut self.inner.heap);
}
} else {
if std::mem::needs_drop::<T>() {
// Drop the allocated stack elements in place
unsafe {
std::ptr::drop_in_place(std::ptr::slice_from_raw_parts_mut(self.inner.stack.buf_ptr as *mut T, self.fill_ptr())); // I think this drops the elements, we don't need to loop.
/*
for x in slice::from_raw_parts_mut(self.inner.stack.buf_ptr, self.fill_ptr())
{
std::ptr::drop_in_place(x.as_mut_ptr());
}*/
}
}
}
}
}
impl<'a, T> AVec<'a, T>
{
/// The current fill_ptr of this stack buffer
fn fill_ptr(&self) -> usize
{
// SAFETY: Both fields are repr(C) with this element first
unsafe {
self.inner.stack.fill_ptr
}
}
/// Have the elements been moved to the heap?
pub fn is_allocated(&self) -> bool
{
self.fill_ptr() > self.stack_sz
}
/// Create a new `AVec` with this backing buffer.
pub fn new(stack: &'a mut [MaybeUninit<T>]) -> Self
{
let (buf_ptr, stack_sz) = (stack.as_mut_ptr(), stack.len());
Self {
stack_sz,
inner: Internal {
stack: StackBuffer {
fill_ptr: 0,
buf_ptr,
}
},
_stack: PhantomData
}
}
}