From d1b2d29528b7794b41e66fc2136e395a02f8529b Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 30 May 2024 05:59:35 +0200 Subject: Merging upstream version 1.73.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/ciborium/src/ser/mod.rs | 499 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 499 insertions(+) create mode 100644 vendor/ciborium/src/ser/mod.rs (limited to 'vendor/ciborium/src/ser/mod.rs') diff --git a/vendor/ciborium/src/ser/mod.rs b/vendor/ciborium/src/ser/mod.rs new file mode 100644 index 000000000..ff3d11846 --- /dev/null +++ b/vendor/ciborium/src/ser/mod.rs @@ -0,0 +1,499 @@ +// SPDX-License-Identifier: Apache-2.0 + +//! Serde serialization support for CBOR + +mod error; + +pub use error::Error; + +use alloc::string::ToString; + +use ciborium_io::Write; +use ciborium_ll::*; +use serde::{ser, Serialize as _}; + +struct Serializer(Encoder); + +impl From for Serializer { + #[inline] + fn from(writer: W) -> Self { + Self(writer.into()) + } +} + +impl From> for Serializer { + #[inline] + fn from(writer: Encoder) -> Self { + Self(writer) + } +} + +impl<'a, W: Write> ser::Serializer for &'a mut Serializer +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + type SerializeSeq = CollectionSerializer<'a, W>; + type SerializeTuple = CollectionSerializer<'a, W>; + type SerializeTupleStruct = CollectionSerializer<'a, W>; + type SerializeTupleVariant = CollectionSerializer<'a, W>; + type SerializeMap = CollectionSerializer<'a, W>; + type SerializeStruct = CollectionSerializer<'a, W>; + type SerializeStructVariant = CollectionSerializer<'a, W>; + + #[inline] + fn serialize_bool(self, v: bool) -> Result<(), Self::Error> { + Ok(self.0.push(match v { + false => Header::Simple(simple::FALSE), + true => Header::Simple(simple::TRUE), + })?) + } + + #[inline] + fn serialize_i8(self, v: i8) -> Result<(), Self::Error> { + self.serialize_i64(v.into()) + } + + #[inline] + fn serialize_i16(self, v: i16) -> Result<(), Self::Error> { + self.serialize_i64(v.into()) + } + + #[inline] + fn serialize_i32(self, v: i32) -> Result<(), Self::Error> { + self.serialize_i64(v.into()) + } + + #[inline] + fn serialize_i64(self, v: i64) -> Result<(), Self::Error> { + Ok(self.0.push(match v.is_negative() { + false => Header::Positive(v as u64), + true => Header::Negative(v as u64 ^ !0), + })?) + } + + #[inline] + fn serialize_i128(self, v: i128) -> Result<(), Self::Error> { + let (tag, raw) = match v.is_negative() { + false => (tag::BIGPOS, v as u128), + true => (tag::BIGNEG, v as u128 ^ !0), + }; + + match (tag, u64::try_from(raw)) { + (tag::BIGPOS, Ok(x)) => return Ok(self.0.push(Header::Positive(x))?), + (tag::BIGNEG, Ok(x)) => return Ok(self.0.push(Header::Negative(x))?), + _ => {} + } + + let bytes = raw.to_be_bytes(); + + // Skip leading zeros. + let mut slice = &bytes[..]; + while !slice.is_empty() && slice[0] == 0 { + slice = &slice[1..]; + } + + self.0.push(Header::Tag(tag))?; + self.0.push(Header::Bytes(Some(slice.len())))?; + Ok(self.0.write_all(slice)?) + } + + #[inline] + fn serialize_u8(self, v: u8) -> Result<(), Self::Error> { + self.serialize_u64(v.into()) + } + + #[inline] + fn serialize_u16(self, v: u16) -> Result<(), Self::Error> { + self.serialize_u64(v.into()) + } + + #[inline] + fn serialize_u32(self, v: u32) -> Result<(), Self::Error> { + self.serialize_u64(v.into()) + } + + #[inline] + fn serialize_u64(self, v: u64) -> Result<(), Self::Error> { + Ok(self.0.push(Header::Positive(v))?) + } + + #[inline] + fn serialize_u128(self, v: u128) -> Result<(), Self::Error> { + if let Ok(x) = u64::try_from(v) { + return self.serialize_u64(x); + } + + let bytes = v.to_be_bytes(); + + // Skip leading zeros. + let mut slice = &bytes[..]; + while !slice.is_empty() && slice[0] == 0 { + slice = &slice[1..]; + } + + self.0.push(Header::Tag(tag::BIGPOS))?; + self.0.push(Header::Bytes(Some(slice.len())))?; + Ok(self.0.write_all(slice)?) + } + + #[inline] + fn serialize_f32(self, v: f32) -> Result<(), Self::Error> { + self.serialize_f64(v.into()) + } + + #[inline] + fn serialize_f64(self, v: f64) -> Result<(), Self::Error> { + Ok(self.0.push(Header::Float(v))?) + } + + #[inline] + fn serialize_char(self, v: char) -> Result<(), Self::Error> { + self.serialize_str(&v.to_string()) + } + + #[inline] + fn serialize_str(self, v: &str) -> Result<(), Self::Error> { + let bytes = v.as_bytes(); + self.0.push(Header::Text(bytes.len().into()))?; + Ok(self.0.write_all(bytes)?) + } + + #[inline] + fn serialize_bytes(self, v: &[u8]) -> Result<(), Self::Error> { + self.0.push(Header::Bytes(v.len().into()))?; + Ok(self.0.write_all(v)?) + } + + #[inline] + fn serialize_none(self) -> Result<(), Self::Error> { + Ok(self.0.push(Header::Simple(simple::NULL))?) + } + + #[inline] + fn serialize_some(self, value: &U) -> Result<(), Self::Error> { + value.serialize(self) + } + + #[inline] + fn serialize_unit(self) -> Result<(), Self::Error> { + self.serialize_none() + } + + #[inline] + fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> { + self.serialize_unit() + } + + #[inline] + fn serialize_unit_variant( + self, + _name: &'static str, + _index: u32, + variant: &'static str, + ) -> Result<(), Self::Error> { + self.serialize_str(variant) + } + + #[inline] + fn serialize_newtype_struct( + self, + _name: &'static str, + value: &U, + ) -> Result<(), Self::Error> { + value.serialize(self) + } + + #[inline] + fn serialize_newtype_variant( + self, + name: &'static str, + _index: u32, + variant: &'static str, + value: &U, + ) -> Result<(), Self::Error> { + if name != "@@TAG@@" || variant != "@@UNTAGGED@@" { + self.0.push(Header::Map(Some(1)))?; + self.serialize_str(variant)?; + } + + value.serialize(self) + } + + #[inline] + fn serialize_seq(self, length: Option) -> Result { + self.0.push(Header::Array(length))?; + Ok(CollectionSerializer { + encoder: self, + ending: length.is_none(), + tag: false, + }) + } + + #[inline] + fn serialize_tuple(self, length: usize) -> Result { + self.serialize_seq(Some(length)) + } + + #[inline] + fn serialize_tuple_struct( + self, + _name: &'static str, + length: usize, + ) -> Result { + self.serialize_seq(Some(length)) + } + + #[inline] + fn serialize_tuple_variant( + self, + name: &'static str, + _index: u32, + variant: &'static str, + length: usize, + ) -> Result { + match (name, variant) { + ("@@TAG@@", "@@TAGGED@@") => Ok(CollectionSerializer { + encoder: self, + ending: false, + tag: true, + }), + + _ => { + self.0.push(Header::Map(Some(1)))?; + self.serialize_str(variant)?; + self.0.push(Header::Array(Some(length)))?; + Ok(CollectionSerializer { + encoder: self, + ending: false, + tag: false, + }) + } + } + } + + #[inline] + fn serialize_map(self, length: Option) -> Result { + self.0.push(Header::Map(length))?; + Ok(CollectionSerializer { + encoder: self, + ending: length.is_none(), + tag: false, + }) + } + + #[inline] + fn serialize_struct( + self, + _name: &'static str, + length: usize, + ) -> Result { + self.0.push(Header::Map(Some(length)))?; + Ok(CollectionSerializer { + encoder: self, + ending: false, + tag: false, + }) + } + + #[inline] + fn serialize_struct_variant( + self, + _name: &'static str, + _index: u32, + variant: &'static str, + length: usize, + ) -> Result { + self.0.push(Header::Map(Some(1)))?; + self.serialize_str(variant)?; + self.0.push(Header::Map(Some(length)))?; + Ok(CollectionSerializer { + encoder: self, + ending: false, + tag: false, + }) + } + + #[inline] + fn is_human_readable(&self) -> bool { + false + } +} + +macro_rules! end { + () => { + #[inline] + fn end(self) -> Result<(), Self::Error> { + if self.ending { + self.encoder.0.push(Header::Break)?; + } + + Ok(()) + } + }; +} + +struct CollectionSerializer<'a, W: Write> { + encoder: &'a mut Serializer, + ending: bool, + tag: bool, +} + +impl<'a, W: Write> ser::SerializeSeq for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element( + &mut self, + value: &U, + ) -> Result<(), Self::Error> { + value.serialize(&mut *self.encoder) + } + + end!(); +} + +impl<'a, W: Write> ser::SerializeTuple for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element( + &mut self, + value: &U, + ) -> Result<(), Self::Error> { + value.serialize(&mut *self.encoder) + } + + end!(); +} + +impl<'a, W: Write> ser::SerializeTupleStruct for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field( + &mut self, + value: &U, + ) -> Result<(), Self::Error> { + value.serialize(&mut *self.encoder) + } + + end!(); +} + +impl<'a, W: Write> ser::SerializeTupleVariant for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field( + &mut self, + value: &U, + ) -> Result<(), Self::Error> { + if !self.tag { + return value.serialize(&mut *self.encoder); + } + + self.tag = false; + match value.serialize(crate::tag::Serializer) { + Ok(x) => Ok(self.encoder.0.push(Header::Tag(x))?), + _ => Err(Error::Value("expected tag".into())), + } + } + + end!(); +} + +impl<'a, W: Write> ser::SerializeMap for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_key(&mut self, key: &U) -> Result<(), Self::Error> { + key.serialize(&mut *self.encoder) + } + + #[inline] + fn serialize_value( + &mut self, + value: &U, + ) -> Result<(), Self::Error> { + value.serialize(&mut *self.encoder) + } + + end!(); +} + +impl<'a, W: Write> ser::SerializeStruct for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field( + &mut self, + key: &'static str, + value: &U, + ) -> Result<(), Self::Error> { + key.serialize(&mut *self.encoder)?; + value.serialize(&mut *self.encoder)?; + Ok(()) + } + + end!(); +} + +impl<'a, W: Write> ser::SerializeStructVariant for CollectionSerializer<'a, W> +where + W::Error: core::fmt::Debug, +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field( + &mut self, + key: &'static str, + value: &U, + ) -> Result<(), Self::Error> { + key.serialize(&mut *self.encoder)?; + value.serialize(&mut *self.encoder) + } + + end!(); +} + +/// Serializes as CBOR into a type with [`impl ciborium_io::Write`](ciborium_io::Write) +#[inline] +pub fn into_writer( + value: &T, + writer: W, +) -> Result<(), Error> +where + W::Error: core::fmt::Debug, +{ + let mut encoder = Serializer::from(writer); + value.serialize(&mut encoder) +} -- cgit v1.2.3