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