1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#![deny(rust_2018_idioms)]
#![deny(clippy::all)]

mod entity;
mod mapstorage;
mod no_such_entity;
mod register;
mod vecstorage;

pub use genesis_impl::*;

pub use entity::Entities;
pub use entity::Entity;
pub use mapstorage::MapStorage;
pub use no_such_entity::NoSuchEntity;
pub use register::Register;
pub use vecstorage::VecStorage;

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::{Arc, RwLock};

    #[derive(Debug, Clone, Copy, Eq, PartialEq)]
    struct VecTestData(i32);

    #[derive(Debug, Clone, Copy, Eq, PartialEq)]
    struct MapTestData(i32);

    struct World {
        pub entities: Arc<RwLock<Entities>>,
        pub vec: VecStorage<VecTestData>,
        pub map: MapStorage<MapTestData>,
    }

    impl World {
        pub fn new(capacity: u32) -> Self {
            let entities = Arc::new(RwLock::new(Entities::new(capacity)));
            let vec = VecStorage::new(Arc::clone(&entities), capacity);
            let map = MapStorage::new(Arc::clone(&entities));
            Self { entities, vec, map }
        }

        pub fn spawn(&mut self) -> Entity {
            self.entities.write().unwrap().spawn()
        }

        #[allow(unused)]
        pub fn despawn(&mut self, id: Entity) -> Result<(), NoSuchEntity> {
            let mut write = self.entities.write().unwrap();

            write.despawn(id)?;
            self.vec.remove_unchecked(id);
            self.map.remove_unchecked(id);

            Ok(())
        }
    }

    #[test]
    fn test_world() {
        let mut world = World::new(10);
        let first_id = world.spawn();
        let second_id = world.spawn();

        world.vec.set(first_id, VecTestData(1)).unwrap();
        world.vec.set(second_id, VecTestData(2)).unwrap();

        assert_eq!(world.vec.get(first_id), Some(&VecTestData(1)));

        let mut inc = 0;
        for id in world.entities.read().unwrap().iter() {
            inc += 1;
            assert_eq!(world.vec.get(id), Some(&VecTestData(inc)));
        }

        for id in world.entities.read().unwrap().iter() {
            world.vec.remove(id).unwrap();
        }
    }
}