Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 804 insertions, 0 deletions

diff --git a/third_party/rust/plist/src/ser.rs b/third_party/rust/plist/src/ser.rs
new file mode 100644
index 0000000000..039bfcfcc9
--- /dev/null
+++ b/third_party/rust/plist/src/ser.rs
@@ -0,0 +1,804 @@
+use serde::ser;
+use std::{
+    fmt::Display,
+    fs::File,
+    io::{BufWriter, Write},
+    mem,
+    path::Path,
+};
+
+use crate::{
+    date::serde_impls::DATE_NEWTYPE_STRUCT_NAME,
+    error::{self, Error, ErrorKind},
+    stream::{self, Writer},
+    uid::serde_impls::UID_NEWTYPE_STRUCT_NAME,
+    Date, Integer, Uid, XmlWriteOptions,
+};
+
+#[doc(hidden)]
+impl ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        ErrorKind::Serde(msg.to_string()).without_position()
+    }
+}
+
+enum OptionMode {
+    Root,
+    StructField(&'static str),
+    StructFieldNameWritten,
+    Explicit,
+}
+
+/// A structure that serializes Rust values plist event streams.
+pub struct Serializer<W: Writer> {
+    writer: W,
+    option_mode: OptionMode,
+}
+
+impl<W: Writer> Serializer<W> {
+    pub fn new(writer: W) -> Serializer<W> {
+        Serializer {
+            writer,
+            option_mode: OptionMode::Root,
+        }
+    }
+
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+
+    fn serialize_with_option_mode<T: ?Sized + ser::Serialize>(
+        &mut self,
+        option_mode: OptionMode,
+        value: &T,
+    ) -> Result<(), Error> {
+        let prev_option_mode = mem::replace(&mut self.option_mode, option_mode);
+        let result = value.serialize(&mut *self);
+        self.option_mode = prev_option_mode;
+        result
+    }
+
+    fn maybe_write_pending_struct_field_name(&mut self) -> Result<(), Error> {
+        if let OptionMode::StructField(field_name) = self.option_mode {
+            self.option_mode = OptionMode::StructFieldNameWritten;
+            self.writer.write_string(field_name)?;
+        }
+        Ok(())
+    }
+
+    fn write_start_array(&mut self, len: Option<u64>) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_start_array(len)
+    }
+
+    fn write_start_dictionary(&mut self, len: Option<u64>) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_start_dictionary(len)
+    }
+
+    fn write_end_collection(&mut self) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_end_collection()
+    }
+
+    fn write_boolean(&mut self, value: bool) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_boolean(value)
+    }
+
+    fn write_data(&mut self, value: &[u8]) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_data(value)
+    }
+
+    fn write_date(&mut self, value: Date) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_date(value)
+    }
+
+    fn write_integer(&mut self, value: Integer) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_integer(value)
+    }
+
+    fn write_real(&mut self, value: f64) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_real(value)
+    }
+
+    fn write_string(&mut self, value: &str) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_string(value)
+    }
+
+    fn write_uid(&mut self, value: Uid) -> Result<(), Error> {
+        self.maybe_write_pending_struct_field_name()?;
+        self.writer.write_uid(value)
+    }
+}
+
+impl<'a, W: Writer> ser::Serializer for &'a mut Serializer<W> {
+    type Ok = ();
+    type Error = Error;
+
+    type SerializeSeq = Compound<'a, W>;
+    type SerializeTuple = Compound<'a, W>;
+    type SerializeTupleStruct = Compound<'a, W>;
+    type SerializeTupleVariant = Compound<'a, W>;
+    type SerializeMap = Compound<'a, W>;
+    type SerializeStruct = Compound<'a, W>;
+    type SerializeStructVariant = Compound<'a, W>;
+
+    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
+        self.write_boolean(v)
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<(), Error> {
+        self.serialize_i64(v.into())
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<(), Error> {
+        self.serialize_i64(v.into())
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<(), Error> {
+        self.serialize_i64(v.into())
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
+        self.write_integer(v.into())
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<(), Error> {
+        self.serialize_u64(v.into())
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<(), Error> {
+        self.serialize_u64(v.into())
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<(), Error> {
+        self.serialize_u64(v.into())
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
+        self.write_integer(v.into())
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<(), Error> {
+        self.serialize_f64(v.into())
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<(), Error> {
+        self.write_real(v)
+    }
+
+    fn serialize_char(self, v: char) -> Result<(), Self::Error> {
+        let mut buf = [0; 4];
+        let v = v.encode_utf8(&mut buf);
+        self.write_string(v)
+    }
+
+    fn serialize_str(self, v: &str) -> Result<(), Error> {
+        self.write_string(v)
+    }
+
+    fn serialize_bytes(self, v: &[u8]) -> Result<(), Error> {
+        self.write_data(v)
+    }
+
+    fn serialize_none(self) -> Result<(), Error> {
+        match self.option_mode {
+            OptionMode::Root | OptionMode::StructField(_) => (),
+            OptionMode::StructFieldNameWritten => unreachable!(),
+            OptionMode::Explicit => {
+                self.write_start_dictionary(Some(1))?;
+                self.write_string("None")?;
+                self.serialize_unit()?;
+                self.write_end_collection()?;
+            }
+        }
+        Ok(())
+    }
+
+    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Error> {
+        match self.option_mode {
+            OptionMode::Root => self.serialize_with_option_mode(OptionMode::Explicit, value)?,
+            OptionMode::StructField(field_name) => {
+                self.option_mode = OptionMode::StructFieldNameWritten;
+                self.write_string(field_name)?;
+                self.serialize_with_option_mode(OptionMode::Explicit, value)?;
+            }
+            OptionMode::StructFieldNameWritten => unreachable!(),
+            OptionMode::Explicit => {
+                self.write_start_dictionary(Some(1))?;
+                self.write_string("Some")?;
+                value.serialize(&mut *self)?;
+                self.write_end_collection()?;
+            }
+        }
+        Ok(())
+    }
+
+    fn serialize_unit(self) -> Result<(), Error> {
+        self.write_string("")
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> Result<(), Error> {
+        // `plist` since v1.1 serialises unit enum variants as plain strings.
+        self.write_string(variant)
+    }
+
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+        self,
+        name: &'static str,
+        value: &T,
+    ) -> Result<(), Error> {
+        match name {
+            DATE_NEWTYPE_STRUCT_NAME => value.serialize(DateSerializer { ser: &mut *self }),
+            UID_NEWTYPE_STRUCT_NAME => value.serialize(UidSerializer { ser: &mut *self }),
+            _ => value.serialize(self),
+        }
+    }
+
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<(), Error> {
+        self.write_start_dictionary(Some(1))?;
+        self.write_string(variant)?;
+        value.serialize(&mut *self)?;
+        self.write_end_collection()
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
+        let len = len.map(|len| len as u64);
+        self.write_start_array(len)?;
+        Ok(Compound { ser: self })
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Error> {
+        self.serialize_tuple(len)
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Error> {
+        self.write_start_dictionary(Some(1))?;
+        self.write_string(variant)?;
+        self.serialize_tuple(len)
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Error> {
+        let len = len.map(|len| len as u64);
+        self.write_start_dictionary(len)?;
+        Ok(Compound { ser: self })
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Error> {
+        // The number of struct fields is not known as fields with None values are ignored.
+        self.serialize_map(None)
+    }
+
+    fn serialize_struct_variant(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStructVariant, Error> {
+        self.write_start_dictionary(Some(1))?;
+        self.write_string(variant)?;
+        self.serialize_struct(name, len)
+    }
+}
+
+struct DateSerializer<'a, W: 'a + Writer> {
+    ser: &'a mut Serializer<W>,
+}
+
+impl<'a, W: Writer> DateSerializer<'a, W> {
+    fn expecting_date_error(&self) -> Error {
+        ser::Error::custom("plist date string expected")
+    }
+}
+
+impl<'a, W: Writer> ser::Serializer for DateSerializer<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    type SerializeSeq = ser::Impossible<(), Error>;
+    type SerializeTuple = ser::Impossible<(), Error>;
+    type SerializeTupleStruct = ser::Impossible<(), Error>;
+    type SerializeTupleVariant = ser::Impossible<(), Error>;
+    type SerializeMap = ser::Impossible<(), Error>;
+    type SerializeStruct = ser::Impossible<(), Error>;
+    type SerializeStructVariant = ser::Impossible<(), Error>;
+
+    fn serialize_bool(self, _: bool) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_i8(self, _: i8) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_i16(self, _: i16) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_i32(self, _: i32) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_i64(self, _: i64) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_u8(self, _: u8) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_u16(self, _: u16) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_u32(self, _: u32) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_u64(self, _: u64) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_f32(self, _: f32) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_f64(self, _: f64) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_char(self, _: char) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_str(self, v: &str) -> Result<(), Error> {
+        let date = Date::from_rfc3339(v).map_err(|()| self.expecting_date_error())?;
+        self.ser.write_date(date)
+    }
+
+    fn serialize_bytes(self, _: &[u8]) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_none(self) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_unit(self) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+        self,
+        _: &'static str,
+        _: &T,
+    ) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: &T,
+    ) -> Result<(), Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleStruct, Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleVariant, Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Error> {
+        Err(self.expecting_date_error())
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStructVariant, Error> {
+        Err(self.expecting_date_error())
+    }
+}
+
+struct UidSerializer<'a, W: 'a + Writer> {
+    ser: &'a mut Serializer<W>,
+}
+
+impl<'a, W: Writer> UidSerializer<'a, W> {
+    fn expecting_uid_error(&self) -> Error {
+        ser::Error::custom("plist uid expected")
+    }
+}
+
+impl<'a, W: Writer> ser::Serializer for UidSerializer<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    type SerializeSeq = ser::Impossible<(), Error>;
+    type SerializeTuple = ser::Impossible<(), Error>;
+    type SerializeTupleStruct = ser::Impossible<(), Error>;
+    type SerializeTupleVariant = ser::Impossible<(), Error>;
+    type SerializeMap = ser::Impossible<(), Error>;
+    type SerializeStruct = ser::Impossible<(), Error>;
+    type SerializeStructVariant = ser::Impossible<(), Error>;
+
+    fn serialize_bool(self, _: bool) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_i8(self, _: i8) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_i16(self, _: i16) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_i32(self, _: i32) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_i64(self, _: i64) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_u8(self, _: u8) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_u16(self, _: u16) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_u32(self, _: u32) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<(), Error> {
+        self.ser.write_uid(Uid::new(v))
+    }
+
+    fn serialize_f32(self, _: f32) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_f64(self, _: f64) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_char(self, _: char) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_str(self, _: &str) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_bytes(self, _: &[u8]) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_none(self) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_unit(self) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+        self,
+        _: &'static str,
+        _: &T,
+    ) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: &T,
+    ) -> Result<(), Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleStruct, Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleVariant, Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct, Error> {
+        Err(self.expecting_uid_error())
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStructVariant, Error> {
+        Err(self.expecting_uid_error())
+    }
+}
+
+#[doc(hidden)]
+pub struct Compound<'a, W: 'a + Writer> {
+    ser: &'a mut Serializer<W>,
+}
+
+impl<'a, W: Writer> ser::SerializeSeq for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::Explicit, value)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.write_end_collection()
+    }
+}
+
+impl<'a, W: Writer> ser::SerializeTuple for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::Explicit, value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        self.ser.write_end_collection()
+    }
+}
+
+impl<'a, W: Writer> ser::SerializeTupleStruct for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::Explicit, value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        self.ser.write_end_collection()
+    }
+}
+
+impl<'a, W: Writer> ser::SerializeTupleVariant for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::Explicit, value)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.write_end_collection()?;
+        self.ser.write_end_collection()
+    }
+}
+
+impl<'a, W: Writer> ser::SerializeMap for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::Explicit, key)
+    }
+
+    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::Explicit, value)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        self.ser.write_end_collection()
+    }
+}
+
+impl<'a, W: Writer> ser::SerializeStruct for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Error> {
+        // We don't want to serialize None if the Option is a struct field as this is how null
+        // fields are represented in plists.
+        self.ser
+            .serialize_with_option_mode(OptionMode::StructField(key), value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        self.ser.write_end_collection()
+    }
+}
+
+impl<'a, W: Writer> ser::SerializeStructVariant for Compound<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Error> {
+        self.ser
+            .serialize_with_option_mode(OptionMode::StructField(key), value)
+    }
+
+    fn end(self) -> Result<(), Error> {
+        self.ser.write_end_collection()?;
+        self.ser.write_end_collection()
+    }
+}
+
+/// Serializes the given data structure to a file as a binary encoded plist.
+pub fn to_file_binary<P: AsRef<Path>, T: ser::Serialize>(path: P, value: &T) -> Result<(), Error> {
+    let mut file = File::create(path).map_err(error::from_io_without_position)?;
+    to_writer_binary(BufWriter::new(&mut file), value)?;
+    file.sync_all().map_err(error::from_io_without_position)?;
+    Ok(())
+}
+
+/// Serializes the given data structure to a file as an XML encoded plist.
+pub fn to_file_xml<P: AsRef<Path>, T: ser::Serialize>(path: P, value: &T) -> Result<(), Error> {
+    let mut file = File::create(path).map_err(error::from_io_without_position)?;
+    to_writer_xml(BufWriter::new(&mut file), value)?;
+    file.sync_all().map_err(error::from_io_without_position)?;
+    Ok(())
+}
+
+/// Serializes the given data structure to a byte stream as a binary encoded plist.
+pub fn to_writer_binary<W: Write, T: ser::Serialize>(writer: W, value: &T) -> Result<(), Error> {
+    let writer = stream::BinaryWriter::new(writer);
+    let mut ser = Serializer::new(writer);
+    value.serialize(&mut ser)
+}
+
+/// Serializes the given data structure to a byte stream as an XML encoded plist.
+pub fn to_writer_xml<W: Write, T: ser::Serialize>(writer: W, value: &T) -> Result<(), Error> {
+    to_writer_xml_with_options(writer, value, &XmlWriteOptions::default())
+}
+
+/// Serializes to a byte stream as an XML encoded plist, using custom [`XmlWriteOptions`].
+pub fn to_writer_xml_with_options<W: Write, T: ser::Serialize>(
+    writer: W,
+    value: &T,
+    options: &XmlWriteOptions,
+) -> Result<(), Error> {
+    let writer = stream::XmlWriter::new_with_options(writer, options);
+    let mut ser = Serializer::new(writer);
+    value.serialize(&mut ser)
+}