#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct SlotId {
    idx: u32,
    genr: u32,
}

pub struct SlotVec<T> {
    data: Vec<(u32, Option<T>)>,
    free: Vec<u32>,
}

impl<T> SlotVec<T> {
    pub fn new() -> Self {
        Self {
            data: Default::default(),
            free: Default::default(),
        }
    }

    pub fn add(&mut self, x: T) -> SlotId {
        if let Some(idx) = self.free.pop() {
            let (genr, data) = &mut self.data[idx as usize];
            *data = Some(x);
            SlotId { idx, genr: *genr }
        } else {
            let idx = self.data.len() as u32;
            let genr = 0;
            self.data.push((genr, Some(x)));
            SlotId { idx, genr }
        }
    }

    pub fn free(&mut self, id: SlotId) {
        let (genr, data) = &mut self.data[id.idx as usize];
        *genr += 1;
        *data = None;
        self.free.push(id.idx);
    }

    pub fn get(&self, id: SlotId) -> Option<&T> {
        let slot = &self.data[id.idx as usize];
        if slot.0 != id.genr {
            return None;
        }
        slot.1.as_ref()
    }

    pub fn get_mut(&mut self, id: SlotId) -> Option<&mut T> {
        let slot = &mut self.data[id.idx as usize];
        if slot.0 != id.genr {
            return None;
        }
        slot.1.as_mut()
    }

    pub fn len(&self) -> usize {
        self.data.len() - self.free.len()
    }

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

impl<T> Default for SlotVec<T> {
    fn default() -> Self {
        Self::new()
    }
}