1use super::{to_value, Map, Value};
2use crate::{ser::StringSerializer, Error, Number, Result};
3use serde::ser;
4use std::fmt::Display;
5
6impl ser::Serialize for Value {
7 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
8 where
9 S: ser::Serializer,
10 {
11 match *self {
12 Value::Null => serializer.serialize_unit(),
13 Value::Bool(b) => serializer.serialize_bool(b),
14 Value::Number(ref n) => n.serialize(serializer),
15 Value::String(ref s) => serializer.serialize_str(s),
16 Value::Array(ref v) => v.serialize(serializer),
17 Value::Object(ref v) => v.serialize(serializer),
18 }
19 }
20}
21
22pub struct ValueSerializer;
23
24impl ser::Serializer for ValueSerializer {
25 type Ok = Value;
26 type Error = Error;
27
28 type SerializeSeq = SerializeSeq;
29 type SerializeTuple = SerializeSeq;
30 type SerializeTupleStruct = SerializeSeq;
31 type SerializeTupleVariant = SerializeTupleVariant;
32 type SerializeMap = SerializeMap;
33 type SerializeStruct = SerializeMap;
34 type SerializeStructVariant = SerializeStructVariant;
35
36 serialize_self! { some newtype_struct }
37 forward_to_serialize_seq! { tuple tuple_struct }
38
39 fn serialize_bool(self, value: bool) -> Result<Self::Ok> {
40 Ok(Value::Bool(value))
41 }
42
43 fn serialize_i8(self, value: i8) -> Result<Self::Ok> {
44 self.serialize_i64(value as i64)
45 }
46
47 fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
48 self.serialize_i64(value as i64)
49 }
50
51 fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
52 self.serialize_i64(value as i64)
53 }
54
55 fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
56 Ok(Value::Number(value.into()))
57 }
58
59 fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
60 self.serialize_u64(value as u64)
61 }
62
63 fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
64 self.serialize_u64(value as u64)
65 }
66
67 fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
68 self.serialize_u64(value as u64)
69 }
70
71 fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
72 Ok(Value::Number(value.into()))
73 }
74
75 fn serialize_f32(self, value: f32) -> Result<Self::Ok> {
76 self.serialize_f64(value as f64)
77 }
78
79 fn serialize_f64(self, value: f64) -> Result<Self::Ok> {
80 Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
81 }
82
83 fn serialize_char(self, value: char) -> Result<Self::Ok> {
84 Ok(Value::String(value.to_string()))
85 }
86
87 fn serialize_str(self, value: &str) -> Result<Self::Ok> {
88 Ok(Value::String(value.to_owned()))
89 }
90
91 fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
92 let vec = value.iter().map(|&b| Value::Number(b.into())).collect();
93 Ok(Value::Array(vec))
94 }
95
96 fn serialize_unit(self) -> Result<Self::Ok> {
97 Ok(Value::Null)
98 }
99
100 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
101 self.serialize_unit()
102 }
103
104 fn serialize_unit_variant(
105 self,
106 _name: &'static str,
107 _variant_index: u32,
108 variant: &'static str,
109 ) -> Result<Self::Ok> {
110 self.serialize_str(variant)
111 }
112
113 fn serialize_newtype_variant<T>(
114 self,
115 _name: &'static str,
116 _variant_index: u32,
117 variant: &'static str,
118 value: &T,
119 ) -> Result<Self::Ok>
120 where
121 T: ?Sized + ser::Serialize,
122 {
123 let mut object = Map::with_capacity(1);
124 object.insert(variant.to_owned(), to_value(value)?);
125 Ok(Value::Object(object))
126 }
127
128 fn serialize_none(self) -> Result<Self::Ok> {
129 self.serialize_unit()
130 }
131
132 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
133 Ok(SerializeSeq {
134 vec: Vec::with_capacity(len.unwrap_or(0)),
135 })
136 }
137
138 fn serialize_tuple_variant(
139 self,
140 _name: &'static str,
141 _variant_index: u32,
142 variant: &'static str,
143 len: usize,
144 ) -> Result<Self::SerializeTupleVariant> {
145 Ok(SerializeTupleVariant {
146 name: variant.to_owned(),
147 vec: Vec::with_capacity(len),
148 })
149 }
150
151 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
152 Ok(SerializeMap {
153 map: Map::with_capacity(len.unwrap_or(0)),
154 next_key: None,
155 })
156 }
157
158 fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
159 self.serialize_map(Some(len))
160 }
161
162 fn serialize_struct_variant(
163 self,
164 _name: &'static str,
165 _variant_index: u32,
166 variant: &'static str,
167 len: usize,
168 ) -> Result<Self::SerializeStructVariant> {
169 Ok(SerializeStructVariant {
170 name: variant.to_owned(),
171 map: Map::with_capacity(len),
172 })
173 }
174
175 fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
176 where
177 T: ?Sized + Display,
178 {
179 Ok(Value::String(value.to_string()))
180 }
181}
182
183pub struct SerializeSeq {
184 vec: Vec<Value>,
185}
186
187impl ser::SerializeSeq for SerializeSeq {
188 type Ok = Value;
189 type Error = Error;
190
191 fn serialize_element<T>(&mut self, value: &T) -> Result<()>
192 where
193 T: ?Sized + ser::Serialize,
194 {
195 self.vec.push(to_value(value)?);
196 Ok(())
197 }
198
199 fn end(self) -> Result<Self::Ok> {
200 Ok(Value::Array(self.vec))
201 }
202}
203
204impl ser::SerializeTuple for SerializeSeq {
205 impl_forward_to_serialize_seq!(serialize_element, Value);
206}
207
208impl ser::SerializeTupleStruct for SerializeSeq {
209 impl_forward_to_serialize_seq!(serialize_field, Value);
210}
211
212pub struct SerializeTupleVariant {
213 name: String,
214 vec: Vec<Value>,
215}
216
217impl ser::SerializeTupleVariant for SerializeTupleVariant {
218 type Ok = Value;
219 type Error = Error;
220
221 fn serialize_field<T>(&mut self, value: &T) -> Result<()>
222 where
223 T: ?Sized + ser::Serialize,
224 {
225 self.vec.push(to_value(value)?);
226 Ok(())
227 }
228
229 fn end(self) -> Result<Self::Ok> {
230 let mut object = Map::with_capacity(1);
231 object.insert(self.name, self.vec.into());
232 Ok(Value::Object(object))
233 }
234}
235
236pub struct SerializeMap {
237 map: Map<String, Value>,
238 next_key: Option<String>,
239}
240
241impl ser::SerializeMap for SerializeMap {
242 type Ok = Value;
243 type Error = Error;
244
245 fn serialize_key<T>(&mut self, key: &T) -> Result<()>
246 where
247 T: ?Sized + ser::Serialize,
248 {
249 self.next_key = Some(key.serialize(StringSerializer)?);
250 Ok(())
251 }
252
253 fn serialize_value<T>(&mut self, value: &T) -> Result<()>
254 where
255 T: ?Sized + ser::Serialize,
256 {
257 let key = self.next_key.take();
258 let key = key.expect("serialize_value called before serialize_key");
259 self.map.insert(key, to_value(value)?);
260 Ok(())
261 }
262
263 fn end(self) -> Result<Self::Ok> {
264 Ok(Value::Object(self.map))
265 }
266}
267
268impl ser::SerializeStruct for SerializeMap {
269 type Ok = Value;
270 type Error = Error;
271
272 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
273 where
274 T: ?Sized + ser::Serialize,
275 {
276 ser::SerializeMap::serialize_entry(self, key, value)
277 }
278
279 fn end(self) -> Result<Self::Ok> {
280 ser::SerializeMap::end(self)
281 }
282}
283
284pub struct SerializeStructVariant {
285 name: String,
286 map: Map<String, Value>,
287}
288
289impl ser::SerializeStructVariant for SerializeStructVariant {
290 type Ok = Value;
291 type Error = Error;
292
293 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
294 where
295 T: ?Sized + ser::Serialize,
296 {
297 self.map.insert(key.to_owned(), to_value(value)?);
298 Ok(())
299 }
300
301 fn end(self) -> Result<Self::Ok> {
302 let mut object = Map::with_capacity(1);
303 object.insert(self.name, self.map.into());
304 Ok(Value::Object(object))
305 }
306}