1use crate::{ToWolfram, WolframError, WolframFunction, WolframRule, WolframValue};
2use serde::{
3 ser::{
4 Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
5 },
6 Serialize, Serializer,
7};
8use std::{collections::BTreeMap, fmt::Display, mem::take};
9
10#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
12pub struct WolframSerializer {}
13
14impl Default for WolframSerializer {
15 fn default() -> Self {
16 Self {}
17 }
18}
19
20impl Error for WolframError {
21 fn custom<T: Display>(_msg: T) -> Self {
22 todo!()
23 }
24}
25
26#[derive(Clone, Debug, PartialEq, Eq)]
27pub struct SerializerAsList<'i> {
28 body: Vec<WolframValue>,
29 config: &'i WolframSerializer,
30}
31
32#[derive(Clone, Debug, PartialEq, Eq)]
33pub struct SerializerAsAssociation<'i> {
34 key: WolframValue,
35 body: BTreeMap<WolframValue, (WolframRule, WolframValue)>,
36 config: &'i WolframSerializer,
37}
38
39#[derive(Clone, Debug, PartialEq, Eq)]
40pub struct SerializeAsFunction<'i> {
41 name_space: &'static str,
42 name: &'static str,
43 body: Vec<WolframValue>,
44 config: &'i WolframSerializer,
45}
46
47impl<'i> Serializer for &'i WolframSerializer {
48 type Ok = WolframValue;
49 type Error = WolframError;
50 type SerializeSeq = SerializerAsList<'i>;
51 type SerializeTuple = SerializerAsList<'i>;
52 type SerializeTupleStruct = SerializeAsFunction<'i>;
53 type SerializeTupleVariant = SerializeAsFunction<'i>;
54 type SerializeMap = SerializerAsAssociation<'i>;
55 type SerializeStruct = SerializeAsFunction<'i>;
56 type SerializeStructVariant = SerializeAsFunction<'i>;
57
58 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
59 Ok(WolframValue::Boolean(v))
60 }
61
62 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
63 Ok(WolframValue::Integer8(v))
64 }
65
66 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
67 Ok(WolframValue::Integer16(v))
68 }
69
70 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
71 Ok(WolframValue::Integer32(v))
72 }
73
74 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
75 Ok(WolframValue::Integer64(v))
76 }
77
78 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
79 if v > 127 { Ok(WolframValue::Integer16(v as i16)) } else { Ok(WolframValue::Integer8(v as i8)) }
80 }
81
82 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
83 if v > 32767 { Ok(WolframValue::Integer32(v as i32)) } else { Ok(WolframValue::Integer16(v as i16)) }
84 }
85
86 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
87 if v > 2147483647 { Ok(WolframValue::Integer64(v as i64)) } else { Ok(WolframValue::Integer32(v as i32)) }
88 }
89
90 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
91 if v > 9223372036854775807 { Ok(WolframValue::Integer64(v as i64)) } else { Ok(WolframValue::integer(v)) }
92 }
93
94 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
95 Ok(WolframValue::from(v))
96 }
97
98 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
99 Ok(WolframValue::from(v))
100 }
101
102 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
103 Ok(WolframValue::String(v.to_string()))
104 }
105
106 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
107 Ok(WolframValue::String(v.to_string()))
108 }
109
110 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
111 Ok(WolframValue::Bytes(v.to_vec()))
112 }
113
114 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
115 Ok(WolframValue::system_symbol("None"))
116 }
117
118 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
119 where
120 T: Serialize,
121 {
122 value.serialize(self)
123 }
124
125 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
126 todo!()
127 }
128
129 fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
130 Ok(WolframFunction::global(name, vec![]).to_wolfram())
131 }
132
133 fn serialize_unit_variant(self, name: &'static str, _: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
134 Ok(WolframFunction::namespace(name, variant, vec![]).to_wolfram())
135 }
136
137 fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
138 where
139 T: Serialize,
140 {
141 let value = value.serialize(self)?;
142 Ok(WolframFunction::global(name, vec![value]).to_wolfram())
143 }
144
145 fn serialize_newtype_variant<T: ?Sized>(self, name: &'static str, _: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
146 where
147 T: Serialize,
148 {
149 let value = value.serialize(self)?;
150 Ok(WolframFunction::namespace(name, variant, vec![value]).to_wolfram())
151 }
152
153 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
154 Ok(SerializerAsList { body: Vec::with_capacity(len.unwrap_or(0)), config: self })
155 }
156
157 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
158 Ok(SerializerAsList { body: Vec::with_capacity(len), config: self })
159 }
160
161 fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
162 Ok(SerializeAsFunction { name_space: "", name, body: Vec::with_capacity(len), config: self })
163 }
164
165 fn serialize_tuple_variant(
166 self,
167 name: &'static str,
168 _: u32,
169 variant: &'static str,
170 n: usize,
171 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
172 Ok(SerializeAsFunction { name_space: name, name: variant, body: Vec::with_capacity(n), config: self })
173 }
174
175 fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
176 Ok(SerializerAsAssociation { key: WolframValue::Skip, body: BTreeMap::default(), config: self })
177 }
178
179 fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
180 Ok(SerializeAsFunction { name_space: "", name, body: Vec::with_capacity(len), config: self })
181 }
182
183 fn serialize_struct_variant(
184 self,
185 name: &'static str,
186 _: u32,
187 variant: &'static str,
188 n: usize,
189 ) -> Result<Self::SerializeStructVariant, Self::Error> {
190 Ok(SerializeAsFunction { name_space: name, name: variant, body: Vec::with_capacity(n), config: self })
191 }
192 fn is_human_readable(&self) -> bool {
193 false
194 }
195 fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
196 Ok(WolframValue::integer(v))
197 }
198 fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
199 Ok(WolframValue::integer(v))
200 }
201}
202
203impl<'i> SerializeTuple for SerializerAsList<'i> {
204 type Ok = WolframValue;
205 type Error = WolframError;
206
207 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
208 where
209 T: Serialize,
210 {
211 let item = value.serialize(self.config)?;
212 self.body.push(item);
213 Ok(())
214 }
215
216 fn end(self) -> Result<Self::Ok, Self::Error> {
217 Ok(WolframValue::list(self.body))
218 }
219}
220impl<'i> SerializeSeq for SerializerAsList<'i> {
221 type Ok = WolframValue;
222 type Error = WolframError;
223
224 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
225 where
226 T: Serialize,
227 {
228 SerializeTuple::serialize_element(self, value)
229 }
230
231 fn end(self) -> Result<Self::Ok, Self::Error> {
232 SerializeTuple::end(self)
233 }
234}
235
236impl<'i> SerializeMap for SerializerAsAssociation<'i> {
237 type Ok = WolframValue;
238 type Error = WolframError;
239
240 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
241 where
242 T: Serialize,
243 {
244 let item = key.serialize(self.config)?;
245 self.key = item;
246 Ok(())
247 }
248
249 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
250 where
251 T: Serialize,
252 {
253 let key = take(&mut self.key);
254 let item = value.serialize(self.config)?;
255 self.body.insert(key, (WolframRule::Rule, item));
256 Ok(())
257 }
258
259 fn end(self) -> Result<Self::Ok, Self::Error> {
260 Ok(WolframValue::Association(self.body))
261 }
262}
263
264impl<'i> SerializeTupleStruct for SerializeAsFunction<'i> {
265 type Ok = WolframValue;
266 type Error = WolframError;
267
268 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
269 where
270 T: Serialize,
271 {
272 let item = value.serialize(self.config)?;
273 self.body.push(item);
274 Ok(())
275 }
276
277 fn end(self) -> Result<Self::Ok, Self::Error> {
278 Ok(WolframFunction::global(self.name, self.body).to_wolfram())
279 }
280}
281
282impl<'i> SerializeTupleVariant for SerializeAsFunction<'i> {
283 type Ok = WolframValue;
284 type Error = WolframError;
285
286 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
287 where
288 T: Serialize,
289 {
290 SerializeTupleStruct::serialize_field(self, value)
291 }
292
293 fn end(self) -> Result<Self::Ok, Self::Error> {
294 Ok(WolframFunction::namespace(self.name_space, self.name, self.body).to_wolfram())
295 }
296}
297
298impl<'i> SerializeStruct for SerializeAsFunction<'i> {
299 type Ok = WolframValue;
300 type Error = WolframError;
301
302 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
303 where
304 T: Serialize,
305 {
306 let key = WolframValue::String(key.to_string());
307 let value = value.serialize(self.config)?;
308 let pair = WolframValue::pair(key, value, false);
309 self.body.push(pair);
310 Ok(())
311 }
312
313 fn end(self) -> Result<Self::Ok, Self::Error> {
314 Ok(WolframFunction::global(self.name, self.body).to_wolfram())
315 }
316}
317
318impl<'i> SerializeStructVariant for SerializeAsFunction<'i> {
319 type Ok = WolframValue;
320 type Error = WolframError;
321
322 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
323 where
324 T: Serialize,
325 {
326 SerializeStruct::serialize_field(self, key, value)
327 }
328
329 fn end(self) -> Result<Self::Ok, Self::Error> {
330 Ok(WolframFunction::namespace(self.name_space, self.name, self.body).to_wolfram())
331 }
332}