rl_model/model/
skillset.rs

1use super::*;
2use crate::parser::{Position, RlError};
3use std::collections::HashMap;
4
5#[derive(Debug, Clone, Default)]
6pub struct Skillset {
7    name: String,
8    types: Vec<RlType>,
9    data: Vec<Data>,
10    resources: Vec<Resource>,
11    events: Vec<Event>,
12    skills: Vec<Skill>,
13    position: Option<Position>,
14}
15
16impl Skillset {
17    pub fn new<S: Into<String>>(name: S, position: Option<Position>) -> Self {
18        let name = name.into();
19        Self {
20            name,
21            types: Default::default(),
22            data: Default::default(),
23            resources: Default::default(),
24            events: Default::default(),
25            skills: Default::default(),
26            position,
27        }
28    }
29
30    pub fn name(&self) -> &str {
31        &self.name
32    }
33
34    pub fn position(&self) -> Option<Position> {
35        self.position.clone()
36    }
37
38    //---------- Type ----------
39
40    pub fn types(&self) -> &Vec<RlType> {
41        &self.types
42    }
43
44    pub fn add_type(&mut self, mut rl_type: RlType) -> TypeId {
45        let id = TypeId(self.types.len());
46        rl_type.set_id(id);
47        self.types.push(rl_type);
48        id
49    }
50
51    pub fn get_type(&self, id: TypeId) -> Option<&RlType> {
52        let TypeId(index) = id;
53        self.types.get(index)
54    }
55
56    pub fn type_map(&self) -> HashMap<String, TypeId> {
57        let mut map = HashMap::new();
58        for x in self.types.iter() {
59            map.insert(x.name().into(), x.id());
60        }
61        map
62    }
63
64    //---------- Data ----------
65
66    pub fn data(&self) -> &Vec<Data> {
67        &self.data
68    }
69
70    pub fn get_data(&self, id: DataId) -> Option<&Data> {
71        self.data.get(id.index())
72    }
73
74    pub fn add_data(&mut self, mut data: Data) -> DataId {
75        let id = DataId(self.data.len());
76        data.set_id(id);
77        self.data.push(data);
78        id
79    }
80
81    //---------- Resource ----------
82
83    pub fn resources(&self) -> &Vec<Resource> {
84        &self.resources
85    }
86
87    pub fn get_resource(&self, id: ResourceId) -> Option<&Resource> {
88        self.resources.get(id.index())
89    }
90
91    pub fn add_resource(&mut self, mut resource: Resource) -> ResourceId {
92        let id = ResourceId(self.resources.len());
93        resource.set_id(id);
94        self.resources.push(resource);
95        id
96    }
97
98    pub fn resource_map(&self) -> HashMap<String, ResourceId> {
99        let mut map = HashMap::new();
100        for x in self.resources.iter() {
101            map.insert(x.name().into(), x.id());
102        }
103        map
104    }
105
106    //---------- State ----------
107
108    pub fn get_state(&self, id: StateId) -> Option<&State> {
109        let resource = self.get_resource(id.resource())?;
110        resource.get_state(id)
111    }
112
113    pub fn state_map(&self) -> HashMap<String, StateId> {
114        let mut map = HashMap::new();
115        for x in self.resources.iter() {
116            for y in x.states().iter() {
117                map.insert(y.name().into(), y.id());
118            }
119        }
120        map
121    }
122
123    //---------- Event ----------
124
125    pub fn events(&self) -> &Vec<Event> {
126        &self.events
127    }
128
129    pub fn get_event(&self, id: EventId) -> Option<&Event> {
130        self.events.get(id.index())
131    }
132
133    pub fn add_event(&mut self, mut event: Event) -> EventId {
134        let id = EventId(self.events.len());
135        event.set_id(id);
136        self.events.push(event);
137        id
138    }
139
140    //---------- Skill ----------
141
142    pub fn skills(&self) -> &Vec<Skill> {
143        &self.skills
144    }
145
146    pub fn get_skill(&self, id: SkillId) -> Option<&Skill> {
147        self.skills.get(id.index())
148    }
149
150    pub fn add_skill(&mut self, mut skill: Skill) -> SkillId {
151        let id = SkillId(self.skills.len());
152        skill.set_id(id);
153        self.skills.push(skill);
154        id
155    }
156
157    //---------- Duplicate ----------
158
159    pub fn type_naming(&self) -> Vec<Naming> {
160        self.types.iter().map(|x| x.naming()).collect()
161    }
162
163    pub fn data_naming(&self) -> Vec<Naming> {
164        self.data.iter().map(|x| x.naming()).collect()
165    }
166    pub fn resource_naming(&self) -> Vec<Naming> {
167        let mut v = Vec::new();
168        for x in self.resources.iter() {
169            v.push((x.name().into(), x.position()));
170            v.extend(x.names());
171        }
172        v
173    }
174    pub fn event_naming(&self) -> Vec<Naming> {
175        self.events.iter().map(|x| x.naming()).collect()
176    }
177    pub fn skill_naming(&self) -> Vec<Naming> {
178        self.skills.iter().map(|x| x.naming()).collect()
179    }
180
181    pub fn duplicate(&self) -> Result<(), RlError> {
182        let types = self.type_naming();
183
184        // Data
185        check_duplicate(
186            types
187                .clone()
188                .into_iter()
189                .chain(self.data_naming().into_iter())
190                .collect(),
191        )?;
192        // Resource
193        check_duplicate(
194            types
195                .clone()
196                .into_iter()
197                .chain(self.resource_naming().into_iter())
198                .collect(),
199        )?;
200        // Event
201        check_duplicate(
202            types
203                .clone()
204                .into_iter()
205                .chain(self.event_naming().into_iter())
206                .collect(),
207        )?;
208        // Skill
209        check_duplicate(
210            types
211                .clone()
212                .into_iter()
213                .chain(self.skill_naming().into_iter())
214                .collect(),
215        )?;
216
217        // Skill
218        for x in self.skills.iter() {
219            x.duplicate(self)?;
220        }
221
222        Ok(())
223    }
224
225    //---------- Resolve ----------
226
227    pub fn resolve(&mut self) -> Result<(), RlError> {
228        self.resolve_type()?;
229        self.resolve_resource()?;
230        self.resolve_state()
231    }
232
233    pub fn resolve_type(&mut self) -> Result<(), RlError> {
234        let map = self.type_map();
235        // Data
236        for x in self.data.iter_mut() {
237            x.resolve_type(&map)?;
238        }
239        // Skill
240        for x in self.skills.iter_mut() {
241            x.resolve_type(&map)?;
242        }
243        Ok(())
244    }
245
246    pub fn resolve_resource(&mut self) -> Result<(), RlError> {
247        let map = self.resource_map();
248        // Event
249        for x in self.events.iter_mut() {
250            x.resolve_resource(&map)?;
251        }
252        // Skill
253        for x in self.skills.iter_mut() {
254            x.resolve_resource(&map)?;
255        }
256        Ok(())
257    }
258
259    pub fn resolve_state(&mut self) -> Result<(), RlError> {
260        // Resource
261        for x in self.resources.iter_mut() {
262            x.resolve_state()?;
263        }
264        // Event
265        let map = self.state_map();
266        for x in self.events.iter_mut() {
267            x.resolve_state(&map)?;
268        }
269        // Skill
270        let map = self.state_map();
271        for x in self.skills.iter_mut() {
272            x.resolve_state(&map)?;
273        }
274        Ok(())
275    }
276}
277
278//------------------------- Get From Id -------------------------
279
280impl GetFromId<TypeId, RlType> for Skillset {
281    fn get(&self, id: TypeId) -> Option<&RlType> {
282        self.get_type(id)
283    }
284}
285
286impl GetFromId<DataId, Data> for Skillset {
287    fn get(&self, id: DataId) -> Option<&Data> {
288        self.get_data(id)
289    }
290}
291impl GetFromId<ResourceId, Resource> for Skillset {
292    fn get(&self, id: ResourceId) -> Option<&Resource> {
293        self.get_resource(id)
294    }
295}
296impl GetFromId<StateId, State> for Skillset {
297    fn get(&self, id: StateId) -> Option<&State> {
298        self.get_state(id)
299    }
300}
301impl GetFromId<EventId, Event> for Skillset {
302    fn get(&self, id: EventId) -> Option<&Event> {
303        self.get_event(id)
304    }
305}
306impl GetFromId<SkillId, Skill> for Skillset {
307    fn get(&self, id: SkillId) -> Option<&Skill> {
308        self.get_skill(id)
309    }
310}
311impl GetFromId<PreconditionId, Precondition> for Skillset {
312    fn get(&self, id: PreconditionId) -> Option<&Precondition> {
313        let skill = self.get(id.skill())?;
314        skill.get(id)
315    }
316}
317impl GetFromId<InvariantId, Invariant> for Skillset {
318    fn get(&self, id: InvariantId) -> Option<&Invariant> {
319        let skill = self.get(id.skill())?;
320        skill.get(id)
321    }
322}
323impl GetFromId<SuccessId, Success> for Skillset {
324    fn get(&self, id: SuccessId) -> Option<&Success> {
325        let skill = self.get(id.skill())?;
326        skill.get(id)
327    }
328}
329impl GetFromId<FailureId, Failure> for Skillset {
330    fn get(&self, id: FailureId) -> Option<&Failure> {
331        let skill = self.get(id.skill())?;
332        skill.get(id)
333    }
334}
335
336//------------------------- Display -------------------------
337
338impl std::fmt::Display for Skillset {
339    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
340        write!(f, "skillset {}", self.name)?;
341        // Types
342        if let Some((first, others)) = self.types.split_first() {
343            write!(f, "<{}", first.name())?;
344            for t in others {
345                write!(f, ", {}", t.name())?;
346            }
347            write!(f, ">")?;
348        }
349        write!(f, " {{\n")?;
350        // Data
351        if !self.data.is_empty() {
352            write!(f, "\tdata {{\n")?;
353            for x in self.data.iter() {
354                write!(f, "\t\t{}", &x.to_lang(self))?;
355            }
356            write!(f, "\t}}\n")?;
357        }
358        // Resource
359        if !self.resources.is_empty() {
360            write!(f, "\tresource {{\n")?;
361            for x in self.resources.iter() {
362                write!(f, "{}", x.to_lang(self))?;
363            }
364            write!(f, "\t}}\n")?;
365        }
366        // Event
367        if !self.events.is_empty() {
368            write!(f, "\tevent {{\n")?;
369            for x in self.events.iter() {
370                write!(f, "{}", x.to_lang(self))?;
371            }
372            write!(f, "\t}}\n")?;
373        }
374        // Skill
375        if !self.skills.is_empty() {
376            write!(f, "\tskill {{\n")?;
377            for x in self.skills.iter() {
378                write!(f, "{}", x.to_lang(self))?;
379            }
380            write!(f, "\t}}\n")?;
381        }
382        //
383        write!(f, "}}\n")?;
384        //
385        Ok(())
386    }
387}
rl_model/model/skillset.rs

rl_model/model/
skillset.rs
