specs 0.20.0

Specs is an Entity-Component-System library written in Rust.
Documentation 
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use hibitset::BitSet;

#[nougat::gat(Type)]
use crate::join::LendJoin;
use crate::{
    join::{Join, RepeatableLendGet},
    storage::MaskedStorage,
    world::{Component, Index},
};

/// A draining storage wrapper which has a `Join` implementation
/// that removes the components.
pub struct Drain<'a, T: Component> {
    /// The masked storage
    pub data: &'a mut MaskedStorage<T>,
}

// SAFETY: Calling `get` is always safe! Iterating the mask does not repeat
// indices.
#[nougat::gat]
unsafe impl<'a, T> LendJoin for Drain<'a, T>
where
    T: Component,
{
    type Mask = BitSet;
    type Type<'next> = T;
    type Value = &'a mut MaskedStorage<T>;

    unsafe fn open(self) -> (Self::Mask, Self::Value) {
        // TODO: Cloning the whole bitset here seems expensive, and it is
        // hidden from the user, but there is no obvious way to restructure
        // things to avoid this with the way that bitsets are composed together
        // for iteration.
        let mask = self.data.mask.clone();

        (mask, self.data)
    }

    unsafe fn get<'next>(value: &'next mut Self::Value, id: Index) -> T {
        value.remove(id).expect("Tried to access same index twice")
    }
}

// SAFETY: Calling `get` is always safe!
unsafe impl<'a, T> RepeatableLendGet for Drain<'a, T> where T: Component {}

// SAFETY: Calling `get` is always safe! Iterating the mask does not repeat
// indices.
unsafe impl<'a, T> Join for Drain<'a, T>
where
    T: Component,
{
    type Mask = BitSet;
    type Type = T;
    type Value = &'a mut MaskedStorage<T>;

    unsafe fn open(self) -> (Self::Mask, Self::Value) {
        // TODO: Cloning the whole bitset here seems expensive, and it is
        // hidden from the user, but there is no obvious way to restructure
        // things to avoid this with the way that bitsets are composed together
        // for iteration.
        let mask = self.data.mask.clone();

        (mask, self.data)
    }

    unsafe fn get(value: &mut Self::Value, id: Index) -> T {
        value.remove(id).expect("Tried to access same index twice")
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn basic_drain() {
        use crate::{
            join::Join,
            storage::DenseVecStorage,
            world::{Builder, Component, World, WorldExt},
        };

        #[derive(Debug, PartialEq)]
        struct Comp;

        impl Component for Comp {
            type Storage = DenseVecStorage<Self>;
        }

        let mut world = World::new();
        world.register::<Comp>();

        world.create_entity().build();
        let b = world.create_entity().with(Comp).build();
        let c = world.create_entity().with(Comp).build();
        world.create_entity().build();
        let e = world.create_entity().with(Comp).build();

        let mut comps = world.write_storage::<Comp>();
        let entities = world.entities();

        {
            let mut iter = (comps.drain(), &entities).join();

            assert_eq!(iter.next().unwrap(), (Comp, b));
            assert_eq!(iter.next().unwrap(), (Comp, c));
            assert_eq!(iter.next().unwrap(), (Comp, e));
        }

        assert_eq!((&comps).join().count(), 0);
    }
}