use core::{
    mem::MaybeUninit,
    ptr,
};

#[derive(Debug)]
pub struct OutOfSpace;

pub struct BoxVec<T> {
    boxed: Box<[MaybeUninit<T>]>,
    len: usize
}

impl <T> BoxVec<T> {
    pub fn new(size: usize) -> Self {
        let mut boxed = (0..size).map(|_| MaybeUninit::uninit()).collect();

        Self {
            boxed,
            len: 0,
        }
    }

    pub fn push(&mut self, elem: T) {
        self.try_push(elem).unwrap()
    }

    pub fn try_push(&mut self, elem: T) -> Result<(), OutOfSpace> {
        if self.len < self.boxed.len() {
            unsafe {
                self.unchecked_push(elem);
                Ok(())
            }
        } else {
            Err(OutOfSpace)
        }
    }

    pub unsafe fn unchecked_push(&mut self, elem: T) {
        let mut uninit_elem = &mut self.boxed[self.len];
        ptr::write(uninit_elem.as_mut_ptr(), elem);
    }
}