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
|
use std::collections::HashMap;
use serde::{Serialize, Deserialize};
use crate::{
parameter::Parameter,
};
#[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
pub struct EntityType(pub String);
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
enum TemplateSave {
Name(EntityType),
Full{
#[serde(rename = "type")]
name: EntityType,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
args: Vec<Parameter>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
kwargs: HashMap<String, Parameter>,
#[serde(default, skip_serializing_if = "Option::is_none")]
save: Option<bool>
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(from="TemplateSave", into="TemplateSave")]
pub struct Template {
pub name: EntityType,
pub args: Vec<Parameter>,
pub kwargs: HashMap<String, Parameter>,
pub save: Option<bool>,
}
impl From<TemplateSave> for Template {
fn from(ts: TemplateSave) -> Self {
match ts {
TemplateSave::Name(name) => Self{name, args: Vec::new(), kwargs: HashMap::new(), save: None},
TemplateSave::Full{name, args, kwargs, save} => Self{name, args, kwargs, save}
}
}
}
impl Into<TemplateSave> for Template {
fn into(self) -> TemplateSave {
if self.args.is_empty() && self.kwargs.is_empty() && self.save == None {
return TemplateSave::Name(self.name);
}
TemplateSave::Full {
name: self.name,
args: self.args,
kwargs: self.kwargs,
save: self.save
}
}
}
impl Template {
pub fn new(name: &str, kwargs: HashMap<String, Parameter>) -> Self {
Self {
name: EntityType(name.to_string()),
args: Vec::new(),
kwargs,
save: None
}
}
pub fn empty(name: &str) -> Self {
Self::new(name, HashMap::new())
}
pub fn should_save(&self) -> bool {
match self.save {
None | Some(true) => true,
Some(false) => false
}
}
pub fn from_entity_type(typ: EntityType) -> Self {
Self {
name: typ,
args: Vec::new(),
kwargs: HashMap::new(),
save: None
}
}
pub fn unsaved(mut self) -> Self {
if self.save == None {
self.save = Some(false)
}
self
}
pub fn merge(mut self, other: Template) -> Self {
if self.save == None {
self.save = other.save;
}
for (key, value) in other.kwargs {
self.kwargs.entry(key).or_insert(value);
}
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::hashmap;
use serde_json::json;
#[test]
fn template_from_string(){
assert_eq!(Template::deserialize(json!("grass")).unwrap(), Template::empty("grass"));
}
#[test]
fn template_with_kwarg(){
assert_eq!(
Template::deserialize(json!({"type": "wall", "kwargs": {"health": 50}})).unwrap(),
Template::new("wall", hashmap!{"health".to_string() => Parameter::Int(50)})
);
}
}
|
