1 use serde::ser;
2 use std::{
3 fmt::Display,
4 fs::File,
5 io::{BufWriter, Write},
6 mem,
7 path::Path,
8 };
9
10 use crate::{
11 date::serde_impls::DATE_NEWTYPE_STRUCT_NAME,
12 error::{self, Error, ErrorKind},
13 stream::{self, Writer},
14 uid::serde_impls::UID_NEWTYPE_STRUCT_NAME,
15 Date, Integer, Uid,
16 };
17
18 #[doc(hidden)]
19 impl ser::Error for Error {
custom<T: Display>(msg: T) -> Self20 fn custom<T: Display>(msg: T) -> Self {
21 ErrorKind::Serde(msg.to_string()).without_position()
22 }
23 }
24
25 enum OptionMode {
26 Root,
27 StructField(&'static str),
28 StructFieldNameWritten,
29 Explicit,
30 }
31
32 /// A structure that serializes Rust values plist event streams.
33 pub struct Serializer<W: Writer> {
34 writer: W,
35 option_mode: OptionMode,
36 }
37
38 impl<W: Writer> Serializer<W> {
new(writer: W) -> Serializer<W>39 pub fn new(writer: W) -> Serializer<W> {
40 Serializer {
41 writer,
42 option_mode: OptionMode::Root,
43 }
44 }
45
into_inner(self) -> W46 pub fn into_inner(self) -> W {
47 self.writer
48 }
49
serialize_with_option_mode<T: ?Sized + ser::Serialize>( &mut self, option_mode: OptionMode, value: &T, ) -> Result<(), Error>50 fn serialize_with_option_mode<T: ?Sized + ser::Serialize>(
51 &mut self,
52 option_mode: OptionMode,
53 value: &T,
54 ) -> Result<(), Error> {
55 let prev_option_mode = mem::replace(&mut self.option_mode, option_mode);
56 let result = value.serialize(&mut *self);
57 self.option_mode = prev_option_mode;
58 result
59 }
60
maybe_write_pending_struct_field_name(&mut self) -> Result<(), Error>61 fn maybe_write_pending_struct_field_name(&mut self) -> Result<(), Error> {
62 if let OptionMode::StructField(field_name) = self.option_mode {
63 self.option_mode = OptionMode::StructFieldNameWritten;
64 self.writer.write_string(field_name)?;
65 }
66 Ok(())
67 }
68
write_start_array(&mut self, len: Option<u64>) -> Result<(), Error>69 fn write_start_array(&mut self, len: Option<u64>) -> Result<(), Error> {
70 self.maybe_write_pending_struct_field_name()?;
71 self.writer.write_start_array(len)
72 }
73
write_start_dictionary(&mut self, len: Option<u64>) -> Result<(), Error>74 fn write_start_dictionary(&mut self, len: Option<u64>) -> Result<(), Error> {
75 self.maybe_write_pending_struct_field_name()?;
76 self.writer.write_start_dictionary(len)
77 }
78
write_end_collection(&mut self) -> Result<(), Error>79 fn write_end_collection(&mut self) -> Result<(), Error> {
80 self.maybe_write_pending_struct_field_name()?;
81 self.writer.write_end_collection()
82 }
83
write_boolean(&mut self, value: bool) -> Result<(), Error>84 fn write_boolean(&mut self, value: bool) -> Result<(), Error> {
85 self.maybe_write_pending_struct_field_name()?;
86 self.writer.write_boolean(value)
87 }
88
write_data(&mut self, value: &[u8]) -> Result<(), Error>89 fn write_data(&mut self, value: &[u8]) -> Result<(), Error> {
90 self.maybe_write_pending_struct_field_name()?;
91 self.writer.write_data(value)
92 }
93
write_date(&mut self, value: Date) -> Result<(), Error>94 fn write_date(&mut self, value: Date) -> Result<(), Error> {
95 self.maybe_write_pending_struct_field_name()?;
96 self.writer.write_date(value)
97 }
98
write_integer(&mut self, value: Integer) -> Result<(), Error>99 fn write_integer(&mut self, value: Integer) -> Result<(), Error> {
100 self.maybe_write_pending_struct_field_name()?;
101 self.writer.write_integer(value)
102 }
103
write_real(&mut self, value: f64) -> Result<(), Error>104 fn write_real(&mut self, value: f64) -> Result<(), Error> {
105 self.maybe_write_pending_struct_field_name()?;
106 self.writer.write_real(value)
107 }
108
write_string(&mut self, value: &str) -> Result<(), Error>109 fn write_string(&mut self, value: &str) -> Result<(), Error> {
110 self.maybe_write_pending_struct_field_name()?;
111 self.writer.write_string(value)
112 }
113
write_uid(&mut self, value: Uid) -> Result<(), Error>114 fn write_uid(&mut self, value: Uid) -> Result<(), Error> {
115 self.maybe_write_pending_struct_field_name()?;
116 self.writer.write_uid(value)
117 }
118 }
119
120 impl<'a, W: Writer> ser::Serializer for &'a mut Serializer<W> {
121 type Ok = ();
122 type Error = Error;
123
124 type SerializeSeq = Compound<'a, W>;
125 type SerializeTuple = Compound<'a, W>;
126 type SerializeTupleStruct = Compound<'a, W>;
127 type SerializeTupleVariant = Compound<'a, W>;
128 type SerializeMap = Compound<'a, W>;
129 type SerializeStruct = Compound<'a, W>;
130 type SerializeStructVariant = Compound<'a, W>;
131
serialize_bool(self, v: bool) -> Result<(), Self::Error>132 fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
133 self.write_boolean(v)
134 }
135
serialize_i8(self, v: i8) -> Result<(), Error>136 fn serialize_i8(self, v: i8) -> Result<(), Error> {
137 self.serialize_i64(v.into())
138 }
139
serialize_i16(self, v: i16) -> Result<(), Error>140 fn serialize_i16(self, v: i16) -> Result<(), Error> {
141 self.serialize_i64(v.into())
142 }
143
serialize_i32(self, v: i32) -> Result<(), Error>144 fn serialize_i32(self, v: i32) -> Result<(), Error> {
145 self.serialize_i64(v.into())
146 }
147
serialize_i64(self, v: i64) -> Result<(), Self::Error>148 fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
149 self.write_integer(v.into())
150 }
151
serialize_u8(self, v: u8) -> Result<(), Error>152 fn serialize_u8(self, v: u8) -> Result<(), Error> {
153 self.serialize_u64(v.into())
154 }
155
serialize_u16(self, v: u16) -> Result<(), Error>156 fn serialize_u16(self, v: u16) -> Result<(), Error> {
157 self.serialize_u64(v.into())
158 }
159
serialize_u32(self, v: u32) -> Result<(), Error>160 fn serialize_u32(self, v: u32) -> Result<(), Error> {
161 self.serialize_u64(v.into())
162 }
163
serialize_u64(self, v: u64) -> Result<(), Self::Error>164 fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
165 self.write_integer(v.into())
166 }
167
serialize_f32(self, v: f32) -> Result<(), Error>168 fn serialize_f32(self, v: f32) -> Result<(), Error> {
169 self.serialize_f64(v.into())
170 }
171
serialize_f64(self, v: f64) -> Result<(), Error>172 fn serialize_f64(self, v: f64) -> Result<(), Error> {
173 self.write_real(v)
174 }
175
serialize_char(self, v: char) -> Result<(), Self::Error>176 fn serialize_char(self, v: char) -> Result<(), Self::Error> {
177 let mut buf = [0; 4];
178 let v = v.encode_utf8(&mut buf);
179 self.write_string(v)
180 }
181
serialize_str(self, v: &str) -> Result<(), Error>182 fn serialize_str(self, v: &str) -> Result<(), Error> {
183 self.write_string(v)
184 }
185
serialize_bytes(self, v: &[u8]) -> Result<(), Error>186 fn serialize_bytes(self, v: &[u8]) -> Result<(), Error> {
187 self.write_data(v)
188 }
189
serialize_none(self) -> Result<(), Error>190 fn serialize_none(self) -> Result<(), Error> {
191 match self.option_mode {
192 OptionMode::Root | OptionMode::StructField(_) => (),
193 OptionMode::StructFieldNameWritten => unreachable!(),
194 OptionMode::Explicit => {
195 self.write_start_dictionary(Some(1))?;
196 self.write_string("None")?;
197 self.serialize_unit()?;
198 self.write_end_collection()?;
199 }
200 }
201 Ok(())
202 }
203
serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Error>204 fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Error> {
205 match self.option_mode {
206 OptionMode::Root => self.serialize_with_option_mode(OptionMode::Explicit, value)?,
207 OptionMode::StructField(field_name) => {
208 self.option_mode = OptionMode::StructFieldNameWritten;
209 self.write_string(field_name)?;
210 self.serialize_with_option_mode(OptionMode::Explicit, value)?;
211 }
212 OptionMode::StructFieldNameWritten => unreachable!(),
213 OptionMode::Explicit => {
214 self.write_start_dictionary(Some(1))?;
215 self.write_string("Some")?;
216 value.serialize(&mut *self)?;
217 self.write_end_collection()?;
218 }
219 }
220 Ok(())
221 }
222
serialize_unit(self) -> Result<(), Error>223 fn serialize_unit(self) -> Result<(), Error> {
224 self.write_string("")
225 }
226
serialize_unit_struct(self, _name: &'static str) -> Result<(), Error>227 fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> {
228 self.serialize_unit()
229 }
230
serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<(), Error>231 fn serialize_unit_variant(
232 self,
233 _name: &'static str,
234 _variant_index: u32,
235 variant: &'static str,
236 ) -> Result<(), Error> {
237 self.write_start_dictionary(Some(1))?;
238 self.write_string(variant)?;
239 self.serialize_unit()?;
240 self.write_end_collection()
241 }
242
serialize_newtype_struct<T: ?Sized + ser::Serialize>( self, name: &'static str, value: &T, ) -> Result<(), Error>243 fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
244 self,
245 name: &'static str,
246 value: &T,
247 ) -> Result<(), Error> {
248 match name {
249 DATE_NEWTYPE_STRUCT_NAME => value.serialize(DateSerializer { ser: &mut *self }),
250 UID_NEWTYPE_STRUCT_NAME => value.serialize(UidSerializer { ser: &mut *self }),
251 _ => value.serialize(self),
252 }
253 }
254
serialize_newtype_variant<T: ?Sized + ser::Serialize>( self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T, ) -> Result<(), Error>255 fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
256 self,
257 _name: &'static str,
258 _variant_index: u32,
259 variant: &'static str,
260 value: &T,
261 ) -> Result<(), Error> {
262 self.write_start_dictionary(Some(1))?;
263 self.write_string(variant)?;
264 value.serialize(&mut *self)?;
265 self.write_end_collection()
266 }
267
serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error>268 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
269 let len = len.map(|len| len as u64);
270 self.write_start_array(len)?;
271 Ok(Compound { ser: self })
272 }
273
serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error>274 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> {
275 self.serialize_seq(Some(len))
276 }
277
serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result<Self::SerializeTupleStruct, Error>278 fn serialize_tuple_struct(
279 self,
280 _name: &'static str,
281 len: usize,
282 ) -> Result<Self::SerializeTupleStruct, Error> {
283 self.serialize_tuple(len)
284 }
285
serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result<Self::SerializeTupleVariant, Error>286 fn serialize_tuple_variant(
287 self,
288 _name: &'static str,
289 _variant_index: u32,
290 variant: &'static str,
291 len: usize,
292 ) -> Result<Self::SerializeTupleVariant, Error> {
293 self.write_start_dictionary(Some(1))?;
294 self.write_string(variant)?;
295 self.serialize_tuple(len)
296 }
297
serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Error>298 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Error> {
299 let len = len.map(|len| len as u64);
300 self.write_start_dictionary(len)?;
301 Ok(Compound { ser: self })
302 }
303
serialize_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeStruct, Error>304 fn serialize_struct(
305 self,
306 _name: &'static str,
307 _len: usize,
308 ) -> Result<Self::SerializeStruct, Error> {
309 // The number of struct fields is not known as fields with None values are ignored.
310 self.serialize_map(None)
311 }
312
serialize_struct_variant( self, name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result<Self::SerializeStructVariant, Error>313 fn serialize_struct_variant(
314 self,
315 name: &'static str,
316 _variant_index: u32,
317 variant: &'static str,
318 len: usize,
319 ) -> Result<Self::SerializeStructVariant, Error> {
320 self.write_start_dictionary(Some(1))?;
321 self.write_string(variant)?;
322 self.serialize_struct(name, len)
323 }
324 }
325
326 struct DateSerializer<'a, W: 'a + Writer> {
327 ser: &'a mut Serializer<W>,
328 }
329
330 impl<'a, W: Writer> DateSerializer<'a, W> {
expecting_date_error(&self) -> Error331 fn expecting_date_error(&self) -> Error {
332 ser::Error::custom("plist date string expected")
333 }
334 }
335
336 impl<'a, W: Writer> ser::Serializer for DateSerializer<'a, W> {
337 type Ok = ();
338 type Error = Error;
339
340 type SerializeSeq = ser::Impossible<(), Error>;
341 type SerializeTuple = ser::Impossible<(), Error>;
342 type SerializeTupleStruct = ser::Impossible<(), Error>;
343 type SerializeTupleVariant = ser::Impossible<(), Error>;
344 type SerializeMap = ser::Impossible<(), Error>;
345 type SerializeStruct = ser::Impossible<(), Error>;
346 type SerializeStructVariant = ser::Impossible<(), Error>;
347
serialize_bool(self, _: bool) -> Result<(), Error>348 fn serialize_bool(self, _: bool) -> Result<(), Error> {
349 Err(self.expecting_date_error())
350 }
351
serialize_i8(self, _: i8) -> Result<(), Error>352 fn serialize_i8(self, _: i8) -> Result<(), Error> {
353 Err(self.expecting_date_error())
354 }
355
serialize_i16(self, _: i16) -> Result<(), Error>356 fn serialize_i16(self, _: i16) -> Result<(), Error> {
357 Err(self.expecting_date_error())
358 }
359
serialize_i32(self, _: i32) -> Result<(), Error>360 fn serialize_i32(self, _: i32) -> Result<(), Error> {
361 Err(self.expecting_date_error())
362 }
363
serialize_i64(self, _: i64) -> Result<(), Error>364 fn serialize_i64(self, _: i64) -> Result<(), Error> {
365 Err(self.expecting_date_error())
366 }
367
serialize_u8(self, _: u8) -> Result<(), Error>368 fn serialize_u8(self, _: u8) -> Result<(), Error> {
369 Err(self.expecting_date_error())
370 }
371
serialize_u16(self, _: u16) -> Result<(), Error>372 fn serialize_u16(self, _: u16) -> Result<(), Error> {
373 Err(self.expecting_date_error())
374 }
375
serialize_u32(self, _: u32) -> Result<(), Error>376 fn serialize_u32(self, _: u32) -> Result<(), Error> {
377 Err(self.expecting_date_error())
378 }
379
serialize_u64(self, _: u64) -> Result<(), Error>380 fn serialize_u64(self, _: u64) -> Result<(), Error> {
381 Err(self.expecting_date_error())
382 }
383
serialize_f32(self, _: f32) -> Result<(), Error>384 fn serialize_f32(self, _: f32) -> Result<(), Error> {
385 Err(self.expecting_date_error())
386 }
387
serialize_f64(self, _: f64) -> Result<(), Error>388 fn serialize_f64(self, _: f64) -> Result<(), Error> {
389 Err(self.expecting_date_error())
390 }
391
serialize_char(self, _: char) -> Result<(), Error>392 fn serialize_char(self, _: char) -> Result<(), Error> {
393 Err(self.expecting_date_error())
394 }
395
serialize_str(self, v: &str) -> Result<(), Error>396 fn serialize_str(self, v: &str) -> Result<(), Error> {
397 let date = Date::from_rfc3339(v).map_err(|()| self.expecting_date_error())?;
398 self.ser.write_date(date)
399 }
400
serialize_bytes(self, _: &[u8]) -> Result<(), Error>401 fn serialize_bytes(self, _: &[u8]) -> Result<(), Error> {
402 Err(self.expecting_date_error())
403 }
404
serialize_none(self) -> Result<(), Error>405 fn serialize_none(self) -> Result<(), Error> {
406 Err(self.expecting_date_error())
407 }
408
serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Error>409 fn serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Error> {
410 Err(self.expecting_date_error())
411 }
412
serialize_unit(self) -> Result<(), Error>413 fn serialize_unit(self) -> Result<(), Error> {
414 Err(self.expecting_date_error())
415 }
416
serialize_unit_struct(self, _: &'static str) -> Result<(), Error>417 fn serialize_unit_struct(self, _: &'static str) -> Result<(), Error> {
418 Err(self.expecting_date_error())
419 }
420
serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<(), Error>421 fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<(), Error> {
422 Err(self.expecting_date_error())
423 }
424
serialize_newtype_struct<T: ?Sized + ser::Serialize>( self, _: &'static str, _: &T, ) -> Result<(), Error>425 fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
426 self,
427 _: &'static str,
428 _: &T,
429 ) -> Result<(), Error> {
430 Err(self.expecting_date_error())
431 }
432
serialize_newtype_variant<T: ?Sized + ser::Serialize>( self, _: &'static str, _: u32, _: &'static str, _: &T, ) -> Result<(), Error>433 fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
434 self,
435 _: &'static str,
436 _: u32,
437 _: &'static str,
438 _: &T,
439 ) -> Result<(), Error> {
440 Err(self.expecting_date_error())
441 }
442
serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Error>443 fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Error> {
444 Err(self.expecting_date_error())
445 }
446
serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Error>447 fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Error> {
448 Err(self.expecting_date_error())
449 }
450
serialize_tuple_struct( self, _: &'static str, _: usize, ) -> Result<Self::SerializeTupleStruct, Error>451 fn serialize_tuple_struct(
452 self,
453 _: &'static str,
454 _: usize,
455 ) -> Result<Self::SerializeTupleStruct, Error> {
456 Err(self.expecting_date_error())
457 }
458
serialize_tuple_variant( self, _: &'static str, _: u32, _: &'static str, _: usize, ) -> Result<Self::SerializeTupleVariant, Error>459 fn serialize_tuple_variant(
460 self,
461 _: &'static str,
462 _: u32,
463 _: &'static str,
464 _: usize,
465 ) -> Result<Self::SerializeTupleVariant, Error> {
466 Err(self.expecting_date_error())
467 }
468
serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Error>469 fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Error> {
470 Err(self.expecting_date_error())
471 }
472
serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Error>473 fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Error> {
474 Err(self.expecting_date_error())
475 }
476
serialize_struct_variant( self, _: &'static str, _: u32, _: &'static str, _: usize, ) -> Result<Self::SerializeStructVariant, Error>477 fn serialize_struct_variant(
478 self,
479 _: &'static str,
480 _: u32,
481 _: &'static str,
482 _: usize,
483 ) -> Result<Self::SerializeStructVariant, Error> {
484 Err(self.expecting_date_error())
485 }
486 }
487
488 struct UidSerializer<'a, W: 'a + Writer> {
489 ser: &'a mut Serializer<W>,
490 }
491
492 impl<'a, W: Writer> UidSerializer<'a, W> {
expecting_uid_error(&self) -> Error493 fn expecting_uid_error(&self) -> Error {
494 ser::Error::custom("plist uid expected")
495 }
496 }
497
498 impl<'a, W: Writer> ser::Serializer for UidSerializer<'a, W> {
499 type Ok = ();
500 type Error = Error;
501
502 type SerializeSeq = ser::Impossible<(), Error>;
503 type SerializeTuple = ser::Impossible<(), Error>;
504 type SerializeTupleStruct = ser::Impossible<(), Error>;
505 type SerializeTupleVariant = ser::Impossible<(), Error>;
506 type SerializeMap = ser::Impossible<(), Error>;
507 type SerializeStruct = ser::Impossible<(), Error>;
508 type SerializeStructVariant = ser::Impossible<(), Error>;
509
serialize_bool(self, _: bool) -> Result<(), Error>510 fn serialize_bool(self, _: bool) -> Result<(), Error> {
511 Err(self.expecting_uid_error())
512 }
513
serialize_i8(self, _: i8) -> Result<(), Error>514 fn serialize_i8(self, _: i8) -> Result<(), Error> {
515 Err(self.expecting_uid_error())
516 }
517
serialize_i16(self, _: i16) -> Result<(), Error>518 fn serialize_i16(self, _: i16) -> Result<(), Error> {
519 Err(self.expecting_uid_error())
520 }
521
serialize_i32(self, _: i32) -> Result<(), Error>522 fn serialize_i32(self, _: i32) -> Result<(), Error> {
523 Err(self.expecting_uid_error())
524 }
525
serialize_i64(self, _: i64) -> Result<(), Error>526 fn serialize_i64(self, _: i64) -> Result<(), Error> {
527 Err(self.expecting_uid_error())
528 }
529
serialize_u8(self, _: u8) -> Result<(), Error>530 fn serialize_u8(self, _: u8) -> Result<(), Error> {
531 Err(self.expecting_uid_error())
532 }
533
serialize_u16(self, _: u16) -> Result<(), Error>534 fn serialize_u16(self, _: u16) -> Result<(), Error> {
535 Err(self.expecting_uid_error())
536 }
537
serialize_u32(self, _: u32) -> Result<(), Error>538 fn serialize_u32(self, _: u32) -> Result<(), Error> {
539 Err(self.expecting_uid_error())
540 }
541
serialize_u64(self, v: u64) -> Result<(), Error>542 fn serialize_u64(self, v: u64) -> Result<(), Error> {
543 self.ser.write_uid(Uid::new(v))
544 }
545
serialize_f32(self, _: f32) -> Result<(), Error>546 fn serialize_f32(self, _: f32) -> Result<(), Error> {
547 Err(self.expecting_uid_error())
548 }
549
serialize_f64(self, _: f64) -> Result<(), Error>550 fn serialize_f64(self, _: f64) -> Result<(), Error> {
551 Err(self.expecting_uid_error())
552 }
553
serialize_char(self, _: char) -> Result<(), Error>554 fn serialize_char(self, _: char) -> Result<(), Error> {
555 Err(self.expecting_uid_error())
556 }
557
serialize_str(self, _: &str) -> Result<(), Error>558 fn serialize_str(self, _: &str) -> Result<(), Error> {
559 Err(self.expecting_uid_error())
560 }
561
serialize_bytes(self, _: &[u8]) -> Result<(), Error>562 fn serialize_bytes(self, _: &[u8]) -> Result<(), Error> {
563 Err(self.expecting_uid_error())
564 }
565
serialize_none(self) -> Result<(), Error>566 fn serialize_none(self) -> Result<(), Error> {
567 Err(self.expecting_uid_error())
568 }
569
serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Error>570 fn serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Error> {
571 Err(self.expecting_uid_error())
572 }
573
serialize_unit(self) -> Result<(), Error>574 fn serialize_unit(self) -> Result<(), Error> {
575 Err(self.expecting_uid_error())
576 }
577
serialize_unit_struct(self, _: &'static str) -> Result<(), Error>578 fn serialize_unit_struct(self, _: &'static str) -> Result<(), Error> {
579 Err(self.expecting_uid_error())
580 }
581
serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<(), Error>582 fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<(), Error> {
583 Err(self.expecting_uid_error())
584 }
585
serialize_newtype_struct<T: ?Sized + ser::Serialize>( self, _: &'static str, _: &T, ) -> Result<(), Error>586 fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
587 self,
588 _: &'static str,
589 _: &T,
590 ) -> Result<(), Error> {
591 Err(self.expecting_uid_error())
592 }
593
serialize_newtype_variant<T: ?Sized + ser::Serialize>( self, _: &'static str, _: u32, _: &'static str, _: &T, ) -> Result<(), Error>594 fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
595 self,
596 _: &'static str,
597 _: u32,
598 _: &'static str,
599 _: &T,
600 ) -> Result<(), Error> {
601 Err(self.expecting_uid_error())
602 }
603
serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Error>604 fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Error> {
605 Err(self.expecting_uid_error())
606 }
607
serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Error>608 fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Error> {
609 Err(self.expecting_uid_error())
610 }
611
serialize_tuple_struct( self, _: &'static str, _: usize, ) -> Result<Self::SerializeTupleStruct, Error>612 fn serialize_tuple_struct(
613 self,
614 _: &'static str,
615 _: usize,
616 ) -> Result<Self::SerializeTupleStruct, Error> {
617 Err(self.expecting_uid_error())
618 }
619
serialize_tuple_variant( self, _: &'static str, _: u32, _: &'static str, _: usize, ) -> Result<Self::SerializeTupleVariant, Error>620 fn serialize_tuple_variant(
621 self,
622 _: &'static str,
623 _: u32,
624 _: &'static str,
625 _: usize,
626 ) -> Result<Self::SerializeTupleVariant, Error> {
627 Err(self.expecting_uid_error())
628 }
629
serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Error>630 fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Error> {
631 Err(self.expecting_uid_error())
632 }
633
serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Error>634 fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Error> {
635 Err(self.expecting_uid_error())
636 }
637
serialize_struct_variant( self, _: &'static str, _: u32, _: &'static str, _: usize, ) -> Result<Self::SerializeStructVariant, Error>638 fn serialize_struct_variant(
639 self,
640 _: &'static str,
641 _: u32,
642 _: &'static str,
643 _: usize,
644 ) -> Result<Self::SerializeStructVariant, Error> {
645 Err(self.expecting_uid_error())
646 }
647 }
648
649 #[doc(hidden)]
650 pub struct Compound<'a, W: 'a + Writer> {
651 ser: &'a mut Serializer<W>,
652 }
653
654 impl<'a, W: Writer> ser::SerializeSeq for Compound<'a, W> {
655 type Ok = ();
656 type Error = Error;
657
serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error>658 fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
659 self.ser
660 .serialize_with_option_mode(OptionMode::Explicit, value)
661 }
662
end(self) -> Result<Self::Ok, Self::Error>663 fn end(self) -> Result<Self::Ok, Self::Error> {
664 self.ser.write_end_collection()
665 }
666 }
667
668 impl<'a, W: Writer> ser::SerializeTuple for Compound<'a, W> {
669 type Ok = ();
670 type Error = Error;
671
serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error>672 fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
673 self.ser
674 .serialize_with_option_mode(OptionMode::Explicit, value)
675 }
676
end(self) -> Result<(), Error>677 fn end(self) -> Result<(), Error> {
678 self.ser.write_end_collection()
679 }
680 }
681
682 impl<'a, W: Writer> ser::SerializeTupleStruct for Compound<'a, W> {
683 type Ok = ();
684 type Error = Error;
685
serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error>686 fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
687 self.ser
688 .serialize_with_option_mode(OptionMode::Explicit, value)
689 }
690
end(self) -> Result<(), Error>691 fn end(self) -> Result<(), Error> {
692 self.ser.write_end_collection()
693 }
694 }
695
696 impl<'a, W: Writer> ser::SerializeTupleVariant for Compound<'a, W> {
697 type Ok = ();
698 type Error = Error;
699
serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error>700 fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
701 self.ser
702 .serialize_with_option_mode(OptionMode::Explicit, value)
703 }
704
end(self) -> Result<Self::Ok, Self::Error>705 fn end(self) -> Result<Self::Ok, Self::Error> {
706 self.ser.write_end_collection()?;
707 self.ser.write_end_collection()
708 }
709 }
710
711 impl<'a, W: Writer> ser::SerializeMap for Compound<'a, W> {
712 type Ok = ();
713 type Error = Error;
714
serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Error>715 fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Error> {
716 self.ser
717 .serialize_with_option_mode(OptionMode::Explicit, key)
718 }
719
serialize_value<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error>720 fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
721 self.ser
722 .serialize_with_option_mode(OptionMode::Explicit, value)
723 }
724
end(self) -> Result<Self::Ok, Self::Error>725 fn end(self) -> Result<Self::Ok, Self::Error> {
726 self.ser.write_end_collection()
727 }
728 }
729
730 impl<'a, W: Writer> ser::SerializeStruct for Compound<'a, W> {
731 type Ok = ();
732 type Error = Error;
733
serialize_field<T: ?Sized + ser::Serialize>( &mut self, key: &'static str, value: &T, ) -> Result<(), Error>734 fn serialize_field<T: ?Sized + ser::Serialize>(
735 &mut self,
736 key: &'static str,
737 value: &T,
738 ) -> Result<(), Error> {
739 // We don't want to serialize None if the Option is a struct field as this is how null
740 // fields are represented in plists.
741 self.ser
742 .serialize_with_option_mode(OptionMode::StructField(key), value)
743 }
744
end(self) -> Result<(), Error>745 fn end(self) -> Result<(), Error> {
746 self.ser.write_end_collection()
747 }
748 }
749
750 impl<'a, W: Writer> ser::SerializeStructVariant for Compound<'a, W> {
751 type Ok = ();
752 type Error = Error;
753
serialize_field<T: ?Sized + ser::Serialize>( &mut self, key: &'static str, value: &T, ) -> Result<(), Error>754 fn serialize_field<T: ?Sized + ser::Serialize>(
755 &mut self,
756 key: &'static str,
757 value: &T,
758 ) -> Result<(), Error> {
759 self.ser
760 .serialize_with_option_mode(OptionMode::StructField(key), value)
761 }
762
end(self) -> Result<(), Error>763 fn end(self) -> Result<(), Error> {
764 self.ser.write_end_collection()?;
765 self.ser.write_end_collection()
766 }
767 }
768
769 /// Serializes the given data structure to a file as a binary encoded plist.
to_file_binary<P: AsRef<Path>, T: ser::Serialize>(path: P, value: &T) -> Result<(), Error>770 pub fn to_file_binary<P: AsRef<Path>, T: ser::Serialize>(path: P, value: &T) -> Result<(), Error> {
771 let mut file = File::create(path).map_err(error::from_io_without_position)?;
772 to_writer_binary(BufWriter::new(&mut file), value)?;
773 file.sync_all().map_err(error::from_io_without_position)?;
774 Ok(())
775 }
776
777 /// Serializes the given data structure to a file as an XML encoded plist.
to_file_xml<P: AsRef<Path>, T: ser::Serialize>(path: P, value: &T) -> Result<(), Error>778 pub fn to_file_xml<P: AsRef<Path>, T: ser::Serialize>(path: P, value: &T) -> Result<(), Error> {
779 let mut file = File::create(path).map_err(error::from_io_without_position)?;
780 to_writer_xml(BufWriter::new(&mut file), value)?;
781 file.sync_all().map_err(error::from_io_without_position)?;
782 Ok(())
783 }
784
785 /// Serializes the given data structure to a byte stream as a binary encoded plist.
to_writer_binary<W: Write, T: ser::Serialize>(writer: W, value: &T) -> Result<(), Error>786 pub fn to_writer_binary<W: Write, T: ser::Serialize>(writer: W, value: &T) -> Result<(), Error> {
787 let writer = stream::BinaryWriter::new(writer);
788 let mut ser = Serializer::new(writer);
789 value.serialize(&mut ser)
790 }
791
792 /// Serializes the given data structure to a byte stream as an XML encoded plist.
to_writer_xml<W: Write, T: ser::Serialize>(writer: W, value: &T) -> Result<(), Error>793 pub fn to_writer_xml<W: Write, T: ser::Serialize>(writer: W, value: &T) -> Result<(), Error> {
794 let writer = stream::XmlWriter::new(writer);
795 let mut ser = Serializer::new(writer);
796 value.serialize(&mut ser)
797 }
798