wolfram_wxf/traits/
object_builder.rs

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/// A serializer for the Wolfram Language.
11#[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}
wolfram_wxf/traits/object_builder.rs

wolfram_wxf/traits/
object_builder.rs
