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