173 lines
3.6 KiB
Rust
173 lines
3.6 KiB
Rust
#[macro_export]
|
|
macro_rules! gen_id {
|
|
(
|
|
$container_name:ident,
|
|
$instance_name:ident,
|
|
$cell_name:ident,
|
|
$handle_name:ident) => {
|
|
//ThingCell
|
|
#[derive(Debug)]
|
|
pub struct $cell_name {
|
|
pub obj: $instance_name,
|
|
pub generation: u64,
|
|
}
|
|
|
|
//ThingVec
|
|
#[derive(Debug)]
|
|
pub struct $container_name {
|
|
// Vec<Option<ThingCell>>
|
|
pub vec: Vec<Option<$cell_name>>,
|
|
|
|
cur_generation: u64,
|
|
}
|
|
|
|
//ThingHandle
|
|
#[derive(Default, Debug, Clone, Copy, PartialEq, Hash, Eq)]
|
|
pub struct $handle_name {
|
|
idx: u32,
|
|
generation: u64,
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
impl $handle_name {
|
|
pub const fn reset(&mut self) {
|
|
self.generation = 0;
|
|
}
|
|
|
|
pub const fn is_set(&self) -> bool {
|
|
self.generation > 0
|
|
}
|
|
|
|
pub const fn id(&self) -> u32 {
|
|
self.idx
|
|
}
|
|
|
|
pub const fn new(idx: u32, generation: u64) -> Self {
|
|
Self { idx, generation }
|
|
}
|
|
}
|
|
|
|
//ThingVec
|
|
impl $container_name {
|
|
#[allow(clippy::new_without_default)]
|
|
pub const fn new() -> Self {
|
|
Self {
|
|
vec: Vec::new(),
|
|
cur_generation: 0,
|
|
}
|
|
}
|
|
|
|
pub fn iter(&self) -> impl Iterator<Item = ($handle_name, &$instance_name)> {
|
|
self.vec.iter().enumerate().filter_map(|(idx, opt_cell)| {
|
|
opt_cell.as_ref().map(|cell| {
|
|
let handle = $container_name::get_handle(&cell, idx);
|
|
(handle, &cell.obj)
|
|
})
|
|
})
|
|
}
|
|
|
|
pub fn iter_mut(&mut self) -> impl Iterator<Item = ($handle_name, &mut $instance_name)> {
|
|
self.vec.iter_mut().enumerate().filter_map(|(idx, opt_cell)| {
|
|
opt_cell.as_mut().map(|cell| {
|
|
let handle = $container_name::get_handle(&cell, idx);
|
|
(handle, &mut cell.obj)
|
|
})
|
|
})
|
|
}
|
|
|
|
pub const fn get_handle(cell: &$cell_name, idx: usize) -> $handle_name {
|
|
$handle_name {
|
|
idx: idx as u32,
|
|
generation: cell.generation,
|
|
}
|
|
}
|
|
|
|
fn find_unused_idx(&mut self) -> Option<u32> {
|
|
for (num, obj) in self.vec.iter().enumerate() {
|
|
if obj.is_none() {
|
|
return Some(num as u32);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub fn add(&mut self, obj: $instance_name) -> $handle_name {
|
|
self.cur_generation += 1;
|
|
let generation = self.cur_generation;
|
|
|
|
let unused_idx = self.find_unused_idx();
|
|
|
|
let idx = if let Some(idx) = unused_idx {
|
|
idx
|
|
} else {
|
|
self.vec.len() as u32
|
|
};
|
|
|
|
let handle = $handle_name { idx, generation };
|
|
|
|
let cell = $cell_name { obj, generation };
|
|
|
|
if let Some(idx) = unused_idx {
|
|
self.vec[idx as usize] = Some(cell);
|
|
} else {
|
|
self.vec.push(Some(cell))
|
|
}
|
|
|
|
handle
|
|
}
|
|
|
|
pub fn remove(&mut self, handle: &$handle_name) {
|
|
// Out of bounds, ignore
|
|
if handle.idx as usize >= self.vec.len() {
|
|
return;
|
|
}
|
|
|
|
// Remove only if the generation matches
|
|
if let Some(cell) = &self.vec[handle.idx as usize] {
|
|
if cell.generation == handle.generation {
|
|
self.vec[handle.idx as usize] = None;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get(&self, handle: &$handle_name) -> Option<&$instance_name> {
|
|
// Out of bounds, ignore
|
|
if handle.idx as usize >= self.vec.len() {
|
|
return None;
|
|
}
|
|
|
|
if let Some(cell) = &self.vec[handle.idx as usize] {
|
|
if cell.generation == handle.generation {
|
|
return Some(&cell.obj);
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub fn get_mut(&mut self, handle: &$handle_name) -> Option<&mut $instance_name> {
|
|
// Out of bounds, ignore
|
|
if handle.idx as usize >= self.vec.len() {
|
|
return None;
|
|
}
|
|
|
|
if let Some(cell) = &mut self.vec[handle.idx as usize] {
|
|
if cell.generation == handle.generation {
|
|
return Some(&mut cell.obj);
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/* Example usage:
|
|
gen_id!(ThingVec, ThingInstance, ThingCell, ThingHandle);
|
|
|
|
struct ThingInstance {}
|
|
|
|
impl ThingInstance {}
|
|
*/
|