specs 0.17.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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#[cfg(feature = "serde")]
#[macro_use]
extern crate serde;
// Specs is renamed here so that the custom derive cannot refer specs directly
#[cfg(feature = "serde")]
extern crate specs as spocs;

#[cfg(feature = "serde")]
#[macro_use]
extern crate specs_derive;

#[cfg(feature = "serde")]
mod tests {
    #[cfg(feature = "uuid_entity")]
    use spocs::saveload::UuidMarker;
    use spocs::{
        saveload::{ConvertSaveload, Marker, SimpleMarker},
        Builder, Entity, World, WorldExt,
    };

    #[derive(ConvertSaveload)]
    struct OneFieldNamed {
        e: Entity,
    }

    #[derive(ConvertSaveload)]
    struct TwoField {
        a: u32,
        e: Entity,
    }

    // Tests a struct that owns a parent
    // that derives Saveload
    #[derive(ConvertSaveload)]
    struct LevelTwo {
        owner: OneFieldNamed,
    }

    #[derive(ConvertSaveload)]
    struct OneFieldTuple(Entity);

    #[derive(ConvertSaveload)]
    struct TwoFieldTuple(Entity, u32);

    #[derive(ConvertSaveload)]
    struct LevelTwoTuple(OneFieldNamed);

    #[derive(ConvertSaveload)]
    enum AnEnum {
        E(Entity),
        F { e: Entity },
        Unit,
    }

    #[derive(Serialize, Deserialize, Clone)]
    struct TupleSerdeType(u32);

    #[derive(Clone)]
    struct UnserializableType {
        inner: u32
    }

    impl Default for UnserializableType {
        fn default() -> Self {
            Self {
                inner: 0
            }
        }
    }

    #[derive(Serialize, Deserialize, Clone)]
    struct ComplexSerdeType {
        #[serde(skip, default)]
        opaque: UnserializableType
    }

    #[derive(ConvertSaveload)]
    struct ComplexSerdeMixedType {
        #[convert_save_load_skip_convert]
        #[convert_save_load_attr(serde(skip, default))]
        opaque: UnserializableType,
        other: u32
    }

    #[derive(ConvertSaveload)]
    pub struct NamedContainsSerdeType {
        e: Entity,
        a: ComplexSerdeType,
        b: ComplexSerdeMixedType,
    }

    #[derive(ConvertSaveload)]
    struct TupleContainsSerdeType(Entity, ComplexSerdeMixedType);

    #[derive(ConvertSaveload)]
    enum NamedEnumContainsSerdeType {
        A(Entity),
        B { inner_baz: NamedContainsSerdeType }
    }

    #[derive(ConvertSaveload)]
    enum UnnamedEnumContainsSerdeType {
        A(Entity),
        B(NamedContainsSerdeType)
    }

    #[derive(ConvertSaveload)]
    struct Generic<E: EntityLike>(E);

    trait EntityLike {}

    impl EntityLike for Entity {}

    struct NetworkSync;

    #[test]
    fn type_check() {
        let mut world = World::new();
        let entity = world.create_entity().build();
        type_check_internal::<SimpleMarker<NetworkSync>>(entity);
        #[cfg(feature = "uuid_entity")]
        type_check_internal::<UuidMarker>(entity);
    }

    fn type_check_internal<M: Marker>(entity: Entity) {
        black_box::<M, _>(OneFieldNamed { e: entity });
        black_box::<M, _>(TwoField { a: 5, e: entity });
        black_box::<M, _>(LevelTwo {
            owner: OneFieldNamed { e: entity },
        });
        black_box::<M, _>(OneFieldTuple(entity));
        black_box::<M, _>(TwoFieldTuple(entity, 5));
        black_box::<M, _>(TupleSerdeType(5));
        black_box::<M, _>(NamedContainsSerdeType{ e: entity, a: ComplexSerdeType { opaque: UnserializableType::default() }, b: ComplexSerdeMixedType { opaque: UnserializableType::default(), other: 5 } });
        black_box::<M, _>(TupleContainsSerdeType(entity, ComplexSerdeMixedType { opaque: UnserializableType::default(), other: 5 } ));
        black_box::<M, _>(NamedEnumContainsSerdeType::A(entity));
        black_box::<M, _>(UnnamedEnumContainsSerdeType::A(entity));
        // The derive will work for all variants
        // so no need to test anything but unit
        black_box::<M, _>(AnEnum::Unit);
        black_box::<M, _>(Generic(entity));
    }

    fn black_box<M, T: ConvertSaveload<M>>(_item: T) {}
}