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
60#[inline]
61pub fn to_value<T: ser::Serialize>(value: T) -> Result<Value, SerializerError> {
62 value.serialize(Serializer)
63}
64
65struct Serializer;
66
67#[allow(clippy::type_repetition_in_bounds)]
68impl ser::Serializer for Serializer {
69 type Ok = Value;
70 type Error = SerializerError;
71 type SerializeSeq = SerializeSeq;
72 type SerializeTuple = SerializeTuple;
73 type SerializeTupleStruct = SerializeTupleStruct;
74 type SerializeTupleVariant = SerializeTupleVariant;
75 type SerializeMap = SerializeMap;
76 type SerializeStruct = SerializeStruct;
77 type SerializeStructVariant = SerializeStructVariant;
78
79 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
80 Ok(Value::Bool(v))
81 }
82
83 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
84 Ok(Value::I8(v))
85 }
86
87 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
88 Ok(Value::I16(v))
89 }
90
91 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
92 Ok(Value::I32(v))
93 }
94
95 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
96 Ok(Value::I64(v))
97 }
98
99 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
100 Ok(Value::U8(v))
101 }
102
103 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
104 Ok(Value::U16(v))
105 }
106
107 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
108 Ok(Value::U32(v))
109 }
110
111 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
112 Ok(Value::U64(v))
113 }
114
115 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
116 Ok(Value::F32(v))
117 }
118
119 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
120 Ok(Value::F64(v))
121 }
122
123 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
124 Ok(Value::Char(v))
125 }
126
127 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
128 Ok(Value::String(v.to_string()))
129 }
130
131 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
132 Ok(Value::Bytes(v.to_vec()))
133 }
134
135 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
136 Ok(Value::Option(None))
137 }
138
139 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
140 where
141 T: ser::Serialize + ?Sized,
142 {
143 value
144 .serialize(Serializer)
145 .map(|v| Value::Option(Some(Box::new(v))))
146 }
147
148 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
149 Ok(Value::Unit)
150 }
151
152 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
153 Ok(Value::Unit)
154 }
155
156 fn serialize_unit_variant(
157 self,
158 _name: &'static str,
159 _variant_index: u32,
160 variant: &'static str,
161 ) -> Result<Self::Ok, Self::Error> {
162 Ok(Value::String(variant.to_string()))
163 }
164
165 fn serialize_newtype_struct<T>(
166 self,
167 _name: &'static str,
168 value: &T,
169 ) -> Result<Self::Ok, Self::Error>
170 where
171 T: ser::Serialize + ?Sized,
172 {
173 value
174 .serialize(Serializer)
175 .map(|v| Value::Newtype(Box::new(v)))
176 }
177
178 fn serialize_newtype_variant<T>(
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 + ?Sized,
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(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
196 Ok(SerializeSeq(vec![]))
197 }
198
199 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
200 Ok(SerializeTuple(vec![]))
201 }
202
203 fn serialize_tuple_struct(
204 self,
205 _name: &'static str,
206 _len: usize,
207 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
208 Ok(SerializeTupleStruct(vec![]))
209 }
210
211 fn serialize_tuple_variant(
212 self,
213 _name: &'static str,
214 _variant_index: u32,
215 variant: &'static str,
216 len: usize,
217 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
218 Ok(SerializeTupleVariant(
219 Value::String(variant.to_string()),
220 Vec::with_capacity(len),
221 ))
222 }
223
224 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
225 Ok(SerializeMap {
226 map: BTreeMap::new(),
227 key: None,
228 })
229 }
230
231 fn serialize_struct(
232 self,
233 _name: &'static str,
234 _len: usize,
235 ) -> Result<Self::SerializeStruct, Self::Error> {
236 Ok(SerializeStruct(BTreeMap::new()))
237 }
238
239 fn serialize_struct_variant(
240 self,
241 _name: &'static str,
242 _variant_index: u32,
243 variant: &'static str,
244 _len: usize,
245 ) -> Result<Self::SerializeStructVariant, Self::Error> {
246 Ok(SerializeStructVariant(
247 Value::String(variant.to_string()),
248 BTreeMap::new(),
249 ))
250 }
251}
252
253struct SerializeSeq(Vec<Value>);
254
255#[allow(clippy::type_repetition_in_bounds)]
256impl ser::SerializeSeq for SerializeSeq {
257 type Ok = Value;
258 type Error = SerializerError;
259
260 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
261 where
262 T: ser::Serialize + ?Sized,
263 {
264 let value = value.serialize(Serializer)?;
265 self.0.push(value);
266 Ok(())
267 }
268
269 fn end(self) -> Result<Self::Ok, Self::Error> {
270 Ok(Value::Seq(self.0))
271 }
272}
273
274struct SerializeTuple(Vec<Value>);
275
276#[allow(clippy::type_repetition_in_bounds)]
277impl ser::SerializeTuple for SerializeTuple {
278 type Ok = Value;
279 type Error = SerializerError;
280
281 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
282 where
283 T: ser::Serialize + ?Sized,
284 {
285 let value = value.serialize(Serializer)?;
286 self.0.push(value);
287 Ok(())
288 }
289
290 fn end(self) -> Result<Self::Ok, Self::Error> {
291 Ok(Value::Seq(self.0))
292 }
293}
294
295struct SerializeTupleStruct(Vec<Value>);
296
297#[allow(clippy::type_repetition_in_bounds)]
298impl ser::SerializeTupleStruct for SerializeTupleStruct {
299 type Ok = Value;
300 type Error = SerializerError;
301
302 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
303 where
304 T: ser::Serialize + ?Sized,
305 {
306 let value = value.serialize(Serializer)?;
307 self.0.push(value);
308 Ok(())
309 }
310
311 fn end(self) -> Result<Self::Ok, Self::Error> {
312 Ok(Value::Seq(self.0))
313 }
314}
315
316struct SerializeTupleVariant(Value, Vec<Value>);
317
318#[allow(clippy::type_repetition_in_bounds)]
319impl ser::SerializeTupleVariant for SerializeTupleVariant {
320 type Ok = Value;
321 type Error = SerializerError;
322
323 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
324 where
325 T: ser::Serialize + ?Sized,
326 {
327 let value = value.serialize(Serializer)?;
328 self.1.push(value);
329 Ok(())
330 }
331
332 fn end(self) -> Result<Self::Ok, Self::Error> {
333 let mut map = BTreeMap::new();
334 map.insert(self.0, Value::Seq(self.1));
335 Ok(Value::Map(map))
336 }
337}
338
339struct SerializeMap {
340 map: BTreeMap<Value, Value>,
341 key: Option<Value>,
342}
343
344#[allow(clippy::type_repetition_in_bounds)]
345impl ser::SerializeMap for SerializeMap {
346 type Ok = Value;
347 type Error = SerializerError;
348
349 fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
350 where
351 T: ser::Serialize + ?Sized,
352 {
353 let key = key.serialize(Serializer)?;
354 self.key = Some(key);
355 Ok(())
356 }
357
358 fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
359 where
360 T: ser::Serialize + ?Sized,
361 {
362 let value = value.serialize(Serializer)?;
363 self.map.insert(self.key.take().unwrap(), value);
364 Ok(())
365 }
366
367 fn end(self) -> Result<Self::Ok, Self::Error> {
368 Ok(Value::Map(self.map))
369 }
370}
371
372struct SerializeStruct(BTreeMap<Value, Value>);
373
374#[allow(clippy::type_repetition_in_bounds)]
375impl ser::SerializeStruct for SerializeStruct {
376 type Ok = Value;
377 type Error = SerializerError;
378
379 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
380 where
381 T: ser::Serialize + ?Sized,
382 {
383 let key = Value::String(key.to_string());
384 let value = value.serialize(Serializer)?;
385 self.0.insert(key, value);
386 Ok(())
387 }
388
389 fn end(self) -> Result<Self::Ok, Self::Error> {
390 Ok(Value::Map(self.0))
391 }
392}
393
394struct SerializeStructVariant(Value, BTreeMap<Value, Value>);
395
396#[allow(clippy::type_repetition_in_bounds)]
397impl ser::SerializeStructVariant for SerializeStructVariant {
398 type Ok = Value;
399 type Error = SerializerError;
400
401 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
402 where
403 T: ser::Serialize + ?Sized,
404 {
405 let key = Value::String(key.to_string());
406 let value = value.serialize(Serializer)?;
407 self.1.insert(key, value);
408 Ok(())
409 }
410
411 fn end(self) -> Result<Self::Ok, Self::Error> {
412 let mut map = BTreeMap::new();
413 map.insert(self.0, Value::Map(self.1));
414 Ok(Value::Map(map))
415 }
416}