use std::{
alloc, mem,
ptr::{self, NonNull},
};
#[derive(Debug)]
pub(crate) struct Track<T> {
value: T,
}
impl<T> Track<T> {
pub(crate) fn new(value: T) -> Track<T> {
Track { value }
}
pub(crate) fn get_mut(&mut self) -> &mut T {
&mut self.value
}
pub(crate) fn into_inner(self) -> T {
self.value
}
}
pub struct VecAllocation<'a, T: 'a> {
vec: &'a mut Vec<T>,
index: usize,
}
impl<'a, T> VecAllocation<'a, T> {
#[inline(always)]
pub fn init(self, value: T) -> usize {
unsafe {
ptr::write(self.vec.as_mut_ptr().add(self.index), value);
self.vec.set_len(self.index + 1);
}
self.index
}
}
pub enum VecEntry<'a, T: 'a> {
Vacant(VecAllocation<'a, T>),
Occupied(&'a mut T),
}
impl<'a, T> VecEntry<'a, T> {
#[inline(always)]
pub fn set(self, value: T) {
match self {
VecEntry::Vacant(alloc) => { alloc.init(value); }
VecEntry::Occupied(slot) => { *slot = value; }
}
}
}
pub trait VecHelper<T> {
fn alloc(&mut self) -> VecAllocation<T>;
fn entry(&mut self, index: usize) -> VecEntry<T>;
}
impl<T> VecHelper<T> for Vec<T> {
fn alloc(&mut self) -> VecAllocation<T> {
let index = self.len();
if self.capacity() == index {
self.reserve(1);
}
VecAllocation {
vec: self,
index,
}
}
fn entry(&mut self, index: usize) -> VecEntry<T> {
if index < self.len() {
VecEntry::Occupied(unsafe {
self.get_unchecked_mut(index)
})
} else {
assert_eq!(index, self.len());
VecEntry::Vacant(self.alloc())
}
}
}
pub struct BoxAllocation<T>(
NonNull<T>,
);
impl<T> BoxAllocation<T> {
#[inline(always)] pub fn init(self, value: T) -> Box<T> {
if mem::size_of::<T>() == 0 {
return Box::new(value);
}
unsafe {
let ptr = self.0.as_ptr();
mem::forget(self);
ptr::write(ptr, value);
Box::from_raw(ptr)
}
}
}
impl<T> Drop for BoxAllocation<T> {
fn drop(&mut self) {
if mem::size_of::<T>() == 0 {
return;
}
let layout = alloc::Layout::new::<T>();
unsafe {
alloc::dealloc(self.0.as_ptr() as *mut u8, layout);
}
}
}
pub trait BoxHelper<T> {
fn alloc() -> BoxAllocation<T>;
}
impl<T> BoxHelper<T> for Box<T> {
fn alloc() -> BoxAllocation<T> {
if mem::size_of::<T>() == 0 {
return BoxAllocation(NonNull::dangling());
}
let layout = alloc::Layout::new::<T>();
BoxAllocation(
NonNull::new(unsafe { alloc::alloc(layout) as *mut T })
.unwrap_or_else(|| alloc::handle_alloc_error(layout)), )
}
}