1use serde::{Deserialize, Serialize};
2use serde_json::{json, Map, Value};
3use std::ops::{Deref, DerefMut};
4
5#[derive(Default, Clone)]
6pub struct Vars {
7 inner: Map<String, Value>,
8}
9
10pub struct Iter<'a> {
11 iter: serde_json::map::Iter<'a>,
12}
13
14pub struct IterMut<'a> {
15 iter: serde_json::map::IterMut<'a>,
16}
17
18impl Serialize for Vars {
19 fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
20 where
21 S: serde::Serializer,
22 {
23 self.inner.serialize(serializer)
24 }
25}
26
27impl<'de> Deserialize<'de> for Vars {
28 fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 core::result::Result::Ok(Self {
33 inner: serde_json::Map::deserialize(deserializer)?,
34 })
35 }
36}
37
38impl Deref for Vars {
39 type Target = Map<String, Value>;
40 fn deref(&self) -> &Self::Target {
41 &self.inner
42 }
43}
44
45impl DerefMut for Vars {
46 fn deref_mut(&mut self) -> &mut Self::Target {
47 &mut self.inner
48 }
49}
50
51impl FromIterator<(String, Value)> for Vars {
52 fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> Self {
53 Self {
54 inner: Map::from_iter(iter),
55 }
56 }
57}
58
59impl<'a> Iterator for Iter<'a> {
60 type Item = (&'a String, &'a Value);
61
62 fn next(&mut self) -> Option<Self::Item> {
63 self.iter.next()
64 }
65}
66
67impl<'a> Iterator for IterMut<'a> {
68 type Item = (&'a String, &'a mut Value);
69
70 fn next(&mut self) -> Option<Self::Item> {
71 self.iter.next()
72 }
73}
74
75impl<'a> IntoIterator for &'a mut Vars {
76 type Item = (&'a String, &'a mut Value);
77 type IntoIter = IterMut<'a>;
78 #[inline]
79 fn into_iter(self) -> Self::IntoIter {
80 IterMut {
81 iter: self.inner.iter_mut(),
82 }
83 }
84}
85
86impl IntoIterator for &Vars {
87 type Item = (String, Value);
88 type IntoIter = serde_json::map::IntoIter;
89 #[inline]
90 fn into_iter(self) -> Self::IntoIter {
91 self.inner.clone().into_iter()
92 }
93}
94
95impl std::fmt::Debug for Vars {
96 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
97 let text = serde_json::to_string(&self.inner).map_err(|_| std::fmt::Error)?;
98 f.write_str(&text)
99 }
100}
101
102impl std::fmt::Display for Vars {
103 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
104 let text = serde_json::to_string(&self.inner).map_err(|_| std::fmt::Error)?;
105 f.write_str(&text)
106 }
107}
108
109impl From<serde_json::Map<String, Value>> for Vars {
110 fn from(value: serde_json::Map<String, Value>) -> Self {
111 from_json(&value)
112 }
113}
114
115impl From<serde_json::Value> for Vars {
116 fn from(value: serde_json::Value) -> Self {
117 if let serde_json::Value::Object(map) = &value {
118 return from_json(map);
119 }
120 Vars::new()
121 }
122}
123
124impl From<Vars> for serde_json::Value {
125 fn from(val: Vars) -> Self {
126 serde_json::Value::Object(val.inner)
127 }
128}
129
130impl Vars {
131 pub fn new() -> Self {
132 Self { inner: Map::new() }
133 }
134
135 pub fn with<T>(self, name: &str, value: T) -> Self
136 where
137 T: Serialize,
138 {
139 let mut vars = self.inner;
140 vars.insert(name.to_string(), json!(value));
141
142 Self { inner: vars }
143 }
144
145 pub fn set<T>(&mut self, name: &str, value: T)
146 where
147 T: Serialize + Clone,
148 {
149 let value = json!(value);
150 self.inner
151 .entry(name.to_string())
152 .and_modify(|v| *v = value.clone())
153 .or_insert(value);
154 }
155
156 pub fn get<T>(&self, name: &str) -> Option<T>
157 where
158 T: for<'de> Deserialize<'de> + Clone,
159 {
160 if let Some(value) = self.inner.get(name) {
161 if let Ok(value) = serde_json::from_value::<T>(value.clone()) {
162 return Some(value);
163 }
164 }
165
166 None
167 }
168
169 pub fn get_value(&self, name: &str) -> Option<&Value> {
170 self.inner.get(name)
171 }
172
173 pub fn extend(mut self, vars: Vars) -> Self {
174 self.inner.extend(&vars);
175 self
176 }
177}
178
179#[allow(unused)]
180pub fn from_json(map: &serde_json::Map<String, serde_json::Value>) -> Vars {
181 let mut vars = Vars::new();
182
183 for (k, v) in map {
184 let value = match v {
185 serde_json::Value::Null => Value::Null,
186 serde_json::Value::Bool(v) => Value::Bool(*v),
187 serde_json::Value::Number(v) => from_json_number(v),
188 serde_json::Value::String(v) => Value::String(v.clone()),
189 serde_json::Value::Array(v) => from_json_array(v),
190 serde_json::Value::Object(v) => from_json_object(v),
191 };
192
193 vars.insert(k.to_string(), value);
194 }
195
196 vars
197}
198
199#[allow(unused)]
200fn from_json_array(arr: &Vec<serde_json::Value>) -> Value {
201 let mut ret = Vec::new();
202 for v in arr {
203 let value = match v {
204 serde_json::Value::Null => Value::Null,
205 serde_json::Value::Bool(v) => Value::Bool(*v),
206 serde_json::Value::Number(v) => from_json_number(v),
207 serde_json::Value::String(v) => Value::String(v.clone()),
208 serde_json::Value::Array(v) => from_json_array(v),
209 serde_json::Value::Object(v) => from_json_object(v),
210 };
211 ret.push(value);
212 }
213
214 Value::Array(ret)
215}
216
217#[allow(unused)]
218fn from_json_object(o: &serde_json::Map<String, serde_json::Value>) -> Value {
219 let mut map = serde_json::Map::new();
220 for (k, v) in o {
221 let value = match v {
222 serde_json::Value::Null => Value::Null,
223 serde_json::Value::Bool(v) => Value::Bool(*v),
224 serde_json::Value::Number(v) => from_json_number(v),
225 serde_json::Value::String(v) => Value::String(v.clone()),
226 serde_json::Value::Array(v) => from_json_array(v),
227 serde_json::Value::Object(v) => from_json_object(v),
228 };
229
230 map.insert(k.to_string(), value);
231 }
232
233 Value::Object(map)
234}
235
236#[allow(unused)]
237fn from_json_number(n: &serde_json::Number) -> Value {
238 if n.is_i64() {
239 Value::Number(serde_json::Number::from(n.as_i64().unwrap()))
240 } else if n.is_u64() {
241 return Value::Number(serde_json::Number::from(n.as_u64().unwrap()));
242 } else {
243 return Value::Number(serde_json::Number::from_f64(n.as_f64().unwrap()).unwrap());
244 }
245}