diff options
Diffstat (limited to 'third_party/rust/serde_cbor/src/ser.rs')
-rw-r--r-- | third_party/rust/serde_cbor/src/ser.rs | 743 |
1 files changed, 743 insertions, 0 deletions
diff --git a/third_party/rust/serde_cbor/src/ser.rs b/third_party/rust/serde_cbor/src/ser.rs new file mode 100644 index 0000000000..7016dc340a --- /dev/null +++ b/third_party/rust/serde_cbor/src/ser.rs @@ -0,0 +1,743 @@ +//! Serialize a Rust data structure to CBOR data. + +#[cfg(feature = "alloc")] +use alloc::vec::Vec; + +#[cfg(feature = "std")] +pub use crate::write::IoWrite; +pub use crate::write::{SliceWrite, Write}; + +use crate::error::{Error, Result}; +use half::f16; +use serde::ser::{self, Serialize}; +#[cfg(feature = "std")] +use std::io; + +use crate::tags::{get_tag, CBOR_NEWTYPE_NAME}; + +/// Serializes a value to a vector. +#[cfg(any(feature = "std", feature = "alloc"))] +pub fn to_vec<T>(value: &T) -> Result<Vec<u8>> +where + T: ser::Serialize, +{ + let mut vec = Vec::new(); + value.serialize(&mut Serializer::new(&mut vec))?; + Ok(vec) +} + +/// Serializes a value to a vector in packed format. +#[cfg(feature = "std")] +pub fn to_vec_packed<T>(value: &T) -> Result<Vec<u8>> +where + T: ser::Serialize, +{ + let mut vec = Vec::new(); + value.serialize(&mut Serializer::new(&mut IoWrite::new(&mut vec)).packed_format())?; + Ok(vec) +} + +/// Serializes a value to a writer. +#[cfg(feature = "std")] +pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()> +where + W: io::Write, + T: ser::Serialize, +{ + value.serialize(&mut Serializer::new(&mut IoWrite::new(writer))) +} + +/// A structure for serializing Rust values to CBOR. +#[derive(Debug)] +pub struct Serializer<W> { + writer: W, + packed: bool, + enum_as_map: bool, +} + +impl<W> Serializer<W> +where + W: Write, +{ + /// Creates a new CBOR serializer. + /// + /// `to_vec` and `to_writer` should normally be used instead of this method. + #[inline] + pub fn new(writer: W) -> Self { + Serializer { + writer, + packed: false, + enum_as_map: true, + } + } + + /// Choose concise/packed format for serializer. + /// + /// In the packed format enum variant names and field names + /// are replaced with numeric indizes to conserve space. + pub fn packed_format(mut self) -> Self { + self.packed = true; + self + } + + /// Enable old enum format used by `serde_cbor` versions <= v0.9. + /// + /// The `legacy_enums` option determines how enums are encoded. + /// + /// This makes no difference when encoding and decoding enums using + /// this crate, but it shows up when decoding to a `Value` or decoding + /// in other languages. + /// + /// # Examples + /// + /// Given the following enum + /// + /// ```rust + /// enum Enum { + /// Unit, + /// NewType(i32), + /// Tuple(String, bool), + /// Struct{ x: i32, y: i32 }, + /// } + /// ``` + /// we will give the `Value` with the same encoding for each case using + /// JSON notation. + /// + /// ## Default encodings + /// + /// * `Enum::Unit` encodes as `"Unit"` + /// * `Enum::NewType(10)` encodes as `{"NewType": 10}` + /// * `Enum::Tuple("x", true)` encodes as `{"Tuple": ["x", true]}` + /// + /// ## Legacy encodings + /// + /// * `Enum::Unit` encodes as `"Unit"` + /// * `Enum::NewType(10)` encodes as `["NewType", 10]` + /// * `Enum::Tuple("x", true)` encodes as `["Tuple", "x", true]` + /// * `Enum::Struct{ x: 5, y: -5 }` encodes as `["Struct", {"x": 5, "y": -5}]` + pub fn legacy_enums(mut self) -> Self { + self.enum_as_map = false; + self + } + + /// Writes a CBOR self-describe tag to the stream. + /// + /// Tagging allows a decoder to distinguish different file formats based on their content + /// without further information. + #[inline] + pub fn self_describe(&mut self) -> Result<()> { + let mut buf = [6 << 5 | 25, 0, 0]; + (&mut buf[1..]).copy_from_slice(&55799u16.to_be_bytes()); + self.writer.write_all(&buf).map_err(|e| e.into()) + } + + /// Unwrap the `Writer` from the `Serializer`. + #[inline] + pub fn into_inner(self) -> W { + self.writer + } + + #[inline] + fn write_u8(&mut self, major: u8, value: u8) -> Result<()> { + if value <= 0x17 { + self.writer.write_all(&[major << 5 | value]) + } else { + let buf = [major << 5 | 24, value]; + self.writer.write_all(&buf) + } + .map_err(|e| e.into()) + } + + #[inline] + fn write_u16(&mut self, major: u8, value: u16) -> Result<()> { + if value <= u16::from(u8::max_value()) { + self.write_u8(major, value as u8) + } else { + let mut buf = [major << 5 | 25, 0, 0]; + (&mut buf[1..]).copy_from_slice(&value.to_be_bytes()); + self.writer.write_all(&buf).map_err(|e| e.into()) + } + } + + #[inline] + fn write_u32(&mut self, major: u8, value: u32) -> Result<()> { + if value <= u32::from(u16::max_value()) { + self.write_u16(major, value as u16) + } else { + let mut buf = [major << 5 | 26, 0, 0, 0, 0]; + (&mut buf[1..]).copy_from_slice(&value.to_be_bytes()); + self.writer.write_all(&buf).map_err(|e| e.into()) + } + } + + #[inline] + fn write_u64(&mut self, major: u8, value: u64) -> Result<()> { + if value <= u64::from(u32::max_value()) { + self.write_u32(major, value as u32) + } else { + let mut buf = [major << 5 | 27, 0, 0, 0, 0, 0, 0, 0, 0]; + (&mut buf[1..]).copy_from_slice(&value.to_be_bytes()); + self.writer.write_all(&buf).map_err(|e| e.into()) + } + } + + #[inline] + fn serialize_collection<'a>( + &'a mut self, + major: u8, + len: Option<usize>, + ) -> Result<CollectionSerializer<'a, W>> { + let needs_eof = match len { + Some(len) => { + self.write_u64(major, len as u64)?; + false + } + None => { + self.writer + .write_all(&[major << 5 | 31]) + .map_err(|e| e.into())?; + true + } + }; + + Ok(CollectionSerializer { + ser: self, + needs_eof, + }) + } +} + +impl<'a, W> ser::Serializer for &'a mut Serializer<W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + type SerializeSeq = CollectionSerializer<'a, W>; + type SerializeTuple = &'a mut Serializer<W>; + type SerializeTupleStruct = &'a mut Serializer<W>; + type SerializeTupleVariant = &'a mut Serializer<W>; + type SerializeMap = CollectionSerializer<'a, W>; + type SerializeStruct = StructSerializer<'a, W>; + type SerializeStructVariant = StructSerializer<'a, W>; + + #[inline] + fn serialize_bool(self, value: bool) -> Result<()> { + let value = if value { 0xf5 } else { 0xf4 }; + self.writer.write_all(&[value]).map_err(|e| e.into()) + } + + #[inline] + fn serialize_i8(self, value: i8) -> Result<()> { + if value < 0 { + self.write_u8(1, -(value + 1) as u8) + } else { + self.write_u8(0, value as u8) + } + } + + #[inline] + fn serialize_i16(self, value: i16) -> Result<()> { + if value < 0 { + self.write_u16(1, -(value + 1) as u16) + } else { + self.write_u16(0, value as u16) + } + } + + #[inline] + fn serialize_i32(self, value: i32) -> Result<()> { + if value < 0 { + self.write_u32(1, -(value + 1) as u32) + } else { + self.write_u32(0, value as u32) + } + } + + #[inline] + fn serialize_i64(self, value: i64) -> Result<()> { + if value < 0 { + self.write_u64(1, -(value + 1) as u64) + } else { + self.write_u64(0, value as u64) + } + } + + #[inline] + fn serialize_i128(self, value: i128) -> Result<()> { + if value < 0 { + if -(value + 1) > i128::from(u64::max_value()) { + return Err(Error::message("The number can't be stored in CBOR")); + } + self.write_u64(1, -(value + 1) as u64) + } else { + if value > i128::from(u64::max_value()) { + return Err(Error::message("The number can't be stored in CBOR")); + } + self.write_u64(0, value as u64) + } + } + + #[inline] + fn serialize_u8(self, value: u8) -> Result<()> { + self.write_u8(0, value) + } + + #[inline] + fn serialize_u16(self, value: u16) -> Result<()> { + self.write_u16(0, value) + } + + #[inline] + fn serialize_u32(self, value: u32) -> Result<()> { + self.write_u32(0, value) + } + + #[inline] + fn serialize_u64(self, value: u64) -> Result<()> { + self.write_u64(0, value) + } + + #[inline] + fn serialize_u128(self, value: u128) -> Result<()> { + if value > u128::from(u64::max_value()) { + return Err(Error::message("The number can't be stored in CBOR")); + } + self.write_u64(0, value as u64) + } + + #[inline] + #[allow(clippy::float_cmp)] + fn serialize_f32(self, value: f32) -> Result<()> { + if value.is_infinite() { + if value.is_sign_positive() { + self.writer.write_all(&[0xf9, 0x7c, 0x00]) + } else { + self.writer.write_all(&[0xf9, 0xfc, 0x00]) + } + } else if value.is_nan() { + self.writer.write_all(&[0xf9, 0x7e, 0x00]) + } else if f32::from(f16::from_f32(value)) == value { + let mut buf = [0xf9, 0, 0]; + (&mut buf[1..]).copy_from_slice(&f16::from_f32(value).to_bits().to_be_bytes()); + self.writer.write_all(&buf) + } else { + let mut buf = [0xfa, 0, 0, 0, 0]; + (&mut buf[1..]).copy_from_slice(&value.to_bits().to_be_bytes()); + self.writer.write_all(&buf) + } + .map_err(|e| e.into()) + } + + #[inline] + #[allow(clippy::float_cmp)] + fn serialize_f64(self, value: f64) -> Result<()> { + if !value.is_finite() || f64::from(value as f32) == value { + self.serialize_f32(value as f32) + } else { + let mut buf = [0xfb, 0, 0, 0, 0, 0, 0, 0, 0]; + (&mut buf[1..]).copy_from_slice(&value.to_bits().to_be_bytes()); + self.writer.write_all(&buf).map_err(|e| e.into()) + } + } + + #[inline] + fn serialize_char(self, value: char) -> Result<()> { + // A char encoded as UTF-8 takes 4 bytes at most. + let mut buf = [0; 4]; + self.serialize_str(value.encode_utf8(&mut buf)) + } + + #[inline] + fn serialize_str(self, value: &str) -> Result<()> { + self.write_u64(3, value.len() as u64)?; + self.writer + .write_all(value.as_bytes()) + .map_err(|e| e.into()) + } + + #[inline] + fn serialize_bytes(self, value: &[u8]) -> Result<()> { + self.write_u64(2, value.len() as u64)?; + self.writer.write_all(value).map_err(|e| e.into()) + } + + #[inline] + fn serialize_unit(self) -> Result<()> { + self.serialize_none() + } + + #[inline] + fn serialize_some<T>(self, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + value.serialize(self) + } + + #[inline] + fn serialize_none(self) -> Result<()> { + self.writer.write_all(&[0xf6]).map_err(|e| e.into()) + } + + #[inline] + fn serialize_unit_struct(self, _name: &'static str) -> Result<()> { + self.serialize_unit() + } + + #[inline] + fn serialize_unit_variant( + self, + _name: &'static str, + variant_index: u32, + variant: &'static str, + ) -> Result<()> { + if self.packed { + self.serialize_u32(variant_index) + } else { + self.serialize_str(variant) + } + } + + #[inline] + fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + if name == CBOR_NEWTYPE_NAME { + for tag in get_tag().into_iter() { + self.write_u64(6, tag)?; + } + } + value.serialize(self) + } + + #[inline] + fn serialize_newtype_variant<T>( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + if self.enum_as_map { + self.write_u64(5, 1u64)?; + variant.serialize(&mut *self)?; + } else { + self.writer.write_all(&[4 << 5 | 2]).map_err(|e| e.into())?; + self.serialize_unit_variant(name, variant_index, variant)?; + } + value.serialize(self) + } + + #[inline] + fn serialize_seq(self, len: Option<usize>) -> Result<CollectionSerializer<'a, W>> { + self.serialize_collection(4, len) + } + + #[inline] + fn serialize_tuple(self, len: usize) -> Result<&'a mut Serializer<W>> { + self.write_u64(4, len as u64)?; + Ok(self) + } + + #[inline] + fn serialize_tuple_struct( + self, + _name: &'static str, + len: usize, + ) -> Result<&'a mut Serializer<W>> { + self.serialize_tuple(len) + } + + #[inline] + fn serialize_tuple_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<&'a mut Serializer<W>> { + if self.enum_as_map { + self.write_u64(5, 1u64)?; + variant.serialize(&mut *self)?; + self.serialize_tuple(len) + } else { + self.write_u64(4, (len + 1) as u64)?; + self.serialize_unit_variant(name, variant_index, variant)?; + Ok(self) + } + } + + #[inline] + fn serialize_map(self, len: Option<usize>) -> Result<CollectionSerializer<'a, W>> { + self.serialize_collection(5, len) + } + + #[cfg(not(feature = "std"))] + fn collect_str<T: ?Sized>(self, value: &T) -> Result<()> + where + T: core::fmt::Display, + { + use crate::write::FmtWrite; + use core::fmt::Write; + + let mut w = FmtWrite::new(&mut self.writer); + write!(w, "{}", value)?; + Ok(()) + } + + #[inline] + fn serialize_struct(self, _name: &'static str, len: usize) -> Result<StructSerializer<'a, W>> { + self.write_u64(5, len as u64)?; + Ok(StructSerializer { ser: self, idx: 0 }) + } + + #[inline] + fn serialize_struct_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<StructSerializer<'a, W>> { + if self.enum_as_map { + self.write_u64(5, 1u64)?; + } else { + self.writer.write_all(&[4 << 5 | 2]).map_err(|e| e.into())?; + } + self.serialize_unit_variant(name, variant_index, variant)?; + self.serialize_struct(name, len) + } + + #[inline] + fn is_human_readable(&self) -> bool { + false + } +} + +impl<'a, W> ser::SerializeTuple for &'a mut Serializer<W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element<T>(&mut self, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + value.serialize(&mut **self) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W> ser::SerializeTupleStruct for &'a mut Serializer<W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field<T>(&mut self, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + value.serialize(&mut **self) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W> ser::SerializeTupleVariant for &'a mut Serializer<W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field<T>(&mut self, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + value.serialize(&mut **self) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +#[doc(hidden)] +pub struct StructSerializer<'a, W> { + ser: &'a mut Serializer<W>, + idx: u32, +} + +impl<'a, W> StructSerializer<'a, W> +where + W: Write, +{ + #[inline] + fn serialize_field_inner<T>(&mut self, key: &'static str, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + if self.ser.packed { + self.idx.serialize(&mut *self.ser)?; + } else { + key.serialize(&mut *self.ser)?; + } + value.serialize(&mut *self.ser)?; + self.idx += 1; + Ok(()) + } + + #[inline] + fn skip_field_inner(&mut self, _: &'static str) -> Result<()> { + self.idx += 1; + Ok(()) + } + + #[inline] + fn end_inner(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W> ser::SerializeStruct for StructSerializer<'a, W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + self.serialize_field_inner(key, value) + } + + #[inline] + fn skip_field(&mut self, key: &'static str) -> Result<()> { + self.skip_field_inner(key) + } + + #[inline] + fn end(self) -> Result<()> { + self.end_inner() + } +} + +impl<'a, W> ser::SerializeStructVariant for StructSerializer<'a, W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + self.serialize_field_inner(key, value) + } + + #[inline] + fn skip_field(&mut self, key: &'static str) -> Result<()> { + self.skip_field_inner(key) + } + + #[inline] + fn end(self) -> Result<()> { + self.end_inner() + } +} + +#[doc(hidden)] +pub struct CollectionSerializer<'a, W> { + ser: &'a mut Serializer<W>, + needs_eof: bool, +} + +impl<'a, W> CollectionSerializer<'a, W> +where + W: Write, +{ + #[inline] + fn end_inner(self) -> Result<()> { + if self.needs_eof { + self.ser.writer.write_all(&[0xff]).map_err(|e| e.into()) + } else { + Ok(()) + } + } +} + +impl<'a, W> ser::SerializeSeq for CollectionSerializer<'a, W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element<T>(&mut self, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + self.end_inner() + } +} + +impl<'a, W> ser::SerializeMap for CollectionSerializer<'a, W> +where + W: Write, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_key<T>(&mut self, key: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + key.serialize(&mut *self.ser) + } + + #[inline] + fn serialize_value<T>(&mut self, value: &T) -> Result<()> + where + T: ?Sized + ser::Serialize, + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + self.end_inner() + } +} |