clojure_reader/
ser.rs

1use alloc::string::{String, ToString};
2use core::fmt::Display;
3
4use serde::{ser, Serialize};
5
6use crate::error::{Code, Error, Result};
7
8#[derive(Debug)]
9pub struct Serializer {
10  output: String,
11}
12
13impl ser::Error for Error {
14  #[cold]
15  fn custom<T: Display>(msg: T) -> Self {
16    Self { code: Code::Serde(msg.to_string()), line: None, column: None, ptr: None }
17  }
18}
19
20/// Serializer for creating an EDN formatted String
21///
22/// # Errors
23///
24/// See [`crate::error::Error`].
25/// Always returns `Code::Serde`.
26pub fn to_string<T>(value: &T) -> Result<String>
27where
28  T: Serialize,
29{
30  let mut serializer = Serializer { output: String::new() };
31  value.serialize(&mut serializer)?;
32  Ok(serializer.output)
33}
34
35impl ser::Serializer for &mut Serializer {
36  type Ok = ();
37  type Error = Error;
38
39  type SerializeSeq = Self;
40  type SerializeTuple = Self;
41  type SerializeTupleStruct = Self;
42  type SerializeTupleVariant = Self;
43  type SerializeMap = Self;
44  type SerializeStruct = Self;
45  type SerializeStructVariant = Self;
46
47  fn serialize_bool(self, v: bool) -> Result<()> {
48    self.output += if v { "true" } else { "false" };
49    Ok(())
50  }
51
52  // EDN is always an i64 for integers, so all integers will be serialized as i64.
53  fn serialize_i8(self, v: i8) -> Result<()> {
54    self.serialize_i64(i64::from(v))
55  }
56
57  fn serialize_i16(self, v: i16) -> Result<()> {
58    self.serialize_i64(i64::from(v))
59  }
60
61  fn serialize_i32(self, v: i32) -> Result<()> {
62    self.serialize_i64(i64::from(v))
63  }
64
65  fn serialize_i64(self, v: i64) -> Result<()> {
66    self.output += &v.to_string();
67    Ok(())
68  }
69
70  fn serialize_u8(self, v: u8) -> Result<()> {
71    self.serialize_u64(u64::from(v))
72  }
73
74  fn serialize_u16(self, v: u16) -> Result<()> {
75    self.serialize_u64(u64::from(v))
76  }
77
78  fn serialize_u32(self, v: u32) -> Result<()> {
79    self.serialize_u64(u64::from(v))
80  }
81
82  fn serialize_u64(self, v: u64) -> Result<()> {
83    self.output += &v.to_string();
84    Ok(())
85  }
86
87  fn serialize_f32(self, v: f32) -> Result<()> {
88    self.serialize_f64(f64::from(v))
89  }
90
91  fn serialize_f64(self, v: f64) -> Result<()> {
92    self.output += &v.to_string();
93    Ok(())
94  }
95
96  fn serialize_char(self, v: char) -> Result<()> {
97    self.output += "\\";
98    if let Some(c) = crate::edn::char_to_edn(v) {
99      self.output += c;
100    } else {
101      self.output.push(v);
102    }
103    Ok(())
104  }
105
106  fn serialize_str(self, v: &str) -> Result<()> {
107    self.output += "\"";
108    self.output += v;
109    self.output += "\"";
110    Ok(())
111  }
112
113  // as of 2024-11, this is not called by serde
114  // https://serde.rs/impl-serialize.html
115  fn serialize_bytes(self, v: &[u8]) -> Result<()> {
116    use serde::ser::SerializeSeq;
117
118    let mut seq = self.serialize_seq(Some(v.len()))?;
119    for byte in v {
120      seq.serialize_element(byte)?;
121    }
122    seq.end()
123  }
124
125  fn serialize_none(self) -> Result<()> {
126    self.serialize_unit()
127  }
128
129  fn serialize_some<T>(self, value: &T) -> Result<()>
130  where
131    T: ?Sized + Serialize,
132  {
133    value.serialize(self)
134  }
135
136  fn serialize_unit(self) -> Result<()> {
137    self.output += "nil";
138    Ok(())
139  }
140
141  fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
142    self.serialize_unit()
143  }
144
145  fn serialize_unit_variant(
146    self,
147    name: &'static str,
148    _variant_index: u32,
149    variant: &'static str,
150  ) -> Result<()> {
151    self.output += "#";
152    self.output += name;
153    self.output += "/";
154    self.output += variant;
155    self.output += " ";
156    self.serialize_unit()
157  }
158
159  fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
160  where
161    T: ?Sized + Serialize,
162  {
163    value.serialize(self)
164  }
165
166  fn serialize_newtype_variant<T>(
167    self,
168    name: &'static str,
169    _variant_index: u32,
170    variant: &'static str,
171    value: &T,
172  ) -> Result<()>
173  where
174    T: ?Sized + Serialize,
175  {
176    self.output += "#";
177    self.output += name;
178    self.output += "/";
179    self.output += variant;
180    self.output += " ";
181    value.serialize(self)
182  }
183
184  fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
185    self.output += "[";
186    Ok(self)
187  }
188
189  fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
190    self.output += "[";
191    Ok(self)
192  }
193
194  fn serialize_tuple_struct(
195    self,
196    _name: &'static str,
197    len: usize,
198  ) -> Result<Self::SerializeTupleStruct> {
199    self.serialize_tuple(len)
200  }
201
202  fn serialize_tuple_variant(
203    self,
204    name: &'static str,
205    _variant_index: u32,
206    variant: &'static str,
207    _len: usize,
208  ) -> Result<Self::SerializeTupleVariant> {
209    self.output += "#";
210    self.output += name;
211    self.output += "/";
212    self.output += variant;
213    self.output += " [";
214    Ok(self)
215  }
216
217  fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
218    self.output += "{";
219    Ok(self)
220  }
221
222  fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
223    self.serialize_map(Some(len))
224  }
225
226  fn serialize_struct_variant(
227    self,
228    name: &'static str,
229    _variant_index: u32,
230    variant: &'static str,
231    _len: usize,
232  ) -> Result<Self::SerializeStructVariant> {
233    self.output += "#";
234    self.output += name;
235    self.output += "/";
236    self.output += variant;
237    self.output += " {";
238    Ok(self)
239  }
240}
241
242impl ser::SerializeSeq for &mut Serializer {
243  type Ok = ();
244  type Error = Error;
245
246  fn serialize_element<T>(&mut self, value: &T) -> Result<()>
247  where
248    T: ?Sized + Serialize,
249  {
250    if !self.output.ends_with('[') {
251      self.output += " ";
252    }
253    value.serialize(&mut **self)
254  }
255
256  fn end(self) -> Result<()> {
257    self.output += "]";
258    Ok(())
259  }
260}
261
262impl ser::SerializeTuple for &mut Serializer {
263  type Ok = ();
264  type Error = Error;
265
266  fn serialize_element<T>(&mut self, value: &T) -> Result<()>
267  where
268    T: ?Sized + Serialize,
269  {
270    if !self.output.ends_with('[') {
271      self.output += " ";
272    }
273    value.serialize(&mut **self)
274  }
275
276  fn end(self) -> Result<()> {
277    self.output += "]";
278    Ok(())
279  }
280}
281
282impl ser::SerializeTupleStruct for &mut Serializer {
283  type Ok = ();
284  type Error = Error;
285
286  fn serialize_field<T>(&mut self, value: &T) -> Result<()>
287  where
288    T: ?Sized + Serialize,
289  {
290    if !self.output.ends_with('[') {
291      self.output += " ";
292    }
293    value.serialize(&mut **self)
294  }
295
296  fn end(self) -> Result<()> {
297    self.output += "]";
298    Ok(())
299  }
300}
301
302impl ser::SerializeTupleVariant for &mut Serializer {
303  type Ok = ();
304  type Error = Error;
305
306  fn serialize_field<T>(&mut self, value: &T) -> Result<()>
307  where
308    T: ?Sized + Serialize,
309  {
310    if !self.output.ends_with('[') {
311      self.output += " ";
312    }
313    value.serialize(&mut **self)
314  }
315
316  fn end(self) -> Result<()> {
317    self.output += "]";
318    Ok(())
319  }
320}
321
322impl ser::SerializeMap for &mut Serializer {
323  type Ok = ();
324  type Error = Error;
325
326  fn serialize_key<T>(&mut self, key: &T) -> Result<()>
327  where
328    T: ?Sized + Serialize,
329  {
330    if !self.output.ends_with('{') {
331      self.output += ", ";
332    }
333
334    key.serialize(&mut **self)
335  }
336
337  fn serialize_value<T>(&mut self, value: &T) -> Result<()>
338  where
339    T: ?Sized + Serialize,
340  {
341    self.output += " ";
342    value.serialize(&mut **self)
343  }
344
345  fn end(self) -> Result<()> {
346    self.output += "}";
347    Ok(())
348  }
349}
350
351impl ser::SerializeStruct for &mut Serializer {
352  type Ok = ();
353  type Error = Error;
354
355  fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
356  where
357    T: ?Sized + Serialize,
358  {
359    if !self.output.ends_with('{') {
360      self.output += ", ";
361    }
362    self.output += ":";
363    self.output += key;
364    self.output += " ";
365    value.serialize(&mut **self)
366  }
367
368  fn end(self) -> Result<()> {
369    self.output += "}";
370    Ok(())
371  }
372}
373
374impl ser::SerializeStructVariant for &mut Serializer {
375  type Ok = ();
376  type Error = Error;
377
378  fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
379  where
380    T: ?Sized + Serialize,
381  {
382    if !self.output.ends_with('{') {
383      self.output += ", ";
384    }
385    self.output += ":";
386    self.output += key;
387    self.output += " ";
388    value.serialize(&mut **self)
389  }
390
391  fn end(self) -> Result<()> {
392    self.output += "}";
393    Ok(())
394  }
395}
clojure_reader/ser.rs

clojure_reader/
ser.rs
