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