]>
Commit | Line | Data |
---|---|---|
041b39d2 XL |
1 | // Copyright 2017 Serde Developers |
2 | // | |
3 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
4 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
5 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
6 | // option. This file may not be copied, modified, or distributed | |
7 | // except according to those terms. | |
8 | ||
9 | use lib::*; | |
10 | ||
11 | use ser::{Serialize, SerializeTuple, Serializer}; | |
12 | ||
13 | #[cfg(feature = "std")] | |
14 | use ser::Error; | |
15 | ||
16 | //////////////////////////////////////////////////////////////////////////////// | |
17 | ||
18 | macro_rules! primitive_impl { | |
19 | ($ty:ident, $method:ident $($cast:tt)*) => { | |
20 | impl Serialize for $ty { | |
21 | #[inline] | |
22 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
23 | where | |
24 | S: Serializer, | |
25 | { | |
26 | serializer.$method(*self $($cast)*) | |
27 | } | |
28 | } | |
29 | } | |
30 | } | |
31 | ||
32 | primitive_impl!(bool, serialize_bool); | |
33 | primitive_impl!(isize, serialize_i64 as i64); | |
34 | primitive_impl!(i8, serialize_i8); | |
35 | primitive_impl!(i16, serialize_i16); | |
36 | primitive_impl!(i32, serialize_i32); | |
37 | primitive_impl!(i64, serialize_i64); | |
38 | primitive_impl!(usize, serialize_u64 as u64); | |
39 | primitive_impl!(u8, serialize_u8); | |
40 | primitive_impl!(u16, serialize_u16); | |
41 | primitive_impl!(u32, serialize_u32); | |
42 | primitive_impl!(u64, serialize_u64); | |
43 | primitive_impl!(f32, serialize_f32); | |
44 | primitive_impl!(f64, serialize_f64); | |
45 | primitive_impl!(char, serialize_char); | |
46 | ||
47 | //////////////////////////////////////////////////////////////////////////////// | |
48 | ||
49 | impl Serialize for str { | |
50 | #[inline] | |
51 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
52 | where | |
53 | S: Serializer, | |
54 | { | |
55 | serializer.serialize_str(self) | |
56 | } | |
57 | } | |
58 | ||
59 | #[cfg(any(feature = "std", feature = "alloc"))] | |
60 | impl Serialize for String { | |
61 | #[inline] | |
62 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
63 | where | |
64 | S: Serializer, | |
65 | { | |
66 | serializer.serialize_str(self) | |
67 | } | |
68 | } | |
69 | ||
70 | //////////////////////////////////////////////////////////////////////////////// | |
71 | ||
72 | #[cfg(feature = "std")] | |
73 | impl Serialize for CStr { | |
74 | #[inline] | |
75 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
76 | where | |
77 | S: Serializer, | |
78 | { | |
79 | serializer.serialize_bytes(self.to_bytes()) | |
80 | } | |
81 | } | |
82 | ||
83 | #[cfg(feature = "std")] | |
84 | impl Serialize for CString { | |
85 | #[inline] | |
86 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
87 | where | |
88 | S: Serializer, | |
89 | { | |
90 | serializer.serialize_bytes(self.to_bytes()) | |
91 | } | |
92 | } | |
93 | ||
94 | //////////////////////////////////////////////////////////////////////////////// | |
95 | ||
96 | impl<T> Serialize for Option<T> | |
97 | where | |
98 | T: Serialize, | |
99 | { | |
100 | #[inline] | |
101 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
102 | where | |
103 | S: Serializer, | |
104 | { | |
105 | match *self { | |
106 | Some(ref value) => serializer.serialize_some(value), | |
107 | None => serializer.serialize_none(), | |
108 | } | |
109 | } | |
110 | } | |
111 | ||
112 | //////////////////////////////////////////////////////////////////////////////// | |
113 | ||
114 | impl<T> Serialize for PhantomData<T> { | |
115 | #[inline] | |
116 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
117 | where | |
118 | S: Serializer, | |
119 | { | |
120 | serializer.serialize_unit_struct("PhantomData") | |
121 | } | |
122 | } | |
123 | ||
124 | //////////////////////////////////////////////////////////////////////////////// | |
125 | ||
126 | // Does not require T: Serialize. | |
127 | impl<T> Serialize for [T; 0] { | |
128 | #[inline] | |
129 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
130 | where | |
131 | S: Serializer, | |
132 | { | |
133 | try!(serializer.serialize_tuple(0)).end() | |
134 | } | |
135 | } | |
136 | ||
137 | macro_rules! array_impls { | |
138 | ($($len:tt)+) => { | |
139 | $( | |
140 | impl<T> Serialize for [T; $len] | |
141 | where | |
142 | T: Serialize, | |
143 | { | |
144 | #[inline] | |
145 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
146 | where | |
147 | S: Serializer, | |
148 | { | |
149 | let mut seq = try!(serializer.serialize_tuple($len)); | |
150 | for e in self { | |
151 | try!(seq.serialize_element(e)); | |
152 | } | |
153 | seq.end() | |
154 | } | |
155 | } | |
156 | )+ | |
157 | } | |
158 | } | |
159 | ||
160 | array_impls!(01 02 03 04 05 06 07 08 09 10 | |
161 | 11 12 13 14 15 16 17 18 19 20 | |
162 | 21 22 23 24 25 26 27 28 29 30 | |
163 | 31 32); | |
164 | ||
165 | //////////////////////////////////////////////////////////////////////////////// | |
166 | ||
167 | impl<T> Serialize for [T] | |
168 | where | |
169 | T: Serialize, | |
170 | { | |
171 | #[inline] | |
172 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
173 | where | |
174 | S: Serializer, | |
175 | { | |
176 | serializer.collect_seq(self) | |
177 | } | |
178 | } | |
179 | ||
180 | #[cfg(any(feature = "std", feature = "alloc"))] | |
181 | macro_rules! seq_impl { | |
182 | ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => { | |
183 | impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*> | |
184 | where | |
185 | T: Serialize $(+ $tbound1 $(+ $tbound2)*)*, | |
186 | $($typaram: $bound,)* | |
187 | { | |
188 | #[inline] | |
189 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
190 | where | |
191 | S: Serializer, | |
192 | { | |
193 | serializer.collect_seq(self) | |
194 | } | |
195 | } | |
196 | } | |
197 | } | |
198 | ||
199 | #[cfg(any(feature = "std", feature = "alloc"))] | |
200 | seq_impl!(BinaryHeap<T: Ord>); | |
201 | ||
202 | #[cfg(any(feature = "std", feature = "alloc"))] | |
203 | seq_impl!(BTreeSet<T: Ord>); | |
204 | ||
205 | #[cfg(feature = "std")] | |
206 | seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>); | |
207 | ||
208 | #[cfg(any(feature = "std", feature = "alloc"))] | |
209 | seq_impl!(LinkedList<T>); | |
210 | ||
211 | #[cfg(any(feature = "std", feature = "alloc"))] | |
212 | seq_impl!(Vec<T>); | |
213 | ||
214 | #[cfg(any(feature = "std", feature = "alloc"))] | |
215 | seq_impl!(VecDeque<T>); | |
216 | ||
217 | //////////////////////////////////////////////////////////////////////////////// | |
218 | ||
219 | #[cfg(feature = "std")] | |
220 | impl<Idx> Serialize for ops::Range<Idx> | |
221 | where | |
222 | Idx: Serialize, | |
223 | { | |
224 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
225 | where | |
226 | S: Serializer, | |
227 | { | |
228 | use super::SerializeStruct; | |
229 | let mut state = try!(serializer.serialize_struct("Range", 2)); | |
230 | try!(state.serialize_field("start", &self.start)); | |
231 | try!(state.serialize_field("end", &self.end)); | |
232 | state.end() | |
233 | } | |
234 | } | |
235 | ||
236 | //////////////////////////////////////////////////////////////////////////////// | |
237 | ||
238 | impl Serialize for () { | |
239 | #[inline] | |
240 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
241 | where | |
242 | S: Serializer, | |
243 | { | |
244 | serializer.serialize_unit() | |
245 | } | |
246 | } | |
247 | ||
248 | //////////////////////////////////////////////////////////////////////////////// | |
249 | ||
250 | macro_rules! tuple_impls { | |
251 | ($($len:expr => ($($n:tt $name:ident)+))+) => { | |
252 | $( | |
253 | impl<$($name),+> Serialize for ($($name,)+) | |
254 | where | |
255 | $($name: Serialize,)+ | |
256 | { | |
257 | #[inline] | |
258 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
259 | where | |
260 | S: Serializer, | |
261 | { | |
262 | let mut tuple = try!(serializer.serialize_tuple($len)); | |
263 | $( | |
264 | try!(tuple.serialize_element(&self.$n)); | |
265 | )+ | |
266 | tuple.end() | |
267 | } | |
268 | } | |
269 | )+ | |
270 | } | |
271 | } | |
272 | ||
273 | tuple_impls! { | |
274 | 1 => (0 T0) | |
275 | 2 => (0 T0 1 T1) | |
276 | 3 => (0 T0 1 T1 2 T2) | |
277 | 4 => (0 T0 1 T1 2 T2 3 T3) | |
278 | 5 => (0 T0 1 T1 2 T2 3 T3 4 T4) | |
279 | 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5) | |
280 | 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6) | |
281 | 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7) | |
282 | 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8) | |
283 | 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9) | |
284 | 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10) | |
285 | 12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11) | |
286 | 13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12) | |
287 | 14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13) | |
288 | 15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14) | |
289 | 16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15) | |
290 | } | |
291 | ||
292 | //////////////////////////////////////////////////////////////////////////////// | |
293 | ||
294 | #[cfg(any(feature = "std", feature = "alloc"))] | |
295 | macro_rules! map_impl { | |
296 | ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => { | |
297 | impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*> | |
298 | where | |
299 | K: Serialize $(+ $kbound1 $(+ $kbound2)*)*, | |
300 | V: Serialize, | |
301 | $($typaram: $bound,)* | |
302 | { | |
303 | #[inline] | |
304 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
305 | where | |
306 | S: Serializer, | |
307 | { | |
308 | serializer.collect_map(self) | |
309 | } | |
310 | } | |
311 | } | |
312 | } | |
313 | ||
314 | #[cfg(any(feature = "std", feature = "alloc"))] | |
315 | map_impl!(BTreeMap<K: Ord, V>); | |
316 | ||
317 | #[cfg(feature = "std")] | |
318 | map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>); | |
319 | ||
320 | //////////////////////////////////////////////////////////////////////////////// | |
321 | ||
322 | macro_rules! deref_impl { | |
323 | ($($desc:tt)+) => { | |
324 | impl $($desc)+ { | |
325 | #[inline] | |
326 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
327 | where | |
328 | S: Serializer, | |
329 | { | |
330 | (**self).serialize(serializer) | |
331 | } | |
332 | } | |
333 | }; | |
334 | } | |
335 | ||
336 | deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize); | |
337 | deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize); | |
338 | ||
339 | #[cfg(any(feature = "std", feature = "alloc"))] | |
340 | deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize); | |
341 | ||
342 | #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] | |
ea8adc8c | 343 | deref_impl!(<T: ?Sized> Serialize for Rc<T> where T: Serialize); |
041b39d2 XL |
344 | |
345 | #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] | |
ea8adc8c | 346 | deref_impl!(<T: ?Sized> Serialize for Arc<T> where T: Serialize); |
041b39d2 XL |
347 | |
348 | #[cfg(any(feature = "std", feature = "alloc"))] | |
349 | deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned); | |
350 | ||
351 | //////////////////////////////////////////////////////////////////////////////// | |
352 | ||
353 | #[cfg(feature = "unstable")] | |
354 | impl<T> Serialize for NonZero<T> | |
355 | where | |
356 | T: Serialize + Zeroable + Clone, | |
357 | { | |
358 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
359 | where | |
360 | S: Serializer, | |
361 | { | |
362 | self.clone().get().serialize(serializer) | |
363 | } | |
364 | } | |
365 | ||
366 | impl<T> Serialize for Cell<T> | |
367 | where | |
368 | T: Serialize + Copy, | |
369 | { | |
370 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
371 | where | |
372 | S: Serializer, | |
373 | { | |
374 | self.get().serialize(serializer) | |
375 | } | |
376 | } | |
377 | ||
378 | impl<T> Serialize for RefCell<T> | |
379 | where | |
380 | T: Serialize, | |
381 | { | |
382 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
383 | where | |
384 | S: Serializer, | |
385 | { | |
386 | self.borrow().serialize(serializer) | |
387 | } | |
388 | } | |
389 | ||
390 | #[cfg(feature = "std")] | |
391 | impl<T> Serialize for Mutex<T> | |
392 | where | |
393 | T: Serialize, | |
394 | { | |
395 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
396 | where | |
397 | S: Serializer, | |
398 | { | |
399 | match self.lock() { | |
400 | Ok(locked) => locked.serialize(serializer), | |
401 | Err(_) => Err(S::Error::custom("lock poison error while serializing")), | |
402 | } | |
403 | } | |
404 | } | |
405 | ||
406 | #[cfg(feature = "std")] | |
407 | impl<T> Serialize for RwLock<T> | |
408 | where | |
409 | T: Serialize, | |
410 | { | |
411 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
412 | where | |
413 | S: Serializer, | |
414 | { | |
415 | match self.read() { | |
416 | Ok(locked) => locked.serialize(serializer), | |
417 | Err(_) => Err(S::Error::custom("lock poison error while serializing")), | |
418 | } | |
419 | } | |
420 | } | |
421 | ||
422 | //////////////////////////////////////////////////////////////////////////////// | |
423 | ||
424 | impl<T, E> Serialize for Result<T, E> | |
425 | where | |
426 | T: Serialize, | |
427 | E: Serialize, | |
428 | { | |
429 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
430 | where | |
431 | S: Serializer, | |
432 | { | |
433 | match *self { | |
434 | Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value), | |
435 | Result::Err(ref value) => { | |
436 | serializer.serialize_newtype_variant("Result", 1, "Err", value) | |
437 | } | |
438 | } | |
439 | } | |
440 | } | |
441 | ||
442 | //////////////////////////////////////////////////////////////////////////////// | |
443 | ||
444 | #[cfg(feature = "std")] | |
445 | impl Serialize for Duration { | |
446 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
447 | where | |
448 | S: Serializer, | |
449 | { | |
450 | use super::SerializeStruct; | |
451 | let mut state = try!(serializer.serialize_struct("Duration", 2)); | |
452 | try!(state.serialize_field("secs", &self.as_secs())); | |
453 | try!(state.serialize_field("nanos", &self.subsec_nanos())); | |
454 | state.end() | |
455 | } | |
456 | } | |
457 | ||
458 | //////////////////////////////////////////////////////////////////////////////// | |
459 | ||
460 | #[cfg(feature = "std")] | |
461 | impl Serialize for SystemTime { | |
462 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
463 | where | |
464 | S: Serializer, | |
465 | { | |
466 | use super::SerializeStruct; | |
467 | let duration_since_epoch = self.duration_since(UNIX_EPOCH).expect("SystemTime must be later than UNIX_EPOCH"); | |
468 | let mut state = try!(serializer.serialize_struct("SystemTime", 2)); | |
469 | try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs())); | |
470 | try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos())); | |
471 | state.end() | |
472 | } | |
473 | } | |
474 | ||
475 | //////////////////////////////////////////////////////////////////////////////// | |
476 | ||
477 | /// Serialize a value that implements `Display` as a string, when that string is | |
478 | /// statically known to never have more than a constant `MAX_LEN` bytes. | |
479 | /// | |
480 | /// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes. | |
481 | #[cfg(feature = "std")] | |
482 | macro_rules! serialize_display_bounded_length { | |
483 | ($value:expr, $max:expr, $serializer:expr) => {{ | |
484 | let mut buffer: [u8; $max] = unsafe { mem::uninitialized() }; | |
485 | let remaining_len = { | |
486 | let mut remaining = &mut buffer[..]; | |
487 | write!(remaining, "{}", $value).unwrap(); | |
488 | remaining.len() | |
489 | }; | |
490 | let written_len = buffer.len() - remaining_len; | |
491 | let written = &buffer[..written_len]; | |
492 | ||
493 | // write! only provides fmt::Formatter to Display implementations, which | |
494 | // has methods write_str and write_char but no method to write arbitrary | |
495 | // bytes. Therefore `written` must be valid UTF-8. | |
496 | let written_str = unsafe { | |
497 | str::from_utf8_unchecked(written) | |
498 | }; | |
499 | $serializer.serialize_str(written_str) | |
500 | }} | |
501 | } | |
502 | ||
503 | #[cfg(feature = "std")] | |
504 | impl Serialize for net::IpAddr { | |
505 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
506 | where | |
507 | S: Serializer, | |
508 | { | |
abe05a73 XL |
509 | if serializer.is_human_readable() { |
510 | match *self { | |
511 | net::IpAddr::V4(ref a) => a.serialize(serializer), | |
512 | net::IpAddr::V6(ref a) => a.serialize(serializer), | |
513 | } | |
514 | } else { | |
515 | match *self { | |
516 | net::IpAddr::V4(ref a) => | |
517 | serializer.serialize_newtype_variant("IpAddr", 0, "V4", a), | |
518 | net::IpAddr::V6(ref a) => | |
519 | serializer.serialize_newtype_variant("IpAddr", 1, "V6", a), | |
520 | } | |
041b39d2 XL |
521 | } |
522 | } | |
523 | } | |
524 | ||
525 | #[cfg(feature = "std")] | |
526 | impl Serialize for net::Ipv4Addr { | |
527 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
528 | where | |
529 | S: Serializer, | |
530 | { | |
abe05a73 XL |
531 | if serializer.is_human_readable() { |
532 | const MAX_LEN: usize = 15; | |
533 | debug_assert_eq!(MAX_LEN, "101.102.103.104".len()); | |
534 | serialize_display_bounded_length!(self, MAX_LEN, serializer) | |
535 | } else { | |
536 | self.octets().serialize(serializer) | |
537 | } | |
041b39d2 XL |
538 | } |
539 | } | |
540 | ||
541 | #[cfg(feature = "std")] | |
542 | impl Serialize for net::Ipv6Addr { | |
543 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
544 | where | |
545 | S: Serializer, | |
546 | { | |
abe05a73 XL |
547 | if serializer.is_human_readable() { |
548 | const MAX_LEN: usize = 39; | |
549 | debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len()); | |
550 | serialize_display_bounded_length!(self, MAX_LEN, serializer) | |
551 | } else { | |
552 | self.octets().serialize(serializer) | |
553 | } | |
041b39d2 XL |
554 | } |
555 | } | |
556 | ||
557 | #[cfg(feature = "std")] | |
558 | impl Serialize for net::SocketAddr { | |
559 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
560 | where | |
561 | S: Serializer, | |
562 | { | |
abe05a73 XL |
563 | if serializer.is_human_readable() { |
564 | match *self { | |
565 | net::SocketAddr::V4(ref addr) => addr.serialize(serializer), | |
566 | net::SocketAddr::V6(ref addr) => addr.serialize(serializer), | |
567 | } | |
568 | } else { | |
569 | match *self { | |
570 | net::SocketAddr::V4(ref addr) => | |
571 | serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr), | |
572 | net::SocketAddr::V6(ref addr) => | |
573 | serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr), | |
574 | } | |
041b39d2 XL |
575 | } |
576 | } | |
577 | } | |
578 | ||
579 | #[cfg(feature = "std")] | |
580 | impl Serialize for net::SocketAddrV4 { | |
581 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
582 | where | |
583 | S: Serializer, | |
584 | { | |
abe05a73 XL |
585 | if serializer.is_human_readable() { |
586 | const MAX_LEN: usize = 21; | |
587 | debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len()); | |
588 | serialize_display_bounded_length!(self, MAX_LEN, serializer) | |
589 | } else { | |
590 | (self.ip(), self.port()).serialize(serializer) | |
591 | } | |
041b39d2 XL |
592 | } |
593 | } | |
594 | ||
595 | #[cfg(feature = "std")] | |
596 | impl Serialize for net::SocketAddrV6 { | |
597 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
598 | where | |
599 | S: Serializer, | |
600 | { | |
abe05a73 XL |
601 | if serializer.is_human_readable() { |
602 | const MAX_LEN: usize = 47; | |
603 | debug_assert_eq!(MAX_LEN, "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()); | |
604 | serialize_display_bounded_length!(self, MAX_LEN, serializer) | |
605 | } else { | |
606 | (self.ip(), self.port()).serialize(serializer) | |
607 | } | |
041b39d2 XL |
608 | } |
609 | } | |
610 | ||
611 | //////////////////////////////////////////////////////////////////////////////// | |
612 | ||
613 | #[cfg(feature = "std")] | |
614 | impl Serialize for Path { | |
615 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
616 | where | |
617 | S: Serializer, | |
618 | { | |
619 | match self.to_str() { | |
620 | Some(s) => s.serialize(serializer), | |
621 | None => Err(Error::custom("path contains invalid UTF-8 characters")), | |
622 | } | |
623 | } | |
624 | } | |
625 | ||
626 | #[cfg(feature = "std")] | |
627 | impl Serialize for PathBuf { | |
628 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
629 | where | |
630 | S: Serializer, | |
631 | { | |
632 | self.as_path().serialize(serializer) | |
633 | } | |
634 | } | |
635 | ||
636 | #[cfg(all(feature = "std", any(unix, windows)))] | |
637 | impl Serialize for OsStr { | |
638 | #[cfg(unix)] | |
639 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
640 | where | |
641 | S: Serializer, | |
642 | { | |
643 | use std::os::unix::ffi::OsStrExt; | |
644 | serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes()) | |
645 | } | |
646 | ||
647 | #[cfg(windows)] | |
648 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
649 | where | |
650 | S: Serializer, | |
651 | { | |
652 | use std::os::windows::ffi::OsStrExt; | |
653 | let val = self.encode_wide().collect::<Vec<_>>(); | |
654 | serializer.serialize_newtype_variant("OsString", 1, "Windows", &val) | |
655 | } | |
656 | } | |
657 | ||
658 | #[cfg(all(feature = "std", any(unix, windows)))] | |
659 | impl Serialize for OsString { | |
660 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
661 | where | |
662 | S: Serializer, | |
663 | { | |
664 | self.as_os_str().serialize(serializer) | |
665 | } | |
666 | } | |
abe05a73 XL |
667 | |
668 | //////////////////////////////////////////////////////////////////////////////// | |
669 | ||
670 | #[cfg(feature = "std")] | |
671 | impl<T> Serialize for Wrapping<T> | |
672 | where | |
673 | T: Serialize, | |
674 | { | |
675 | #[inline] | |
676 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
677 | where | |
678 | S: Serializer, | |
679 | { | |
680 | self.0.serialize(serializer) | |
681 | } | |
682 | } |