1use serde::ser;
2use std::collections::BTreeMap;
3use std::error::Error;
4use std::fmt;
5
6use crate::Value;
7
8#[derive(Debug)]
9pub enum SerializerError {
10 Custom(String),
11}
12
13impl fmt::Display for SerializerError {
14 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
15 match *self {
16 SerializerError::Custom(ref s) => fmt.write_str(s),
17 }
18 }
19}
20
21impl Error for SerializerError {
22 fn description(&self) -> &str {
23 "Value serializer error"
24 }
25}
26
27impl ser::Error for SerializerError {
28 fn custom<T: fmt::Display>(msg: T) -> SerializerError {
29 SerializerError::Custom(msg.to_string())
30 }
31}
32
33impl ser::Serialize for Value {
34 fn serialize<S: ser::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
35 match *self {
36 Value::Bool(v) => s.serialize_bool(v),
37 Value::U8(v) => s.serialize_u8(v),
38 Value::U16(v) => s.serialize_u16(v),
39 Value::U32(v) => s.serialize_u32(v),
40 Value::U64(v) => s.serialize_u64(v),
41 Value::I8(v) => s.serialize_i8(v),
42 Value::I16(v) => s.serialize_i16(v),
43 Value::I32(v) => s.serialize_i32(v),
44 Value::I64(v) => s.serialize_i64(v),
45 Value::F32(v) => s.serialize_f32(v),
46 Value::F64(v) => s.serialize_f64(v),
47 Value::Char(v) => s.serialize_char(v),
48 Value::String(ref v) => s.serialize_str(v),
49 Value::Unit => s.serialize_unit(),
50 Value::Option(None) => s.serialize_none(),
51 Value::Option(Some(ref v)) => s.serialize_some(v),
52 Value::Newtype(ref v) => s.serialize_newtype_struct("", v),
53 Value::Seq(ref v) => v.serialize(s),
54 Value::Map(ref v) => v.serialize(s),
55 Value::Bytes(ref v) => s.serialize_bytes(v),
56 }
57 }
58}
59
60pub fn to_value<T: ser::Serialize>(value: T) -> Result<Value, SerializerError> {
61 value.serialize(Serializer)
62}
63
64struct Serializer;
65
66impl ser::Serializer for Serializer {
67 type Ok = Value;
68 type Error = SerializerError;
69 type SerializeSeq = SerializeSeq;
70 type SerializeTuple = SerializeTuple;
71 type SerializeTupleStruct = SerializeTupleStruct;
72 type SerializeTupleVariant = SerializeTupleVariant;
73 type SerializeMap = SerializeMap;
74 type SerializeStruct = SerializeStruct;
75 type SerializeStructVariant = SerializeStructVariant;
76
77 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
78 Ok(Value::Bool(v))
79 }
80
81 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
82 Ok(Value::I8(v))
83 }
84
85 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
86 Ok(Value::I16(v))
87 }
88
89 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
90 Ok(Value::I32(v))
91 }
92
93 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
94 Ok(Value::I64(v))
95 }
96
97 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
98 Ok(Value::U8(v))
99 }
100
101 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
102 Ok(Value::U16(v))
103 }
104
105 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
106 Ok(Value::U32(v))
107 }
108
109 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
110 Ok(Value::U64(v))
111 }
112
113 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
114 Ok(Value::F32(v))
115 }
116
117 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
118 Ok(Value::F64(v))
119 }
120
121 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
122 Ok(Value::Char(v))
123 }
124
125 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
126 Ok(Value::String(v.to_string()))
127 }
128
129 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
130 Ok(Value::Bytes(v.to_vec()))
131 }
132
133 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
134 Ok(Value::Option(None))
135 }
136
137 fn serialize_some<T: ?Sized>(
138 self,
139 value: &T
140 ) -> Result<Self::Ok, Self::Error>
141 where
142 T: ser::Serialize
143 {
144 value.serialize(Serializer).map(|v| Value::Option(Some(Box::new(v))))
145 }
146
147 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
148 Ok(Value::Unit)
149 }
150
151 fn serialize_unit_struct(
152 self,
153 _name: &'static str
154 ) -> Result<Self::Ok, Self::Error> {
155 Ok(Value::Unit)
156 }
157
158 fn serialize_unit_variant(
159 self,
160 _name: &'static str,
161 _variant_index: u32,
162 variant: &'static str,
163 ) -> Result<Self::Ok, Self::Error> {
164 Ok(Value::String(variant.to_string()))
165 }
166
167 fn serialize_newtype_struct<T: ?Sized>(
168 self,
169 _name: &'static str,
170 value: &T
171 ) -> Result<Self::Ok, Self::Error>
172 where
173 T: ser::Serialize
174 {
175 value.serialize(Serializer).map(|v| Value::Newtype(Box::new(v)))
176 }
177
178 fn serialize_newtype_variant<T: ?Sized>(
179 self,
180 _name: &'static str,
181 _variant_index: u32,
182 variant: &'static str,
183 value: &T
184 ) -> Result<Self::Ok, Self::Error>
185 where
186 T: ser::Serialize
187 {
188 value.serialize(Serializer).map(|v| {
189 let mut map = BTreeMap::new();
190 map.insert(Value::String(variant.to_string()), v);
191 Value::Map(map)
192 })
193 }
194
195 fn serialize_seq(
196 self,
197 _len: Option<usize>
198 ) -> Result<Self::SerializeSeq, Self::Error> {
199 Ok(SerializeSeq(vec![]))
200 }
201
202 fn serialize_tuple(
203 self,
204 _len: usize
205 ) -> Result<Self::SerializeTuple, Self::Error> {
206 Ok(SerializeTuple(vec![]))
207 }
208
209 fn serialize_tuple_struct(
210 self,
211 _name: &'static str,
212 _len: usize
213 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
214 Ok(SerializeTupleStruct(vec![]))
215 }
216
217 fn serialize_tuple_variant(
218 self,
219 _name: &'static str,
220 _variant_index: u32,
221 variant: &'static str,
222 len: usize
223 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
224 Ok(SerializeTupleVariant(
225 Value::String(variant.to_string()),
226 Vec::with_capacity(len),
227 ))
228 }
229
230 fn serialize_map(
231 self,
232 _len: Option<usize>
233 ) -> Result<Self::SerializeMap, Self::Error> {
234 Ok(SerializeMap { map: BTreeMap::new(), key: None })
235 }
236
237 fn serialize_struct(
238 self,
239 _name: &'static str,
240 _len: usize
241 ) -> Result<Self::SerializeStruct, Self::Error> {
242 Ok(SerializeStruct(BTreeMap::new()))
243 }
244
245 fn serialize_struct_variant(
246 self,
247 _name: &'static str,
248 _variant_index: u32,
249 variant: &'static str,
250 _len: usize
251 ) -> Result<Self::SerializeStructVariant, Self::Error> {
252 Ok(SerializeStructVariant(
253 Value::String(variant.to_string()),
254 BTreeMap::new(),
255 ))
256 }
257}
258
259struct SerializeSeq(Vec<Value>);
260
261impl ser::SerializeSeq for SerializeSeq {
262 type Ok = Value;
263 type Error = SerializerError;
264
265 fn serialize_element<T: ?Sized>(
266 &mut self,
267 value: &T
268 ) -> Result<(), Self::Error>
269 where
270 T: ser::Serialize
271 {
272 let value = value.serialize(Serializer)?;
273 self.0.push(value);
274 Ok(())
275 }
276
277 fn end(self) -> Result<Self::Ok, Self::Error> {
278 Ok(Value::Seq(self.0))
279 }
280}
281
282struct SerializeTuple(Vec<Value>);
283
284impl ser::SerializeTuple for SerializeTuple {
285 type Ok = Value;
286 type Error = SerializerError;
287
288 fn serialize_element<T: ?Sized>(
289 &mut self,
290 value: &T
291 ) -> Result<(), Self::Error>
292 where
293 T: ser::Serialize
294 {
295 let value = value.serialize(Serializer)?;
296 self.0.push(value);
297 Ok(())
298 }
299
300 fn end(self) -> Result<Self::Ok, Self::Error> {
301 Ok(Value::Seq(self.0))
302 }
303}
304
305struct SerializeTupleStruct(Vec<Value>);
306
307impl ser::SerializeTupleStruct for SerializeTupleStruct {
308 type Ok = Value;
309 type Error = SerializerError;
310
311 fn serialize_field<T: ?Sized>(
312 &mut self,
313 value: &T
314 ) -> Result<(), Self::Error>
315 where
316 T: ser::Serialize
317 {
318 let value = value.serialize(Serializer)?;
319 self.0.push(value);
320 Ok(())
321 }
322
323 fn end(self) -> Result<Self::Ok, Self::Error> {
324 Ok(Value::Seq(self.0))
325 }
326}
327
328struct SerializeTupleVariant(Value, Vec<Value>);
329
330impl ser::SerializeTupleVariant for SerializeTupleVariant {
331 type Ok = Value;
332 type Error = SerializerError;
333
334 fn serialize_field<T: ?Sized>(
335 &mut self,
336 value: &T
337 ) -> Result<(), Self::Error>
338 where
339 T: ser::Serialize
340 {
341 let value = value.serialize(Serializer)?;
342 self.1.push(value);
343 Ok(())
344 }
345
346 fn end(self) -> Result<Self::Ok, Self::Error> {
347 let mut map = BTreeMap::new();
348 map.insert(self.0, Value::Seq(self.1));
349 Ok(Value::Map(map))
350 }
351}
352
353struct SerializeMap {
354 map: BTreeMap<Value, Value>,
355 key: Option<Value>,
356}
357
358impl ser::SerializeMap for SerializeMap {
359 type Ok = Value;
360 type Error = SerializerError;
361
362 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
363 where
364 T: ser::Serialize
365 {
366 let key = key.serialize(Serializer)?;
367 self.key = Some(key);
368 Ok(())
369 }
370
371 fn serialize_value<T: ?Sized>(
372 &mut self,
373 value: &T
374 ) -> Result<(), Self::Error>
375 where
376 T: ser::Serialize
377 {
378 let value = value.serialize(Serializer)?;
379 self.map.insert(self.key.take().unwrap(), value);
380 Ok(())
381 }
382
383 fn end(self) -> Result<Self::Ok, Self::Error> {
384 Ok(Value::Map(self.map))
385 }
386}
387
388struct SerializeStruct(BTreeMap<Value, Value>);
389
390impl ser::SerializeStruct for SerializeStruct {
391 type Ok = Value;
392 type Error = SerializerError;
393
394 fn serialize_field<T: ?Sized>(
395 &mut self,
396 key: &'static str,
397 value: &T
398 ) -> Result<(), Self::Error>
399 where
400 T: ser::Serialize
401 {
402 let key = Value::String(key.to_string());
403 let value = value.serialize(Serializer)?;
404 self.0.insert(key, value);
405 Ok(())
406 }
407
408 fn end(self) -> Result<Self::Ok, Self::Error> {
409 Ok(Value::Map(self.0))
410 }
411}
412
413struct SerializeStructVariant(Value, BTreeMap<Value, Value>);
414
415impl ser::SerializeStructVariant for SerializeStructVariant {
416 type Ok = Value;
417 type Error = SerializerError;
418
419 fn serialize_field<T: ?Sized>(
420 &mut self,
421 key: &'static str,
422 value: &T
423 ) -> Result<(), Self::Error>
424 where
425 T: ser::Serialize
426 {
427 let key = Value::String(key.to_string());
428 let value = value.serialize(Serializer)?;
429 self.1.insert(key, value);
430 Ok(())
431 }
432
433 fn end(self) -> Result<Self::Ok, Self::Error> {
434 let mut map = BTreeMap::new();
435 map.insert(self.0, Value::Map(self.1));
436 Ok(Value::Map(map))
437 }
438}