diff options
Diffstat (limited to 'third_party/rust/serde_with/src')
32 files changed, 13014 insertions, 0 deletions
diff --git a/third_party/rust/serde_with/src/base64.rs b/third_party/rust/serde_with/src/base64.rs new file mode 100644 index 0000000000..e1c6490f44 --- /dev/null +++ b/third_party/rust/serde_with/src/base64.rs @@ -0,0 +1,205 @@ +//! De/Serialization of base64 encoded bytes +//! +//! This modules is only available when using the `base64` feature of the crate. +//! +//! Please check the documentation on the [`Base64`] type for details. + +use crate::{formats, DeserializeAs, SerializeAs}; +use alloc::{format, string::String, vec::Vec}; +use core::{ + convert::{TryFrom, TryInto}, + default::Default, + marker::PhantomData, +}; +use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer}; + +/// Serialize bytes with base64 +/// +/// The type serializes a sequence of bytes as a base64 string. +/// It works on any type implementing `AsRef<[u8]>` for serialization and `TryFrom<Vec<u8>>` for deserialization. +/// +/// The type allows customizing the character set and the padding behavior. +/// The `CHARSET` is a type implementing [`CharacterSet`]. +/// `PADDING` specifies if serializing should emit padding. +/// Deserialization always supports padded and unpadded formats. +/// [`formats::Padded`] emits padding and [`formats::Unpadded`] leaves it off. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::serde_as; +/// use serde_with::base64::{Base64, Bcrypt, BinHex, Standard}; +/// use serde_with::formats::{Padded, Unpadded}; +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct B64 { +/// // The default is the same as Standard character set with padding +/// #[serde_as(as = "Base64")] +/// default: Vec<u8>, +/// // Only change the character set, implies padding +/// #[serde_as(as = "Base64<BinHex>")] +/// charset_binhex: Vec<u8>, +/// +/// #[serde_as(as = "Base64<Standard, Padded>")] +/// explicit_padding: Vec<u8>, +/// #[serde_as(as = "Base64<Bcrypt, Unpadded>")] +/// no_padding: Vec<u8>, +/// } +/// +/// let b64 = B64 { +/// default: b"Hello World".to_vec(), +/// charset_binhex: b"Hello World".to_vec(), +/// explicit_padding: b"Hello World".to_vec(), +/// no_padding: b"Hello World".to_vec(), +/// }; +/// let json = serde_json::json!({ +/// "default": "SGVsbG8gV29ybGQ=", +/// "charset_binhex": "5'8VD'mI8epaD'3=", +/// "explicit_padding": "SGVsbG8gV29ybGQ=", +/// "no_padding": "QETqZE6eT07wZEO", +/// }); +/// +/// // Test serialization and deserialization +/// assert_eq!(json, serde_json::to_value(&b64).unwrap()); +/// assert_eq!(b64, serde_json::from_value(json).unwrap()); +/// # } +/// ``` + +// The padding might be better as `const PADDING: bool = true` +// https://blog.rust-lang.org/inside-rust/2021/09/06/Splitting-const-generics.html#featureconst_generics_default/ +#[derive(Copy, Clone, Debug, Default)] +pub struct Base64<CHARSET: CharacterSet = Standard, PADDING: formats::Format = formats::Padded>( + PhantomData<(CHARSET, PADDING)>, +); + +impl<T, CHARSET> SerializeAs<T> for Base64<CHARSET, formats::Padded> +where + T: AsRef<[u8]>, + CHARSET: CharacterSet, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + base64_crate::encode_config(source, base64_crate::Config::new(CHARSET::charset(), true)) + .serialize(serializer) + } +} + +impl<T, CHARSET> SerializeAs<T> for Base64<CHARSET, formats::Unpadded> +where + T: AsRef<[u8]>, + CHARSET: CharacterSet, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + base64_crate::encode_config(source, base64_crate::Config::new(CHARSET::charset(), false)) + .serialize(serializer) + } +} + +impl<'de, T, CHARSET, FORMAT> DeserializeAs<'de, T> for Base64<CHARSET, FORMAT> +where + T: TryFrom<Vec<u8>>, + CHARSET: CharacterSet, + FORMAT: formats::Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + String::deserialize(deserializer) + .and_then(|s| { + base64_crate::decode_config( + &*s, + base64_crate::Config::new(CHARSET::charset(), false), + ) + .map_err(Error::custom) + }) + .and_then(|vec: Vec<u8>| { + let length = vec.len(); + vec.try_into().map_err(|_e: T::Error| { + Error::custom(format!( + "Can't convert a Byte Vector of length {} to the output type.", + length + )) + }) + }) + } +} + +/// A base64 character set from [this list](base64_crate::CharacterSet). +pub trait CharacterSet { + /// Return a specific character set. + /// + /// Return one enum variant of the [`base64::CharacterSet`](base64_crate::CharacterSet) enum. + fn charset() -> base64_crate::CharacterSet; +} + +/// The standard character set (uses `+` and `/`). +/// +/// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3). +#[derive(Copy, Clone, Debug, Default)] +pub struct Standard; +impl CharacterSet for Standard { + fn charset() -> base64_crate::CharacterSet { + base64_crate::CharacterSet::Standard + } +} + +/// The URL safe character set (uses `-` and `_`). +/// +/// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3). +#[derive(Copy, Clone, Debug, Default)] +pub struct UrlSafe; +impl CharacterSet for UrlSafe { + fn charset() -> base64_crate::CharacterSet { + base64_crate::CharacterSet::UrlSafe + } +} + +/// The `crypt(3)` character set (uses `./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`). +/// +/// Not standardized, but folk wisdom on the net asserts that this alphabet is what crypt uses. +#[derive(Copy, Clone, Debug, Default)] +pub struct Crypt; +impl CharacterSet for Crypt { + fn charset() -> base64_crate::CharacterSet { + base64_crate::CharacterSet::Crypt + } +} + +/// The bcrypt character set (uses `./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`). +#[derive(Copy, Clone, Debug, Default)] +pub struct Bcrypt; +impl CharacterSet for Bcrypt { + fn charset() -> base64_crate::CharacterSet { + base64_crate::CharacterSet::Bcrypt + } +} + +/// The character set used in IMAP-modified UTF-7 (uses `+` and `,`). +/// +/// See [RFC 3501](https://tools.ietf.org/html/rfc3501#section-5.1.3). +#[derive(Copy, Clone, Debug, Default)] +pub struct ImapMutf7; +impl CharacterSet for ImapMutf7 { + fn charset() -> base64_crate::CharacterSet { + base64_crate::CharacterSet::ImapMutf7 + } +} + +/// The character set used in BinHex 4.0 files. +/// +/// See [BinHex 4.0 Definition](http://files.stairways.com/other/binhex-40-specs-info.txt). +#[derive(Copy, Clone, Debug, Default)] +pub struct BinHex; +impl CharacterSet for BinHex { + fn charset() -> base64_crate::CharacterSet { + base64_crate::CharacterSet::BinHex + } +} diff --git a/third_party/rust/serde_with/src/chrono.rs b/third_party/rust/serde_with/src/chrono.rs new file mode 100644 index 0000000000..d39725464f --- /dev/null +++ b/third_party/rust/serde_with/src/chrono.rs @@ -0,0 +1,516 @@ +//! De/Serialization of [chrono][] types +//! +//! This modules is only available if using the `chrono` feature of the crate. +//! +//! [chrono]: https://docs.rs/chrono/ + +use crate::{ + de::DeserializeAs, + formats::{Flexible, Format, Strict, Strictness}, + ser::SerializeAs, + utils::duration::{DurationSigned, Sign}, + DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds, + DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac, + DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds, TimestampMicroSecondsWithFrac, + TimestampMilliSeconds, TimestampMilliSecondsWithFrac, TimestampNanoSeconds, + TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac, +}; +use alloc::{format, string::String, vec::Vec}; +use chrono_crate::{DateTime, Duration, Local, NaiveDateTime, TimeZone, Utc}; +use core::fmt; +use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; + +/// Create a [`DateTime`] for the Unix Epoch using the [`Utc`] timezone +fn unix_epoch_utc() -> DateTime<Utc> { + DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc) +} + +/// Create a [`DateTime`] for the Unix Epoch using the [`Local`] timezone +fn unix_epoch_local() -> DateTime<Local> { + DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc).with_timezone(&Local) +} + +/// Create a [`NaiveDateTime`] for the Unix Epoch +fn unix_epoch_naive() -> NaiveDateTime { + NaiveDateTime::from_timestamp(0, 0) +} + +/// Deserialize a Unix timestamp with optional subsecond precision into a `DateTime<Utc>`. +/// +/// The `DateTime<Utc>` can be serialized from an integer, a float, or a string representing a number. +/// +/// # Examples +/// +/// ``` +/// # use chrono_crate::{DateTime, Utc}; +/// # use serde::Deserialize; +/// # +/// #[derive(Debug, Deserialize)] +/// struct S { +/// #[serde(with = "serde_with::chrono::datetime_utc_ts_seconds_from_any")] +/// date: DateTime<Utc>, +/// } +/// +/// // Deserializes integers +/// assert!(serde_json::from_str::<S>(r#"{ "date": 1478563200 }"#).is_ok()); +/// // floats +/// assert!(serde_json::from_str::<S>(r#"{ "date": 1478563200.123 }"#).is_ok()); +/// // and strings with numbers, for high-precision values +/// assert!(serde_json::from_str::<S>(r#"{ "date": "1478563200.123" }"#).is_ok()); +/// ``` +pub mod datetime_utc_ts_seconds_from_any { + use super::*; + use chrono_crate::{DateTime, NaiveDateTime, Utc}; + use serde::de::{Deserializer, Error, Unexpected, Visitor}; + + /// Deserialize a Unix timestamp with optional subsecond precision into a `DateTime<Utc>`. + pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error> + where + D: Deserializer<'de>, + { + struct Helper; + impl<'de> Visitor<'de> for Helper { + type Value = DateTime<Utc>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter + .write_str("an integer, float, or string with optional subsecond precision.") + } + + fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> + where + E: Error, + { + let ndt = NaiveDateTime::from_timestamp_opt(value, 0); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(Error::custom(format!( + "a timestamp which can be represented in a DateTime but received '{}'", + value + ))) + } + } + + fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> + where + E: Error, + { + let ndt = NaiveDateTime::from_timestamp_opt(value as i64, 0); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(Error::custom(format!( + "a timestamp which can be represented in a DateTime but received '{}'", + value + ))) + } + } + + fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E> + where + E: Error, + { + let seconds = value.trunc() as i64; + let nsecs = (value.fract() * 1_000_000_000_f64).abs() as u32; + let ndt = NaiveDateTime::from_timestamp_opt(seconds, nsecs); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(Error::custom(format!( + "a timestamp which can be represented in a DateTime but received '{}'", + value + ))) + } + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: Error, + { + let parts: Vec<_> = value.split('.').collect(); + + match *parts.as_slice() { + [seconds] => { + if let Ok(seconds) = seconds.parse() { + let ndt = NaiveDateTime::from_timestamp_opt(seconds, 0); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(Error::custom(format!( + "a timestamp which can be represented in a DateTime but received '{}'", + value + ))) + } + } else { + Err(Error::invalid_value(Unexpected::Str(value), &self)) + } + } + [seconds, subseconds] => { + if let Ok(seconds) = seconds.parse() { + let subseclen = subseconds.chars().count() as u32; + if subseclen > 9 { + return Err(Error::custom(format!( + "DateTimes only support nanosecond precision but '{}' has more than 9 digits.", + value + ))); + } + + if let Ok(mut subseconds) = subseconds.parse() { + // convert subseconds to nanoseconds (10^-9), require 9 places for nanoseconds + subseconds *= 10u32.pow(9 - subseclen); + let ndt = NaiveDateTime::from_timestamp_opt(seconds, subseconds); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(Error::custom(format!( + "a timestamp which can be represented in a DateTime but received '{}'", + value + ))) + } + } else { + Err(Error::invalid_value(Unexpected::Str(value), &self)) + } + } else { + Err(Error::invalid_value(Unexpected::Str(value), &self)) + } + } + + _ => Err(Error::invalid_value(Unexpected::Str(value), &self)), + } + } + } + + deserializer.deserialize_any(Helper) + } +} + +impl SerializeAs<NaiveDateTime> for DateTime<Utc> { + fn serialize_as<S>(source: &NaiveDateTime, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let datetime = DateTime::<Utc>::from_utc(*source, Utc); + datetime.serialize(serializer) + } +} + +impl<'de> DeserializeAs<'de, NaiveDateTime> for DateTime<Utc> { + fn deserialize_as<D>(deserializer: D) -> Result<NaiveDateTime, D::Error> + where + D: Deserializer<'de>, + { + DateTime::<Utc>::deserialize(deserializer).map(|datetime| datetime.naive_utc()) + } +} + +/// Convert a [`chrono::Duration`] into a [`DurationSigned`] +fn duration_into_duration_signed(dur: &Duration) -> DurationSigned { + match dur.to_std() { + Ok(dur) => DurationSigned::with_duration(Sign::Positive, dur), + Err(_) => { + if let Ok(dur) = (-*dur).to_std() { + DurationSigned::with_duration(Sign::Negative, dur) + } else { + panic!("A chrono Duration should be convertible to a DurationSigned") + } + } + } +} + +/// Convert a [`DurationSigned`] into a [`chrono::Duration`] +fn duration_from_duration_signed<'de, D>(dur: DurationSigned) -> Result<Duration, D::Error> +where + D: Deserializer<'de>, +{ + let mut chrono_dur = match Duration::from_std(dur.duration) { + Ok(dur) => dur, + Err(msg) => { + return Err(de::Error::custom(format!( + "Duration is outside of the representable range: {}", + msg + ))) + } + }; + if dur.sign.is_negative() { + chrono_dur = -chrono_dur; + } + Ok(chrono_dur) +} + +macro_rules! use_duration_signed_ser { + ( + $main_trait:ident $internal_trait:ident => + { + $ty:ty; $converter:ident => + $({ + $format:ty, $strictness:ty => + $($tbound:ident: $bound:ident $(,)?)* + })* + } + ) => { + $( + impl<$($tbound ,)*> SerializeAs<$ty> for $main_trait<$format, $strictness> + where + $($tbound: $bound,)* + { + fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let dur: DurationSigned = $converter(source); + $internal_trait::<$format, $strictness>::serialize_as( + &dur, + serializer, + ) + } + } + )* + }; + ( + $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt + ) => { + $( use_duration_signed_ser!($main_trait $internal_trait => $rest); )+ + }; +} + +fn datetime_to_duration<TZ>(source: &DateTime<TZ>) -> DurationSigned +where + TZ: TimeZone, +{ + duration_into_duration_signed(&source.clone().signed_duration_since(unix_epoch_utc())) +} + +fn naive_datetime_to_duration(source: &NaiveDateTime) -> DurationSigned { + duration_into_duration_signed(&source.signed_duration_since(unix_epoch_naive())) +} + +use_duration_signed_ser!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_into_duration_signed => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<TZ>; datetime_to_duration => + {i64, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness} + {f64, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness} + {String, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + NaiveDateTime; naive_datetime_to_duration => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +// Duration/Timestamp WITH FRACTIONS +use_duration_signed_ser!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_into_duration_signed => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + DateTime<TZ>; datetime_to_duration => + {f64, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness} + {String, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + NaiveDateTime; naive_datetime_to_duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +macro_rules! use_duration_signed_de { + ( + $main_trait:ident $internal_trait:ident => + { + $ty:ty; $converter:ident => + $({ + $format:ty, $strictness:ty => + $($tbound:ident: $bound:ident)* + })* + } + ) =>{ + $( + impl<'de, $($tbound,)*> DeserializeAs<'de, $ty> for $main_trait<$format, $strictness> + where + $($tbound: $bound,)* + { + fn deserialize_as<D>(deserializer: D) -> Result<$ty, D::Error> + where + D: Deserializer<'de>, + { + let dur: DurationSigned = $internal_trait::<$format, $strictness>::deserialize_as(deserializer)?; + $converter::<D>(dur) + } + } + )* + }; + ( + $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt + ) => { + $( use_duration_signed_de!($main_trait $internal_trait => $rest); )+ + }; +} + +fn duration_to_datetime_utc<'de, D>(dur: DurationSigned) -> Result<DateTime<Utc>, D::Error> +where + D: Deserializer<'de>, +{ + Ok(unix_epoch_utc() + duration_from_duration_signed::<D>(dur)?) +} + +fn duration_to_datetime_local<'de, D>(dur: DurationSigned) -> Result<DateTime<Local>, D::Error> +where + D: Deserializer<'de>, +{ + Ok(unix_epoch_local() + duration_from_duration_signed::<D>(dur)?) +} + +fn duration_to_naive_datetime<'de, D>(dur: DurationSigned) -> Result<NaiveDateTime, D::Error> +where + D: Deserializer<'de>, +{ + Ok(unix_epoch_naive() + duration_from_duration_signed::<D>(dur)?) +} + +// No subsecond precision +use_duration_signed_de!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_from_duration_signed => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<Utc>; duration_to_datetime_utc => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<Local>; duration_to_datetime_local => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + NaiveDateTime; duration_to_naive_datetime => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); + +// Duration/Timestamp WITH FRACTIONS +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_from_duration_signed => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + DateTime<Utc>; duration_to_datetime_utc => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + DateTime<Local>; duration_to_datetime_local => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + NaiveDateTime; duration_to_naive_datetime => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); diff --git a/third_party/rust/serde_with/src/content/mod.rs b/third_party/rust/serde_with/src/content/mod.rs new file mode 100644 index 0000000000..711af475c8 --- /dev/null +++ b/third_party/rust/serde_with/src/content/mod.rs @@ -0,0 +1,5 @@ +//! Import of the unstable private `Content` type from `serde`. +//! +//! <https://github.com/serde-rs/serde/blob/55a7cedd737278a9d75a2efd038c6f38b8c38bd6/serde/src/private/ser.rs#L338-L997> + +pub(crate) mod ser; diff --git a/third_party/rust/serde_with/src/content/ser.rs b/third_party/rust/serde_with/src/content/ser.rs new file mode 100644 index 0000000000..be02595af9 --- /dev/null +++ b/third_party/rust/serde_with/src/content/ser.rs @@ -0,0 +1,623 @@ +//! Buffer for serializing data. +//! +//! This is a copy and improvement of the `serde` private type: +//! <https://github.com/serde-rs/serde/blob/55a7cedd737278a9d75a2efd038c6f38b8c38bd6/serde/src/private/ser.rs#L338-L997> +//! The code is very stable in the `serde` crate, so no maintainability problem is expected. +//! +//! Since the type is private we copy the type here. +//! `serde` is licensed as MIT+Apache2, the same as this crate. +//! +//! This version carries improvements compared to `serde`'s version. +//! The types support 128-bit integers, which is supported for all targets in Rust 1.40+. +//! The [`ContentSerializer`] can also be configured to human readable or compact representation. + +use alloc::{borrow::ToOwned, boxed::Box, string::String, vec::Vec}; +use core::marker::PhantomData; +use serde::ser::{self, Serialize, Serializer}; + +#[derive(Debug)] +pub(crate) enum Content { + Bool(bool), + + U8(u8), + U16(u16), + U32(u32), + U64(u64), + U128(u128), + + I8(i8), + I16(i16), + I32(i32), + I64(i64), + I128(i128), + + F32(f32), + F64(f64), + + Char(char), + String(String), + Bytes(Vec<u8>), + + None, + Some(Box<Content>), + + Unit, + UnitStruct(&'static str), + UnitVariant(&'static str, u32, &'static str), + NewtypeStruct(&'static str, Box<Content>), + NewtypeVariant(&'static str, u32, &'static str, Box<Content>), + + Seq(Vec<Content>), + Tuple(Vec<Content>), + TupleStruct(&'static str, Vec<Content>), + TupleVariant(&'static str, u32, &'static str, Vec<Content>), + Map(Vec<(Content, Content)>), + Struct(&'static str, Vec<(&'static str, Content)>), + StructVariant( + &'static str, + u32, + &'static str, + Vec<(&'static str, Content)>, + ), +} + +impl Serialize for Content { + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + match *self { + Content::Bool(b) => serializer.serialize_bool(b), + Content::U8(u) => serializer.serialize_u8(u), + Content::U16(u) => serializer.serialize_u16(u), + Content::U32(u) => serializer.serialize_u32(u), + Content::U64(u) => serializer.serialize_u64(u), + Content::U128(u) => serializer.serialize_u128(u), + Content::I8(i) => serializer.serialize_i8(i), + Content::I16(i) => serializer.serialize_i16(i), + Content::I32(i) => serializer.serialize_i32(i), + Content::I64(i) => serializer.serialize_i64(i), + Content::I128(i) => serializer.serialize_i128(i), + Content::F32(f) => serializer.serialize_f32(f), + Content::F64(f) => serializer.serialize_f64(f), + Content::Char(c) => serializer.serialize_char(c), + Content::String(ref s) => serializer.serialize_str(s), + Content::Bytes(ref b) => serializer.serialize_bytes(b), + Content::None => serializer.serialize_none(), + Content::Some(ref c) => serializer.serialize_some(&**c), + Content::Unit => serializer.serialize_unit(), + Content::UnitStruct(n) => serializer.serialize_unit_struct(n), + Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v), + Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c), + Content::NewtypeVariant(n, i, v, ref c) => { + serializer.serialize_newtype_variant(n, i, v, &**c) + } + Content::Seq(ref elements) => elements.serialize(serializer), + Content::Tuple(ref elements) => { + use serde::ser::SerializeTuple; + let mut tuple = serializer.serialize_tuple(elements.len())?; + for e in elements { + tuple.serialize_element(e)?; + } + tuple.end() + } + Content::TupleStruct(n, ref fields) => { + use serde::ser::SerializeTupleStruct; + let mut ts = serializer.serialize_tuple_struct(n, fields.len())?; + for f in fields { + ts.serialize_field(f)?; + } + ts.end() + } + Content::TupleVariant(n, i, v, ref fields) => { + use serde::ser::SerializeTupleVariant; + let mut tv = serializer.serialize_tuple_variant(n, i, v, fields.len())?; + for f in fields { + tv.serialize_field(f)?; + } + tv.end() + } + Content::Map(ref entries) => { + use serde::ser::SerializeMap; + let mut map = serializer.serialize_map(Some(entries.len()))?; + for &(ref k, ref v) in entries { + map.serialize_entry(k, v)?; + } + map.end() + } + Content::Struct(n, ref fields) => { + use serde::ser::SerializeStruct; + let mut s = serializer.serialize_struct(n, fields.len())?; + for &(k, ref v) in fields { + s.serialize_field(k, v)?; + } + s.end() + } + Content::StructVariant(n, i, v, ref fields) => { + use serde::ser::SerializeStructVariant; + let mut sv = serializer.serialize_struct_variant(n, i, v, fields.len())?; + for &(k, ref v) in fields { + sv.serialize_field(k, v)?; + } + sv.end() + } + } + } +} + +pub(crate) struct ContentSerializer<E> { + is_human_readable: bool, + error: PhantomData<E>, +} + +impl<E> ContentSerializer<E> { + pub(crate) fn new(is_human_readable: bool) -> Self { + ContentSerializer { + is_human_readable, + error: PhantomData, + } + } +} + +impl<E> Default for ContentSerializer<E> { + fn default() -> Self { + Self::new(true) + } +} + +impl<E> Serializer for ContentSerializer<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + type SerializeSeq = SerializeSeq<E>; + type SerializeTuple = SerializeTuple<E>; + type SerializeTupleStruct = SerializeTupleStruct<E>; + type SerializeTupleVariant = SerializeTupleVariant<E>; + type SerializeMap = SerializeMap<E>; + type SerializeStruct = SerializeStruct<E>; + type SerializeStructVariant = SerializeStructVariant<E>; + + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + fn serialize_bool(self, v: bool) -> Result<Content, E> { + Ok(Content::Bool(v)) + } + + fn serialize_i8(self, v: i8) -> Result<Content, E> { + Ok(Content::I8(v)) + } + + fn serialize_i16(self, v: i16) -> Result<Content, E> { + Ok(Content::I16(v)) + } + + fn serialize_i32(self, v: i32) -> Result<Content, E> { + Ok(Content::I32(v)) + } + + fn serialize_i64(self, v: i64) -> Result<Content, E> { + Ok(Content::I64(v)) + } + + fn serialize_i128(self, v: i128) -> Result<Content, E> { + Ok(Content::I128(v)) + } + + fn serialize_u8(self, v: u8) -> Result<Content, E> { + Ok(Content::U8(v)) + } + + fn serialize_u16(self, v: u16) -> Result<Content, E> { + Ok(Content::U16(v)) + } + + fn serialize_u32(self, v: u32) -> Result<Content, E> { + Ok(Content::U32(v)) + } + + fn serialize_u64(self, v: u64) -> Result<Content, E> { + Ok(Content::U64(v)) + } + + fn serialize_u128(self, v: u128) -> Result<Content, E> { + Ok(Content::U128(v)) + } + + fn serialize_f32(self, v: f32) -> Result<Content, E> { + Ok(Content::F32(v)) + } + + fn serialize_f64(self, v: f64) -> Result<Content, E> { + Ok(Content::F64(v)) + } + + fn serialize_char(self, v: char) -> Result<Content, E> { + Ok(Content::Char(v)) + } + + fn serialize_str(self, value: &str) -> Result<Content, E> { + Ok(Content::String(value.to_owned())) + } + + fn serialize_bytes(self, value: &[u8]) -> Result<Content, E> { + Ok(Content::Bytes(value.to_owned())) + } + + fn serialize_none(self) -> Result<Content, E> { + Ok(Content::None) + } + + fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E> + where + T: Serialize, + { + Ok(Content::Some(Box::new(value.serialize(self)?))) + } + + fn serialize_unit(self) -> Result<Content, E> { + Ok(Content::Unit) + } + + fn serialize_unit_struct(self, name: &'static str) -> Result<Content, E> { + Ok(Content::UnitStruct(name)) + } + + fn serialize_unit_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + ) -> Result<Content, E> { + Ok(Content::UnitVariant(name, variant_index, variant)) + } + + fn serialize_newtype_struct<T: ?Sized>( + self, + name: &'static str, + value: &T, + ) -> Result<Content, E> + where + T: Serialize, + { + Ok(Content::NewtypeStruct( + name, + Box::new(value.serialize(self)?), + )) + } + + fn serialize_newtype_variant<T: ?Sized>( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result<Content, E> + where + T: Serialize, + { + Ok(Content::NewtypeVariant( + name, + variant_index, + variant, + Box::new(value.serialize(self)?), + )) + } + + fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> { + Ok(SerializeSeq { + is_human_readable: self.is_human_readable, + elements: Vec::with_capacity(len.unwrap_or(0)), + error: PhantomData, + }) + } + + fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> { + Ok(SerializeTuple { + is_human_readable: self.is_human_readable, + elements: Vec::with_capacity(len), + error: PhantomData, + }) + } + + fn serialize_tuple_struct( + self, + name: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleStruct, E> { + Ok(SerializeTupleStruct { + is_human_readable: self.is_human_readable, + name, + fields: Vec::with_capacity(len), + error: PhantomData, + }) + } + + fn serialize_tuple_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleVariant, E> { + Ok(SerializeTupleVariant { + is_human_readable: self.is_human_readable, + name, + variant_index, + variant, + fields: Vec::with_capacity(len), + error: PhantomData, + }) + } + + fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> { + Ok(SerializeMap { + is_human_readable: self.is_human_readable, + entries: Vec::with_capacity(len.unwrap_or(0)), + key: None, + error: PhantomData, + }) + } + + fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, E> { + Ok(SerializeStruct { + is_human_readable: self.is_human_readable, + name, + fields: Vec::with_capacity(len), + error: PhantomData, + }) + } + + fn serialize_struct_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<Self::SerializeStructVariant, E> { + Ok(SerializeStructVariant { + is_human_readable: self.is_human_readable, + name, + variant_index, + variant, + fields: Vec::with_capacity(len), + error: PhantomData, + }) + } +} + +pub(crate) struct SerializeSeq<E> { + is_human_readable: bool, + elements: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeSeq for SerializeSeq<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.elements.push(value); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::Seq(self.elements)) + } +} + +pub(crate) struct SerializeTuple<E> { + is_human_readable: bool, + elements: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeTuple for SerializeTuple<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.elements.push(value); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::Tuple(self.elements)) + } +} + +pub(crate) struct SerializeTupleStruct<E> { + is_human_readable: bool, + name: &'static str, + fields: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.fields.push(value); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::TupleStruct(self.name, self.fields)) + } +} + +pub(crate) struct SerializeTupleVariant<E> { + is_human_readable: bool, + name: &'static str, + variant_index: u32, + variant: &'static str, + fields: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.fields.push(value); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::TupleVariant( + self.name, + self.variant_index, + self.variant, + self.fields, + )) + } +} + +pub(crate) struct SerializeMap<E> { + is_human_readable: bool, + entries: Vec<(Content, Content)>, + key: Option<Content>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeMap for SerializeMap<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E> + where + T: Serialize, + { + let key = key.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.key = Some(key); + Ok(()) + } + + fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E> + where + T: Serialize, + { + let key = self + .key + .take() + .expect("serialize_value called before serialize_key"); + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.entries.push((key, value)); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::Map(self.entries)) + } + + fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E> + where + K: Serialize, + V: Serialize, + { + let key = key.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.entries.push((key, value)); + Ok(()) + } +} + +pub(crate) struct SerializeStruct<E> { + is_human_readable: bool, + name: &'static str, + fields: Vec<(&'static str, Content)>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeStruct for SerializeStruct<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E> + where + T: Serialize, + { + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.fields.push((key, value)); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::Struct(self.name, self.fields)) + } +} + +pub(crate) struct SerializeStructVariant<E> { + is_human_readable: bool, + name: &'static str, + variant_index: u32, + variant: &'static str, + fields: Vec<(&'static str, Content)>, + error: PhantomData<E>, +} + +impl<E> ser::SerializeStructVariant for SerializeStructVariant<E> +where + E: ser::Error, +{ + type Ok = Content; + type Error = E; + + fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E> + where + T: Serialize, + { + let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?; + self.fields.push((key, value)); + Ok(()) + } + + fn end(self) -> Result<Content, E> { + Ok(Content::StructVariant( + self.name, + self.variant_index, + self.variant, + self.fields, + )) + } +} diff --git a/third_party/rust/serde_with/src/de/const_arrays.rs b/third_party/rust/serde_with/src/de/const_arrays.rs new file mode 100644 index 0000000000..63f6d662d6 --- /dev/null +++ b/third_party/rust/serde_with/src/de/const_arrays.rs @@ -0,0 +1,338 @@ +use super::*; +use crate::utils::{MapIter, SeqIter}; +use alloc::{borrow::Cow, boxed::Box, collections::BTreeMap, string::String, vec::Vec}; +use core::{convert::TryInto, fmt, mem::MaybeUninit}; +use serde::de::*; +use std::collections::HashMap; + +// TODO this should probably be moved into the utils module when const generics are available for MSRV + +/// # Safety +/// The code follow exactly the pattern of initializing an array element-by-element from the standard library. +/// <https://doc.rust-lang.org/nightly/std/mem/union.MaybeUninit.html#initializing-an-array-element-by-element> +fn array_from_iterator<I, T, E, const N: usize>( + mut iter: I, + expected: &dyn Expected, +) -> Result<[T; N], E> +where + I: Iterator<Item = Result<T, E>>, + E: Error, +{ + fn drop_array_elems<T, const N: usize>(num: usize, mut arr: [MaybeUninit<T>; N]) { + arr[..num].iter_mut().for_each(|elem| { + // TODO This would be better with assume_init_drop nightly function + // https://github.com/rust-lang/rust/issues/63567 + unsafe { core::ptr::drop_in_place(elem.as_mut_ptr()) }; + }); + } + + // Create an uninitialized array of `MaybeUninit`. The `assume_init` is + // safe because the type we are claiming to have initialized here is a + // bunch of `MaybeUninit`s, which do not require initialization. + // + // TODO could be simplified with nightly maybe_uninit_uninit_array feature + // https://doc.rust-lang.org/nightly/std/mem/union.MaybeUninit.html#method.uninit_array + let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() }; + + // Dropping a `MaybeUninit` does nothing. Thus using raw pointer + // assignment instead of `ptr::write` does not cause the old + // uninitialized value to be dropped. Also if there is a panic during + // this loop, we have a memory leak, but there is no memory safety + // issue. + for (idx, elem) in arr[..].iter_mut().enumerate() { + *elem = match iter.next() { + Some(Ok(value)) => MaybeUninit::new(value), + Some(Err(err)) => { + drop_array_elems(idx, arr); + return Err(err); + } + None => { + drop_array_elems(idx, arr); + return Err(Error::invalid_length(idx, expected)); + } + }; + } + + // Everything is initialized. Transmute the array to the + // initialized type. + // A normal transmute is not possible because of: + // https://github.com/rust-lang/rust/issues/61956 + Ok(unsafe { core::mem::transmute_copy::<_, [T; N]>(&arr) }) +} + +impl<'de, T, As, const N: usize> DeserializeAs<'de, [T; N]> for [As; N] +where + As: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<[T; N], D::Error> + where + D: Deserializer<'de>, + { + struct ArrayVisitor<T, const M: usize>(PhantomData<T>); + + impl<'de, T, As, const M: usize> Visitor<'de> for ArrayVisitor<DeserializeAsWrap<T, As>, M> + where + As: DeserializeAs<'de, T>, + { + type Value = [T; M]; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_fmt(format_args!("an array of size {}", M)) + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + array_from_iterator( + SeqIter::new(seq).map(|res: Result<DeserializeAsWrap<T, As>, A::Error>| { + res.map(|t| t.into_inner()) + }), + &self, + ) + } + } + + deserializer.deserialize_tuple(N, ArrayVisitor::<DeserializeAsWrap<T, As>, N>(PhantomData)) + } +} + +macro_rules! tuple_seq_as_map_impl_intern { + ($tyorig:ty, $ty:ident <KAs, VAs>) => { + #[allow(clippy::implicit_hasher)] + impl<'de, K, KAs, V, VAs, const N: usize> DeserializeAs<'de, $tyorig> for $ty<KAs, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + { + fn deserialize_as<D>(deserializer: D) -> Result<$tyorig, D::Error> + where + D: Deserializer<'de>, + { + struct MapVisitor<K, KAs, V, VAs, const M: usize> { + marker: PhantomData<(K, KAs, V, VAs)>, + } + + impl<'de, K, KAs, V, VAs, const M: usize> Visitor<'de> for MapVisitor<K, KAs, V, VAs, M> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + { + type Value = [(K, V); M]; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_fmt(format_args!("a map of length {}", M)) + } + + fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + array_from_iterator(MapIter::new(access).map( + |res: Result<(DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>), A::Error>| { + res.map(|(k, v)| (k.into_inner(), v.into_inner())) + } + ), &self) + } + } + + let visitor = MapVisitor::<K, KAs, V, VAs, N> { + marker: PhantomData, + }; + deserializer.deserialize_map(visitor) + } + } + } +} +tuple_seq_as_map_impl_intern!([(K, V); N], BTreeMap<KAs, VAs>); +tuple_seq_as_map_impl_intern!([(K, V); N], HashMap<KAs, VAs>); + +impl<'de, const N: usize> DeserializeAs<'de, [u8; N]> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<[u8; N], D::Error> + where + D: Deserializer<'de>, + { + struct ArrayVisitor<const M: usize>; + + impl<'de, const M: usize> Visitor<'de> for ArrayVisitor<M> { + type Value = [u8; M]; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_fmt(format_args!("an byte array of size {}", M)) + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + array_from_iterator(SeqIter::new(seq), &self) + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: Error, + { + v.try_into() + .map_err(|_| Error::invalid_length(v.len(), &self)) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: Error, + { + v.as_bytes() + .try_into() + .map_err(|_| Error::invalid_length(v.len(), &self)) + } + } + + deserializer.deserialize_bytes(ArrayVisitor::<N>) + } +} + +impl<'de, const N: usize> DeserializeAs<'de, &'de [u8; N]> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<&'de [u8; N], D::Error> + where + D: Deserializer<'de>, + { + struct ArrayVisitor<const M: usize>; + + impl<'de, const M: usize> Visitor<'de> for ArrayVisitor<M> { + type Value = &'de [u8; M]; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_fmt(format_args!("a borrowed byte array of size {}", M)) + } + + fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E> + where + E: Error, + { + v.try_into() + .map_err(|_| Error::invalid_length(v.len(), &self)) + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: Error, + { + v.as_bytes() + .try_into() + .map_err(|_| Error::invalid_length(v.len(), &self)) + } + } + + deserializer.deserialize_bytes(ArrayVisitor::<N>) + } +} + +impl<'de, const N: usize> DeserializeAs<'de, Cow<'de, [u8; N]>> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8; N]>, D::Error> + where + D: Deserializer<'de>, + { + struct CowVisitor<const M: usize>; + + impl<'de, const M: usize> Visitor<'de> for CowVisitor<M> { + type Value = Cow<'de, [u8; M]>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a byte array") + } + + fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Borrowed( + v.try_into() + .map_err(|_| Error::invalid_length(v.len(), &self))?, + )) + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Borrowed( + v.as_bytes() + .try_into() + .map_err(|_| Error::invalid_length(v.len(), &self))?, + )) + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned( + v.to_vec() + .try_into() + .map_err(|_| Error::invalid_length(v.len(), &self))?, + )) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned( + v.as_bytes() + .to_vec() + .try_into() + .map_err(|_| Error::invalid_length(v.len(), &self))?, + )) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> + where + E: Error, + { + let len = v.len(); + Ok(Cow::Owned( + v.try_into() + .map_err(|_| Error::invalid_length(len, &self))?, + )) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: Error, + { + let len = v.len(); + Ok(Cow::Owned( + v.into_bytes() + .try_into() + .map_err(|_| Error::invalid_length(len, &self))?, + )) + } + + fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error> + where + V: SeqAccess<'de>, + { + Ok(Cow::Owned(array_from_iterator(SeqIter::new(seq), &self)?)) + } + } + + deserializer.deserialize_bytes(CowVisitor) + } +} + +impl<'de, const N: usize> DeserializeAs<'de, Box<[u8; N]>> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<Box<[u8; N]>, D::Error> + where + D: Deserializer<'de>, + { + Bytes::deserialize_as(deserializer).map(Box::new) + } +} + +impl<'de, const N: usize> DeserializeAs<'de, Cow<'de, [u8; N]>> for BorrowCow { + fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8; N]>, D::Error> + where + D: Deserializer<'de>, + { + Bytes::deserialize_as(deserializer) + } +} diff --git a/third_party/rust/serde_with/src/de/impls.rs b/third_party/rust/serde_with/src/de/impls.rs new file mode 100644 index 0000000000..fc960c3d07 --- /dev/null +++ b/third_party/rust/serde_with/src/de/impls.rs @@ -0,0 +1,1508 @@ +use super::*; +use crate::{ + formats::{Flexible, Format, Strict}, + rust::StringWithSeparator, + utils, + utils::duration::DurationSigned, +}; +use alloc::{ + borrow::{Cow, ToOwned}, + boxed::Box, + collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque}, + rc::{Rc, Weak as RcWeak}, + string::String, + sync::{Arc, Weak as ArcWeak}, + vec::Vec, +}; +use core::{ + cell::{Cell, RefCell}, + convert::TryInto, + fmt::{self, Display}, + hash::{BuildHasher, Hash}, + iter::FromIterator, + str::FromStr, + time::Duration, +}; +#[cfg(feature = "indexmap")] +use indexmap_crate::{IndexMap, IndexSet}; +use serde::de::*; +use std::{ + collections::{HashMap, HashSet}, + sync::{Mutex, RwLock}, + time::SystemTime, +}; + +/////////////////////////////////////////////////////////////////////////////// +// region: Simple Wrapper types (e.g., Box, Option) + +impl<'de, T, U> DeserializeAs<'de, Box<T>> for Box<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Box<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(Box::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, U> DeserializeAs<'de, Option<T>> for Option<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Option<T>, D::Error> + where + D: Deserializer<'de>, + { + struct OptionVisitor<T, U>(PhantomData<(T, U)>); + + impl<'de, T, U> Visitor<'de> for OptionVisitor<T, U> + where + U: DeserializeAs<'de, T>, + { + type Value = Option<T>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("option") + } + + #[inline] + fn visit_unit<E>(self) -> Result<Self::Value, E> + where + E: Error, + { + Ok(None) + } + + #[inline] + fn visit_none<E>(self) -> Result<Self::Value, E> + where + E: Error, + { + Ok(None) + } + + #[inline] + fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + U::deserialize_as(deserializer).map(Some) + } + } + + deserializer.deserialize_option(OptionVisitor::<T, U>(PhantomData)) + } +} + +impl<'de, T, U> DeserializeAs<'de, Rc<T>> for Rc<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Rc<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(Rc::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, U> DeserializeAs<'de, RcWeak<T>> for RcWeak<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<RcWeak<T>, D::Error> + where + D: Deserializer<'de>, + { + DeserializeAsWrap::<Option<Rc<T>>, Option<Rc<U>>>::deserialize(deserializer)?; + Ok(RcWeak::new()) + } +} + +impl<'de, T, U> DeserializeAs<'de, Arc<T>> for Arc<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Arc<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(Arc::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, U> DeserializeAs<'de, ArcWeak<T>> for ArcWeak<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<ArcWeak<T>, D::Error> + where + D: Deserializer<'de>, + { + DeserializeAsWrap::<Option<Arc<T>>, Option<Arc<U>>>::deserialize(deserializer)?; + Ok(ArcWeak::new()) + } +} + +impl<'de, T, U> DeserializeAs<'de, Cell<T>> for Cell<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Cell<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(Cell::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, U> DeserializeAs<'de, RefCell<T>> for RefCell<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<RefCell<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(RefCell::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, U> DeserializeAs<'de, Mutex<T>> for Mutex<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Mutex<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(Mutex::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, U> DeserializeAs<'de, RwLock<T>> for RwLock<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<RwLock<T>, D::Error> + where + D: Deserializer<'de>, + { + Ok(RwLock::new( + DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), + )) + } +} + +impl<'de, T, TAs, E, EAs> DeserializeAs<'de, Result<T, E>> for Result<TAs, EAs> +where + TAs: DeserializeAs<'de, T>, + EAs: DeserializeAs<'de, E>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Result<T, E>, D::Error> + where + D: Deserializer<'de>, + { + Ok( + match Result::<DeserializeAsWrap<T, TAs>, DeserializeAsWrap<E, EAs>>::deserialize( + deserializer, + )? { + Ok(value) => Ok(value.into_inner()), + Err(err) => Err(err.into_inner()), + }, + ) + } +} + +// endregion +/////////////////////////////////////////////////////////////////////////////// +// region: Collection Types (e.g., Maps, Sets, Vec) + +macro_rules! seq_impl { + ( + $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)* )* >, + $access:ident, + $with_capacity:expr, + $append:ident + ) => { + // Fix for clippy regression in macros on stable + // The bug no longer exists on nightly + // https://github.com/rust-lang/rust-clippy/issues/7768 + #[allow(clippy::semicolon_if_nothing_returned)] + impl<'de, T, U $(, $typaram)*> DeserializeAs<'de, $ty<T $(, $typaram)*>> for $ty<U $(, $typaram)*> + where + U: DeserializeAs<'de, T>, + $(T: $tbound1 $(+ $tbound2)*,)* + $($typaram: $bound1 $(+ $bound2)*),* + { + fn deserialize_as<D>(deserializer: D) -> Result<$ty<T $(, $typaram)*>, D::Error> + where + D: Deserializer<'de>, + { + struct SeqVisitor<T, U $(, $typaram)*> { + marker: PhantomData<(T, U $(, $typaram)*)>, + } + + impl<'de, T, U $(, $typaram)*> Visitor<'de> for SeqVisitor<T, U $(, $typaram)*> + where + U: DeserializeAs<'de, T>, + $(T: $tbound1 $(+ $tbound2)*,)* + $($typaram: $bound1 $(+ $bound2)*),* + { + type Value = $ty<T $(, $typaram)*>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let mut values = $with_capacity; + + while let Some(value) = $access + .next_element()? + .map(|v: DeserializeAsWrap<T, U>| v.into_inner()) + { + values.$append(value); + } + + Ok(values.into()) + } + } + + let visitor = SeqVisitor::<T, U $(, $typaram)*> { + marker: PhantomData, + }; + deserializer.deserialize_seq(visitor) + } + } + }; +} + +type BoxedSlice<T> = Box<[T]>; +seq_impl!( + BinaryHeap<T: Ord>, + seq, + BinaryHeap::with_capacity(utils::size_hint_cautious(seq.size_hint())), + push +); +seq_impl!( + BoxedSlice<T>, + seq, + Vec::with_capacity(utils::size_hint_cautious(seq.size_hint())), + push +); +seq_impl!(BTreeSet<T: Ord>, seq, BTreeSet::new(), insert); +seq_impl!( + HashSet<T: Eq + Hash, S: BuildHasher + Default>, + seq, + HashSet::with_capacity_and_hasher(utils::size_hint_cautious(seq.size_hint()), S::default()), + insert +); +seq_impl!(LinkedList<T>, seq, LinkedList::new(), push_back); +seq_impl!( + Vec<T>, + seq, + Vec::with_capacity(utils::size_hint_cautious(seq.size_hint())), + push +); +seq_impl!( + VecDeque<T>, + seq, + VecDeque::with_capacity(utils::size_hint_cautious(seq.size_hint())), + push_back +); +#[cfg(feature = "indexmap")] +seq_impl!( + IndexSet<T: Eq + Hash, S: BuildHasher + Default>, + seq, + IndexSet::with_capacity_and_hasher(utils::size_hint_cautious(seq.size_hint()), S::default()), + insert +); + +macro_rules! map_impl { + ( + $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >, + // We need an external name, such that we can use it in the `with_capacity` expression + $access:ident, + $with_capacity:expr + ) => { + // Fix for clippy regression in macros on stable + // The bug no longer exists on nightly + // https://github.com/rust-lang/rust-clippy/issues/7768 + #[allow(clippy::semicolon_if_nothing_returned)] + impl<'de, K, V, KU, VU $(, $typaram)*> DeserializeAs<'de, $ty<K, V $(, $typaram)*>> for $ty<KU, VU $(, $typaram)*> + where + KU: DeserializeAs<'de, K>, + VU: DeserializeAs<'de, V>, + $(K: $kbound1 $(+ $kbound2)*,)* + $($typaram: $bound1 $(+ $bound2)*),* + { + fn deserialize_as<D>(deserializer: D) -> Result<$ty<K, V $(, $typaram)*>, D::Error> + where + D: Deserializer<'de>, + { + struct MapVisitor<K, V, KU, VU $(, $typaram)*> { + marker: PhantomData<$ty<K, V $(, $typaram)*>>, + marker2: PhantomData<$ty<KU, VU $(, $typaram)*>>, + } + + impl<'de, K, V, KU, VU $(, $typaram)*> Visitor<'de> for MapVisitor<K, V, KU, VU $(, $typaram)*> + where + KU: DeserializeAs<'de, K>, + VU: DeserializeAs<'de, V>, + $(K: $kbound1 $(+ $kbound2)*,)* + $($typaram: $bound1 $(+ $bound2)*),* + { + type Value = $ty<K, V $(, $typaram)*>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map") + } + + #[inline] + fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + let mut values = $with_capacity; + + while let Some((key, value)) = ($access.next_entry())?.map(|(k, v): (DeserializeAsWrap::<K, KU>, DeserializeAsWrap::<V, VU>)| (k.into_inner(), v.into_inner())) { + values.insert(key, value); + } + + Ok(values) + } + } + + let visitor = MapVisitor::<K, V, KU, VU $(, $typaram)*> { marker: PhantomData, marker2: PhantomData }; + deserializer.deserialize_map(visitor) + } + } + } +} + +map_impl!( + BTreeMap<K: Ord, V>, + map, + BTreeMap::new()); +map_impl!( + HashMap<K: Eq + Hash, V, S: BuildHasher + Default>, + map, + HashMap::with_capacity_and_hasher(utils::size_hint_cautious(map.size_hint()), S::default())); +#[cfg(feature = "indexmap")] +map_impl!( + IndexMap<K: Eq + Hash, V, S: BuildHasher + Default>, + map, + IndexMap::with_capacity_and_hasher(utils::size_hint_cautious(map.size_hint()), S::default())); + +macro_rules! tuple_impl { + ($len:literal $($n:tt $t:ident $tas:ident)+) => { + impl<'de, $($t, $tas,)+> DeserializeAs<'de, ($($t,)+)> for ($($tas,)+) + where + $($tas: DeserializeAs<'de, $t>,)+ + { + fn deserialize_as<D>(deserializer: D) -> Result<($($t,)+), D::Error> + where + D: Deserializer<'de>, + { + struct TupleVisitor<$($t,)+>(PhantomData<($($t,)+)>); + + impl<'de, $($t, $tas,)+> Visitor<'de> + for TupleVisitor<$(DeserializeAsWrap<$t, $tas>,)+> + where + $($tas: DeserializeAs<'de, $t>,)+ + { + type Value = ($($t,)+); + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str(concat!("a tuple of size ", $len)) + } + + #[allow(non_snake_case)] + fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + $( + let $t: DeserializeAsWrap<$t, $tas> = match seq.next_element()? { + Some(value) => value, + None => return Err(Error::invalid_length($n, &self)), + }; + )+ + + Ok(($($t.into_inner(),)+)) + } + } + + deserializer.deserialize_tuple( + $len, + TupleVisitor::<$(DeserializeAsWrap<$t, $tas>,)+>(PhantomData), + ) + } + } + }; +} + +tuple_impl!(1 0 T0 As0); +tuple_impl!(2 0 T0 As0 1 T1 As1); +tuple_impl!(3 0 T0 As0 1 T1 As1 2 T2 As2); +tuple_impl!(4 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3); +tuple_impl!(5 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4); +tuple_impl!(6 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5); +tuple_impl!(7 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6); +tuple_impl!(8 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7); +tuple_impl!(9 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8); +tuple_impl!(10 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9); +tuple_impl!(11 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10); +tuple_impl!(12 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11); +tuple_impl!(13 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12); +tuple_impl!(14 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13); +tuple_impl!(15 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14); +tuple_impl!(16 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14 15 T15 As15); + +macro_rules! map_as_tuple_seq { + ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V>) => { + impl<'de, K, KAs, V, VAs> DeserializeAs<'de, $ty<K, V>> for Vec<(KAs, VAs)> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + $(K: $kbound1 $(+ $kbound2)*,)* + { + fn deserialize_as<D>(deserializer: D) -> Result<$ty<K, V>, D::Error> + where + D: Deserializer<'de>, + { + struct SeqVisitor<K, KAs, V, VAs> { + marker: PhantomData<(K, KAs, V, VAs)>, + } + + impl<'de, K, KAs, V, VAs> Visitor<'de> for SeqVisitor<K, KAs, V, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + $(K: $kbound1 $(+ $kbound2)*,)* + { + type Value = $ty<K, V>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + #[inline] + fn visit_seq<A>(self, access: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let iter = utils::SeqIter::new(access); + iter.map(|res| { + res.map( + |(k, v): (DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>)| { + (k.into_inner(), v.into_inner()) + }, + ) + }) + .collect() + } + } + + let visitor = SeqVisitor::<K, KAs, V, VAs> { + marker: PhantomData, + }; + deserializer.deserialize_seq(visitor) + } + } + }; +} +map_as_tuple_seq!(BTreeMap<K: Ord, V>); +map_as_tuple_seq!(HashMap<K: Eq + Hash, V>); +#[cfg(feature = "indexmap")] +map_as_tuple_seq!(IndexMap<K: Eq + Hash, V>); + +// endregion +/////////////////////////////////////////////////////////////////////////////// +// region: Conversion types which cause different serialization behavior + +impl<'de, T: Deserialize<'de>> DeserializeAs<'de, T> for Same { + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + T::deserialize(deserializer) + } +} + +impl<'de, T> DeserializeAs<'de, T> for DisplayFromStr +where + T: FromStr, + T::Err: Display, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + crate::rust::display_fromstr::deserialize(deserializer) + } +} + +impl<'de, T, U> DeserializeAs<'de, Vec<T>> for VecSkipError<U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error> + where + D: Deserializer<'de>, + { + #[derive(serde::Deserialize)] + #[serde( + untagged, + bound(deserialize = "DeserializeAsWrap<T, TAs>: Deserialize<'de>") + )] + enum GoodOrError<'a, T, TAs> + where + TAs: DeserializeAs<'a, T>, + { + Good(DeserializeAsWrap<T, TAs>), + // This consumes one "item" when `T` errors while deserializing. + // This is necessary to make this work, when instead of having a direct value + // like integer or string, the deserializer sees a list or map. + Error(IgnoredAny), + #[serde(skip)] + _JustAMarkerForTheLifetime(PhantomData<&'a u32>), + } + + struct SeqVisitor<T, U> { + marker: PhantomData<T>, + marker2: PhantomData<U>, + } + + impl<'de, T, U> Visitor<'de> for SeqVisitor<T, U> + where + U: DeserializeAs<'de, T>, + { + type Value = Vec<T>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let mut values = Vec::with_capacity(seq.size_hint().unwrap_or_default()); + + while let Some(value) = seq.next_element()? { + if let GoodOrError::<T, U>::Good(value) = value { + values.push(value.into_inner()); + } + } + Ok(values) + } + } + + let visitor = SeqVisitor::<T, U> { + marker: PhantomData, + marker2: PhantomData, + }; + deserializer.deserialize_seq(visitor) + } +} + +impl<'de, Str> DeserializeAs<'de, Option<Str>> for NoneAsEmptyString +where + Str: FromStr, + Str::Err: Display, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Option<Str>, D::Error> + where + D: Deserializer<'de>, + { + crate::rust::string_empty_as_none::deserialize(deserializer) + } +} + +macro_rules! tuple_seq_as_map_impl_intern { + ($tyorig:ident < (K $(: $($kbound:ident $(+)?)+)?, V $(: $($vbound:ident $(+)?)+)?)>, $ty:ident <KAs, VAs>) => { + #[allow(clippy::implicit_hasher)] + impl<'de, K, KAs, V, VAs> DeserializeAs<'de, $tyorig < (K, V) >> for $ty<KAs, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + K: $($($kbound +)*)*, + V: $($($vbound +)*)*, + { + fn deserialize_as<D>(deserializer: D) -> Result<$tyorig < (K, V) >, D::Error> + where + D: Deserializer<'de>, + { + struct MapVisitor<K, KAs, V, VAs> { + marker: PhantomData<(K, KAs, V, VAs)>, + } + + impl<'de, K, KAs, V, VAs> Visitor<'de> for MapVisitor<K, KAs, V, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + K: $($($kbound +)*)*, + V: $($($vbound +)*)*, + { + type Value = $tyorig < (K, V) >; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map") + } + + #[inline] + fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + let iter = utils::MapIter::new(access); + iter.map(|res| { + res.map( + |(k, v): (DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>)| { + (k.into_inner(), v.into_inner()) + }, + ) + }) + .collect() + } + } + + let visitor = MapVisitor::<K, KAs, V, VAs> { + marker: PhantomData, + }; + deserializer.deserialize_map(visitor) + } + } + } +} +macro_rules! tuple_seq_as_map_impl { + ($($tyorig:ident < (K $(: $($kbound:ident $(+)?)+)?, V $(: $($vbound:ident $(+)?)+)?)> $(,)?)+) => {$( + tuple_seq_as_map_impl_intern!($tyorig < (K $(: $($kbound +)+)?, V $(: $($vbound +)+)?) >, BTreeMap<KAs, VAs>); + tuple_seq_as_map_impl_intern!($tyorig < (K $(: $($kbound +)+)?, V $(: $($vbound +)+)?) >, HashMap<KAs, VAs>); + )+} +} + +tuple_seq_as_map_impl! { + BinaryHeap<(K: Ord, V: Ord)>, + BTreeSet<(K: Ord, V: Ord)>, + LinkedList<(K, V)>, + Vec<(K, V)>, + VecDeque<(K, V)>, +} +tuple_seq_as_map_impl!(HashSet<(K: Eq + Hash, V: Eq + Hash)>); +#[cfg(feature = "indexmap")] +tuple_seq_as_map_impl!(IndexSet<(K: Eq + Hash, V: Eq + Hash)>); + +macro_rules! tuple_seq_as_map_option_impl { + ($($ty:ident $(,)?)+) => {$( + #[allow(clippy::implicit_hasher)] + impl<'de, K, KAs, V, VAs> DeserializeAs<'de, Option<(K, V)>> for $ty<KAs, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + { + fn deserialize_as<D>(deserializer: D) -> Result<Option<(K, V)>, D::Error> + where + D: Deserializer<'de>, + { + struct MapVisitor<K, KAs, V, VAs> { + marker: PhantomData<(K, KAs, V, VAs)>, + } + + impl<'de, K, KAs, V, VAs> Visitor<'de> for MapVisitor<K, KAs, V, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + { + type Value = Option<(K, V)>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map of size 1") + } + + #[inline] + fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + let iter = utils::MapIter::new(access); + iter.map(|res| { + res.map( + |(k, v): (DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>)| { + (k.into_inner(), v.into_inner()) + }, + ) + }) + .next() + .transpose() + } + } + + let visitor = MapVisitor::<K, KAs, V, VAs> { + marker: PhantomData, + }; + deserializer.deserialize_map(visitor) + } + } + )+} +} +tuple_seq_as_map_option_impl!(BTreeMap); +tuple_seq_as_map_option_impl!(HashMap); + +impl<'de, T, TAs> DeserializeAs<'de, T> for DefaultOnError<TAs> +where + TAs: DeserializeAs<'de, T>, + T: Default, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + #[derive(serde::Deserialize)] + #[serde( + untagged, + bound(deserialize = "DeserializeAsWrap<T, TAs>: Deserialize<'de>") + )] + enum GoodOrError<'a, T, TAs> + where + TAs: DeserializeAs<'a, T>, + { + Good(DeserializeAsWrap<T, TAs>), + // This consumes one "item" when `T` errors while deserializing. + // This is necessary to make this work, when instead of having a direct value + // like integer or string, the deserializer sees a list or map. + Error(IgnoredAny), + #[serde(skip)] + _JustAMarkerForTheLifetime(PhantomData<&'a u32>), + } + + Ok(match Deserialize::deserialize(deserializer) { + Ok(GoodOrError::<T, TAs>::Good(res)) => res.into_inner(), + _ => Default::default(), + }) + } +} + +impl<'de> DeserializeAs<'de, Vec<u8>> for BytesOrString { + fn deserialize_as<D>(deserializer: D) -> Result<Vec<u8>, D::Error> + where + D: Deserializer<'de>, + { + crate::rust::bytes_or_string::deserialize(deserializer) + } +} + +impl<'de, SEPARATOR, I, T> DeserializeAs<'de, I> for StringWithSeparator<SEPARATOR, T> +where + SEPARATOR: Separator, + I: FromIterator<T>, + T: FromStr, + T::Err: Display, +{ + fn deserialize_as<D>(deserializer: D) -> Result<I, D::Error> + where + D: Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + if s.is_empty() { + Ok(None.into_iter().collect()) + } else { + s.split(SEPARATOR::separator()) + .map(FromStr::from_str) + .collect::<Result<_, _>>() + .map_err(Error::custom) + } + } +} + +macro_rules! use_signed_duration { + ( + $main_trait:ident $internal_trait:ident => + { + $ty:ty; $converter:ident => + $({ + $format:ty, $strictness:ty => + $($tbound:ident: $bound:ident $(,)?)* + })* + } + ) => { + $( + impl<'de, $($tbound,)*> DeserializeAs<'de, $ty> for $main_trait<$format, $strictness> + where + $($tbound: $bound,)* + { + fn deserialize_as<D>(deserializer: D) -> Result<$ty, D::Error> + where + D: Deserializer<'de>, + { + let dur: DurationSigned = $internal_trait::<$format, $strictness>::deserialize_as(deserializer)?; + dur.$converter::<D>() + } + } + )* + }; + ( + $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt + ) => { + $( use_signed_duration!($main_trait $internal_trait => $rest); )+ + }; +} + +use_signed_duration!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; to_std_duration => + {u64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_signed_duration!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; to_std_duration => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); + +use_signed_duration!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + SystemTime; to_system_time => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_signed_duration!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + SystemTime; to_system_time => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); + +impl<'de, T, U> DeserializeAs<'de, T> for DefaultOnNull<U> +where + U: DeserializeAs<'de, T>, + T: Default, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + Ok(Option::<U>::deserialize_as(deserializer)?.unwrap_or_default()) + } +} + +impl<'de> DeserializeAs<'de, &'de [u8]> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<&'de [u8], D::Error> + where + D: Deserializer<'de>, + { + <&'de [u8]>::deserialize(deserializer) + } +} + +// serde_bytes implementation for ByteBuf +// https://github.com/serde-rs/bytes/blob/cbae606b9dc225fc094b031cc84eac9493da2058/src/bytebuf.rs#L196 +// +// Implements: +// * visit_seq +// * visit_bytes +// * visit_byte_buf +// * visit_str +// * visit_string +impl<'de> DeserializeAs<'de, Vec<u8>> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<Vec<u8>, D::Error> + where + D: Deserializer<'de>, + { + struct VecVisitor; + + impl<'de> Visitor<'de> for VecVisitor { + type Value = Vec<u8>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a byte array") + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + utils::SeqIter::new(seq).collect::<Result<_, _>>() + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v.to_vec()) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v.as_bytes().to_vec()) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v.into_bytes()) + } + } + + deserializer.deserialize_byte_buf(VecVisitor) + } +} + +impl<'de> DeserializeAs<'de, Box<[u8]>> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<Box<[u8]>, D::Error> + where + D: Deserializer<'de>, + { + <Bytes as DeserializeAs<'de, Vec<u8>>>::deserialize_as(deserializer) + .map(|vec| vec.into_boxed_slice()) + } +} + +// serde_bytes implementation for Cow<'a, [u8]> +// https://github.com/serde-rs/bytes/blob/cbae606b9dc225fc094b031cc84eac9493da2058/src/de.rs#L77 +// +// Implements: +// * visit_borrowed_bytes +// * visit_borrowed_str +// * visit_bytes +// * visit_str +// * visit_byte_buf +// * visit_string +// * visit_seq +impl<'de> DeserializeAs<'de, Cow<'de, [u8]>> for Bytes { + fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8]>, D::Error> + where + D: Deserializer<'de>, + { + struct CowVisitor; + + impl<'de> Visitor<'de> for CowVisitor { + type Value = Cow<'de, [u8]>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a byte array") + } + + fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Borrowed(v)) + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Borrowed(v.as_bytes())) + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned(v.to_vec())) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned(v.as_bytes().to_vec())) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned(v)) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned(v.into_bytes())) + } + + fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error> + where + V: SeqAccess<'de>, + { + Ok(Cow::Owned( + utils::SeqIter::new(seq).collect::<Result<_, _>>()?, + )) + } + } + + deserializer.deserialize_bytes(CowVisitor) + } +} + +impl<'de, T, U, FORMAT> DeserializeAs<'de, Vec<T>> for OneOrMany<U, FORMAT> +where + U: DeserializeAs<'de, T>, + FORMAT: Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error> + where + D: Deserializer<'de>, + { + #[derive(serde::Deserialize)] + #[serde( + untagged, + bound(deserialize = r#"DeserializeAsWrap<T, U>: Deserialize<'de>, + DeserializeAsWrap<Vec<T>, Vec<U>>: Deserialize<'de>"#), + expecting = "a list or single element" + )] + enum Helper<'a, T, U> + where + U: DeserializeAs<'a, T>, + { + One(DeserializeAsWrap<T, U>), + Many(DeserializeAsWrap<Vec<T>, Vec<U>>), + #[serde(skip)] + _JustAMarkerForTheLifetime(PhantomData<&'a u32>), + } + + let h: Helper<'de, T, U> = Deserialize::deserialize(deserializer)?; + match h { + Helper::One(one) => Ok(alloc::vec![one.into_inner()]), + Helper::Many(many) => Ok(many.into_inner()), + Helper::_JustAMarkerForTheLifetime(_) => unreachable!(), + } + } +} + +impl<'de, T, TAs1> DeserializeAs<'de, T> for PickFirst<(TAs1,)> +where + TAs1: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + Ok(DeserializeAsWrap::<T, TAs1>::deserialize(deserializer)?.into_inner()) + } +} + +impl<'de, T, TAs1, TAs2> DeserializeAs<'de, T> for PickFirst<(TAs1, TAs2)> +where + TAs1: DeserializeAs<'de, T>, + TAs2: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + #[derive(serde::Deserialize)] + #[serde( + untagged, + bound(deserialize = r#" + DeserializeAsWrap<T, TAs1>: Deserialize<'de>, + DeserializeAsWrap<T, TAs2>: Deserialize<'de>, + "#), + expecting = "PickFirst could not deserialize data" + )] + enum Helper<'a, T, TAs1, TAs2> + where + TAs1: DeserializeAs<'a, T>, + TAs2: DeserializeAs<'a, T>, + { + First(DeserializeAsWrap<T, TAs1>), + Second(DeserializeAsWrap<T, TAs2>), + #[serde(skip)] + _JustAMarkerForTheLifetime(PhantomData<&'a u32>), + } + + let h: Helper<'de, T, TAs1, TAs2> = Deserialize::deserialize(deserializer)?; + match h { + Helper::First(first) => Ok(first.into_inner()), + Helper::Second(second) => Ok(second.into_inner()), + Helper::_JustAMarkerForTheLifetime(_) => unreachable!(), + } + } +} + +impl<'de, T, TAs1, TAs2, TAs3> DeserializeAs<'de, T> for PickFirst<(TAs1, TAs2, TAs3)> +where + TAs1: DeserializeAs<'de, T>, + TAs2: DeserializeAs<'de, T>, + TAs3: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + #[derive(serde::Deserialize)] + #[serde( + untagged, + bound(deserialize = r#" + DeserializeAsWrap<T, TAs1>: Deserialize<'de>, + DeserializeAsWrap<T, TAs2>: Deserialize<'de>, + DeserializeAsWrap<T, TAs3>: Deserialize<'de>, + "#), + expecting = "PickFirst could not deserialize data" + )] + enum Helper<'a, T, TAs1, TAs2, TAs3> + where + TAs1: DeserializeAs<'a, T>, + TAs2: DeserializeAs<'a, T>, + TAs3: DeserializeAs<'a, T>, + { + First(DeserializeAsWrap<T, TAs1>), + Second(DeserializeAsWrap<T, TAs2>), + Third(DeserializeAsWrap<T, TAs3>), + #[serde(skip)] + _JustAMarkerForTheLifetime(PhantomData<&'a u32>), + } + + let h: Helper<'de, T, TAs1, TAs2, TAs3> = Deserialize::deserialize(deserializer)?; + match h { + Helper::First(first) => Ok(first.into_inner()), + Helper::Second(second) => Ok(second.into_inner()), + Helper::Third(third) => Ok(third.into_inner()), + Helper::_JustAMarkerForTheLifetime(_) => unreachable!(), + } + } +} + +impl<'de, T, TAs1, TAs2, TAs3, TAs4> DeserializeAs<'de, T> for PickFirst<(TAs1, TAs2, TAs3, TAs4)> +where + TAs1: DeserializeAs<'de, T>, + TAs2: DeserializeAs<'de, T>, + TAs3: DeserializeAs<'de, T>, + TAs4: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + #[derive(serde::Deserialize)] + #[serde( + untagged, + bound(deserialize = r#" + DeserializeAsWrap<T, TAs1>: Deserialize<'de>, + DeserializeAsWrap<T, TAs2>: Deserialize<'de>, + DeserializeAsWrap<T, TAs3>: Deserialize<'de>, + DeserializeAsWrap<T, TAs4>: Deserialize<'de>, + "#), + expecting = "PickFirst could not deserialize data" + )] + enum Helper<'a, T, TAs1, TAs2, TAs3, TAs4> + where + TAs1: DeserializeAs<'a, T>, + TAs2: DeserializeAs<'a, T>, + TAs3: DeserializeAs<'a, T>, + TAs4: DeserializeAs<'a, T>, + { + First(DeserializeAsWrap<T, TAs1>), + Second(DeserializeAsWrap<T, TAs2>), + Third(DeserializeAsWrap<T, TAs3>), + Forth(DeserializeAsWrap<T, TAs4>), + #[serde(skip)] + _JustAMarkerForTheLifetime(PhantomData<&'a u32>), + } + + let h: Helper<'de, T, TAs1, TAs2, TAs3, TAs4> = Deserialize::deserialize(deserializer)?; + match h { + Helper::First(first) => Ok(first.into_inner()), + Helper::Second(second) => Ok(second.into_inner()), + Helper::Third(third) => Ok(third.into_inner()), + Helper::Forth(forth) => Ok(forth.into_inner()), + Helper::_JustAMarkerForTheLifetime(_) => unreachable!(), + } + } +} + +impl<'de, T, U> DeserializeAs<'de, T> for FromInto<U> +where + U: Into<T>, + U: Deserialize<'de>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + Ok(U::deserialize(deserializer)?.into()) + } +} + +impl<'de, T, U> DeserializeAs<'de, T> for TryFromInto<U> +where + U: TryInto<T>, + <U as TryInto<T>>::Error: Display, + U: Deserialize<'de>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + U::deserialize(deserializer)? + .try_into() + .map_err(Error::custom) + } +} + +impl<'de> DeserializeAs<'de, Cow<'de, str>> for BorrowCow { + fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, str>, D::Error> + where + D: Deserializer<'de>, + { + struct CowVisitor; + + impl<'de> Visitor<'de> for CowVisitor { + type Value = Cow<'de, str>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("an optionally borrowed string") + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Borrowed(v)) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned(v.to_owned())) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: Error, + { + Ok(Cow::Owned(v)) + } + } + + deserializer.deserialize_str(CowVisitor) + } +} + +impl<'de> DeserializeAs<'de, Cow<'de, [u8]>> for BorrowCow { + fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8]>, D::Error> + where + D: Deserializer<'de>, + { + Bytes::deserialize_as(deserializer) + } +} + +impl<'de> DeserializeAs<'de, bool> for BoolFromInt<Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<bool, D::Error> + where + D: Deserializer<'de>, + { + struct U8Visitor; + impl<'de> Visitor<'de> for U8Visitor { + type Value = bool; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("an integer 0 or 1") + } + + fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> + where + E: Error, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(Error::invalid_value( + Unexpected::Unsigned(unexp as u64), + &"0 or 1", + )), + } + } + + fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> + where + E: Error, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(Error::invalid_value( + Unexpected::Signed(unexp as i64), + &"0 or 1", + )), + } + } + + fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> + where + E: Error, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(Error::invalid_value(Unexpected::Unsigned(unexp), &"0 or 1")), + } + } + + fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> + where + E: Error, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(Error::invalid_value(Unexpected::Signed(unexp), &"0 or 1")), + } + } + + fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> + where + E: Error, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(Error::invalid_value( + Unexpected::Unsigned(unexp as u64), + &"0 or 1", + )), + } + } + + fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> + where + E: Error, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(Error::invalid_value( + Unexpected::Unsigned(unexp as u64), + &"0 or 1", + )), + } + } + } + + deserializer.deserialize_u8(U8Visitor) + } +} + +impl<'de> DeserializeAs<'de, bool> for BoolFromInt<Flexible> { + fn deserialize_as<D>(deserializer: D) -> Result<bool, D::Error> + where + D: Deserializer<'de>, + { + struct U8Visitor; + impl<'de> Visitor<'de> for U8Visitor { + type Value = bool; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("an integer") + } + + fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v != 0) + } + + fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v != 0) + } + + fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v != 0) + } + + fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v != 0) + } + + fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v != 0) + } + + fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> + where + E: Error, + { + Ok(v != 0) + } + } + + deserializer.deserialize_u8(U8Visitor) + } +} + +// endregion diff --git a/third_party/rust/serde_with/src/de/legacy_arrays.rs b/third_party/rust/serde_with/src/de/legacy_arrays.rs new file mode 100644 index 0000000000..550e444a2f --- /dev/null +++ b/third_party/rust/serde_with/src/de/legacy_arrays.rs @@ -0,0 +1,85 @@ +use super::*; +use core::fmt; +use serde::de::*; + +macro_rules! array_impl { + ($len:literal $($idx:tt)*) => { + impl<'de, T, As> DeserializeAs<'de, [T; $len]> for [As; $len] + where + As: DeserializeAs<'de, T>, + { + fn deserialize_as<D>(deserializer: D) -> Result<[T; $len], D::Error> + where + D: Deserializer<'de>, + { + struct ArrayVisitor<T>(PhantomData<T>); + + impl<'de, T, As> Visitor<'de> + for ArrayVisitor<DeserializeAsWrap<T, As>> + where + As: DeserializeAs<'de, T>, + { + type Value = [T; $len]; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str(concat!("an array of size ", $len)) + } + + #[allow(non_snake_case)] + // Because of 0-size arrays + #[allow(unused_variables, unused_mut)] + fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + Ok([$( + match seq.next_element::<DeserializeAsWrap<T, As>>()? { + Some(value) => value.into_inner(), + None => return Err(Error::invalid_length($idx, &self)), + }, + )*]) + } + } + + deserializer.deserialize_tuple( + $len, + ArrayVisitor::<DeserializeAsWrap<T, As>>(PhantomData), + ) + } + } + }; +} + +array_impl!(0); +array_impl!(1 0); +array_impl!(2 0 1); +array_impl!(3 0 1 2); +array_impl!(4 0 1 2 3); +array_impl!(5 0 1 2 3 4); +array_impl!(6 0 1 2 3 4 5); +array_impl!(7 0 1 2 3 4 5 6); +array_impl!(8 0 1 2 3 4 5 6 7); +array_impl!(9 0 1 2 3 4 5 6 7 8); +array_impl!(10 0 1 2 3 4 5 6 7 8 9); +array_impl!(11 0 1 2 3 4 5 6 7 8 9 10); +array_impl!(12 0 1 2 3 4 5 6 7 8 9 10 11); +array_impl!(13 0 1 2 3 4 5 6 7 8 9 10 11 12); +array_impl!(14 0 1 2 3 4 5 6 7 8 9 10 11 12 13); +array_impl!(15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14); +array_impl!(16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15); +array_impl!(17 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16); +array_impl!(18 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17); +array_impl!(19 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18); +array_impl!(20 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19); +array_impl!(21 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20); +array_impl!(22 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21); +array_impl!(23 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22); +array_impl!(24 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23); +array_impl!(25 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24); +array_impl!(26 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25); +array_impl!(27 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26); +array_impl!(28 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27); +array_impl!(29 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28); +array_impl!(30 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29); +array_impl!(31 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30); +array_impl!(32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31); diff --git a/third_party/rust/serde_with/src/de/mod.rs b/third_party/rust/serde_with/src/de/mod.rs new file mode 100644 index 0000000000..518b4f2606 --- /dev/null +++ b/third_party/rust/serde_with/src/de/mod.rs @@ -0,0 +1,143 @@ +//! Module for [`DeserializeAs`][] implementations +//! +//! The module contains the [`DeserializeAs`][] trait and helper code. +//! Additionally, it contains implementations of [`DeserializeAs`][] for types defined in the Rust Standard Library or this crate. +//! +//! You can find more details on how to implement this trait for your types in the documentation of the [`DeserializeAs`][] trait and details about the usage in the [user guide][]. +//! +//! [user guide]: crate::guide + +mod const_arrays; +mod impls; + +use super::*; + +/// A **data structure** that can be deserialized from any data format supported by Serde, analogue to [`Deserialize`]. +/// +/// The trait is analogue to the [`serde::Deserialize`][`Deserialize`] trait, with the same meaning of input and output arguments. +/// It can and should the implemented using the same code structure as the [`Deserialize`] trait. +/// As such, the same advice for [implementing `Deserialize`][impl-deserialize] applies here. +/// +/// # Differences to [`Deserialize`] +/// +/// The trait is only required for container-like types or types implementing specific conversion functions. +/// Container-like types are [`Vec`], [`BTreeMap`], but also [`Option`] and [`Box`]. +/// Conversion types deserialize into a different Rust type. +/// For example, [`DisplayFromStr`] uses the [`FromStr`] trait after deserializing a string and [`DurationSeconds`] creates a [`Duration`] from either String or integer values. +/// +/// This code shows how to implement [`Deserialize`] for [`Box`]: +/// +/// ```rust,ignore +/// impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> { +/// fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> +/// where +/// D: Deserializer<'de>, +/// { +/// Ok(Box::new(Deserialize::deserialize(deserializer)?)) +/// } +/// } +/// ``` +/// +/// and this code shows how to do the same using [`DeserializeAs`][]: +/// +/// ```rust,ignore +/// impl<'de, T, U> DeserializeAs<'de, Box<T>> for Box<U> +/// where +/// U: DeserializeAs<'de, T>, +/// { +/// fn deserialize_as<D>(deserializer: D) -> Result<Box<T>, D::Error> +/// where +/// D: Deserializer<'de>, +/// { +/// Ok(Box::new( +/// DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(), +/// )) +/// } +/// } +/// ``` +/// +/// It uses two type parameters, `T` and `U` instead of only one and performs the deserialization step using the `DeserializeAsWrap` type. +/// The `T` type is the on the Rust side after deserialization, whereas the `U` type determines how the value will be deserialized. +/// These two changes are usually enough to make a container type implement [`DeserializeAs`][]. +/// +/// +/// [`DeserializeAsWrap`] is a piece of glue code which turns [`DeserializeAs`] into a serde compatible datatype, by converting all calls to `deserialize` into `deserialize_as`. +/// This allows us to implement [`DeserializeAs`] such that it can be applied recursively throughout the whole data structure. +/// This is mostly important for container types, such as `Vec` or `BTreeMap`. +/// In a `BTreeMap` this allows us to specify two different serialization behaviors, one for key and one for value, using the [`DeserializeAs`] trait. +/// +/// ## Implementing a converter Type +/// +/// This shows a simplified implementation for [`DisplayFromStr`]. +/// +/// ```rust +/// # #[cfg(all(feature = "macros"))] { +/// # use serde::Deserialize; +/// # use serde::de::Error; +/// # use serde_with::DeserializeAs; +/// # use std::str::FromStr; +/// # use std::fmt::Display; +/// struct DisplayFromStr; +/// +/// impl<'de, T> DeserializeAs<'de, T> for DisplayFromStr +/// where +/// T: FromStr, +/// T::Err: Display, +/// { +/// fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> +/// where +/// D: serde::Deserializer<'de>, +/// { +/// let s = String::deserialize(deserializer).map_err(Error::custom)?; +/// s.parse().map_err(Error::custom) +/// } +/// } +/// # +/// # #[serde_with::serde_as] +/// # #[derive(serde::Deserialize)] +/// # struct S (#[serde_as(as = "DisplayFromStr")] bool); +/// # +/// # assert_eq!(false, serde_json::from_str::<S>(r#""false""#).unwrap().0); +/// # } +/// ``` +/// [`Box`]: std::boxed::Box +/// [`BTreeMap`]: std::collections::BTreeMap +/// [`Duration`]: std::time::Duration +/// [`FromStr`]: std::str::FromStr +/// [`Vec`]: std::vec::Vec +/// [impl-deserialize]: https://serde.rs/impl-deserialize.html +pub trait DeserializeAs<'de, T>: Sized { + /// Deserialize this value from the given Serde deserializer. + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>; +} + +/// Helper type to implement [`DeserializeAs`] for container-like types. +#[derive(Debug)] +pub struct DeserializeAsWrap<T, U> { + value: T, + marker: PhantomData<U>, +} + +impl<T, U> DeserializeAsWrap<T, U> { + /// Return the inner value of type `T`. + pub fn into_inner(self) -> T { + self.value + } +} + +impl<'de, T, U> Deserialize<'de> for DeserializeAsWrap<T, U> +where + U: DeserializeAs<'de, T>, +{ + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + U::deserialize_as(deserializer).map(|value| Self { + value, + marker: PhantomData, + }) + } +} diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs b/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs new file mode 100644 index 0000000000..9370f5fd51 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs @@ -0,0 +1,127 @@ +use alloc::collections::{BTreeMap, BTreeSet}; +use core::hash::{BuildHasher, Hash}; +#[cfg(feature = "indexmap")] +use indexmap_crate::{IndexMap, IndexSet}; +use std::collections::{HashMap, HashSet}; + +pub trait PreventDuplicateInsertsSet<T> { + fn new(size_hint: Option<usize>) -> Self; + + /// Return true if the insert was successful and the value did not exist in the set + fn insert(&mut self, value: T) -> bool; +} + +pub trait PreventDuplicateInsertsMap<K, V> { + fn new(size_hint: Option<usize>) -> Self; + + /// Return true if the insert was successful and the key did not exist in the map + fn insert(&mut self, key: K, value: V) -> bool; +} + +impl<T, S> PreventDuplicateInsertsSet<T> for HashSet<T, S> +where + T: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, value: T) -> bool { + self.insert(value) + } +} + +#[cfg(feature = "indexmap")] +impl<T, S> PreventDuplicateInsertsSet<T> for IndexSet<T, S> +where + T: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, value: T) -> bool { + self.insert(value) + } +} + +impl<T> PreventDuplicateInsertsSet<T> for BTreeSet<T> +where + T: Ord, +{ + #[inline] + fn new(_size_hint: Option<usize>) -> Self { + Self::new() + } + + #[inline] + fn insert(&mut self, value: T) -> bool { + self.insert(value) + } +} + +impl<K, V, S> PreventDuplicateInsertsMap<K, V> for HashMap<K, V, S> +where + K: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, key: K, value: V) -> bool { + self.insert(key, value).is_none() + } +} + +#[cfg(feature = "indexmap")] +impl<K, V, S> PreventDuplicateInsertsMap<K, V> for IndexMap<K, V, S> +where + K: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, key: K, value: V) -> bool { + self.insert(key, value).is_none() + } +} + +impl<K, V> PreventDuplicateInsertsMap<K, V> for BTreeMap<K, V> +where + K: Ord, +{ + #[inline] + fn new(_size_hint: Option<usize>) -> Self { + Self::new() + } + + #[inline] + fn insert(&mut self, key: K, value: V) -> bool { + self.insert(key, value).is_none() + } +} diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs b/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs new file mode 100644 index 0000000000..faf922b8c2 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs @@ -0,0 +1,136 @@ +use alloc::collections::{BTreeMap, BTreeSet}; +use core::hash::{BuildHasher, Hash}; +#[cfg(feature = "indexmap")] +use indexmap_crate::IndexMap; +use std::collections::{HashMap, HashSet}; + +#[deprecated = "This is serde's default behavior."] +pub trait DuplicateInsertsFirstWinsSet<T> { + fn new(size_hint: Option<usize>) -> Self; + + /// Insert the value into the set, if there is not already an existing value + fn insert(&mut self, value: T); +} + +pub trait DuplicateInsertsFirstWinsMap<K, V> { + fn new(size_hint: Option<usize>) -> Self; + + /// Insert the value into the map, if there is not already an existing value + fn insert(&mut self, key: K, value: V); +} + +#[allow(deprecated)] +impl<T, S> DuplicateInsertsFirstWinsSet<T> for HashSet<T, S> +where + T: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, value: T) { + // Hashset already fulfils the contract and always keeps the first value + self.insert(value); + } +} + +#[allow(deprecated)] +impl<T> DuplicateInsertsFirstWinsSet<T> for BTreeSet<T> +where + T: Ord, +{ + #[inline] + fn new(_size_hint: Option<usize>) -> Self { + Self::new() + } + + #[inline] + fn insert(&mut self, value: T) { + // BTreeSet already fulfils the contract and always keeps the first value + self.insert(value); + } +} + +impl<K, V, S> DuplicateInsertsFirstWinsMap<K, V> for HashMap<K, V, S> +where + K: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, key: K, value: V) { + use std::collections::hash_map::Entry; + + match self.entry(key) { + // we want to keep the first value, so do nothing + Entry::Occupied(_) => {} + Entry::Vacant(vacant) => { + vacant.insert(value); + } + } + } +} + +#[cfg(feature = "indexmap")] +impl<K, V, S> DuplicateInsertsFirstWinsMap<K, V> for IndexMap<K, V, S> +where + K: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn insert(&mut self, key: K, value: V) { + use indexmap_crate::map::Entry; + + match self.entry(key) { + // we want to keep the first value, so do nothing + Entry::Occupied(_) => {} + Entry::Vacant(vacant) => { + vacant.insert(value); + } + } + } +} + +impl<K, V> DuplicateInsertsFirstWinsMap<K, V> for BTreeMap<K, V> +where + K: Ord, +{ + #[inline] + fn new(_size_hint: Option<usize>) -> Self { + Self::new() + } + + #[inline] + fn insert(&mut self, key: K, value: V) { + use alloc::collections::btree_map::Entry; + + match self.entry(key) { + // we want to keep the first value, so do nothing + Entry::Occupied(_) => {} + Entry::Vacant(vacant) => { + vacant.insert(value); + } + } + } +} diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs b/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs new file mode 100644 index 0000000000..3eeeaac079 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs @@ -0,0 +1,69 @@ +use alloc::collections::BTreeSet; +use core::hash::{BuildHasher, Hash}; +#[cfg(feature = "indexmap")] +use indexmap_crate::IndexSet; +use std::collections::HashSet; + +pub trait DuplicateInsertsLastWinsSet<T> { + fn new(size_hint: Option<usize>) -> Self; + + /// Insert or replace the existing value + fn replace(&mut self, value: T); +} + +impl<T, S> DuplicateInsertsLastWinsSet<T> for HashSet<T, S> +where + T: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn replace(&mut self, value: T) { + // Hashset already fulfils the contract + self.replace(value); + } +} + +#[cfg(feature = "indexmap")] +impl<T, S> DuplicateInsertsLastWinsSet<T> for IndexSet<T, S> +where + T: Eq + Hash, + S: BuildHasher + Default, +{ + #[inline] + fn new(size_hint: Option<usize>) -> Self { + match size_hint { + Some(size) => Self::with_capacity_and_hasher(size, S::default()), + None => Self::with_hasher(S::default()), + } + } + + #[inline] + fn replace(&mut self, value: T) { + // Hashset already fulfils the contract + self.replace(value); + } +} + +impl<T> DuplicateInsertsLastWinsSet<T> for BTreeSet<T> +where + T: Ord, +{ + #[inline] + fn new(_size_hint: Option<usize>) -> Self { + Self::new() + } + + #[inline] + fn replace(&mut self, value: T) { + // BTreeSet already fulfils the contract + self.replace(value); + } +} diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs b/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs new file mode 100644 index 0000000000..6080812232 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs @@ -0,0 +1,10 @@ +mod error_on_duplicate; +mod first_value_wins; +mod last_value_wins; + +#[allow(deprecated)] +pub use self::{ + error_on_duplicate::{PreventDuplicateInsertsMap, PreventDuplicateInsertsSet}, + first_value_wins::{DuplicateInsertsFirstWinsMap, DuplicateInsertsFirstWinsSet}, + last_value_wins::DuplicateInsertsLastWinsSet, +}; diff --git a/third_party/rust/serde_with/src/enum_map.rs b/third_party/rust/serde_with/src/enum_map.rs new file mode 100644 index 0000000000..ef65f8985f --- /dev/null +++ b/third_party/rust/serde_with/src/enum_map.rs @@ -0,0 +1,888 @@ +use crate::{ + content::ser::{Content, ContentSerializer}, + DeserializeAs, SerializeAs, +}; +use alloc::{string::ToString, vec::Vec}; +use core::{fmt, marker::PhantomData}; +use serde::{ + de::{DeserializeSeed, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor}, + ser, + ser::{Impossible, SerializeMap, SerializeSeq, SerializeStructVariant, SerializeTupleVariant}, + Deserialize, Deserializer, Serialize, Serializer, +}; + +/// Represent a list of enum values as a map. +/// +/// This **only works** if the enum uses the default *externally tagged* representation. +/// Other enum representations are not supported. +/// +/// serde data formats often represent *externally tagged* enums as maps with a single key. +/// The key is the enum variant name, and the value is the variant value. +/// Sometimes a map with multiple keys should be treated like a list of enum values. +/// +/// # Examples +/// +/// ## JSON Map with multiple keys +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// use serde_with::EnumMap; +/// +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// enum EnumValue { +/// Int(i32), +/// String(String), +/// Unit, +/// Tuple(i32, String, bool), +/// Struct { +/// a: i32, +/// b: String, +/// c: bool, +/// }, +/// } +/// +/// #[serde_with::serde_as] +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct VecEnumValues ( +/// #[serde_as(as = "EnumMap")] +/// Vec<EnumValue>, +/// ); +/// +/// // --- +/// +/// // This will serialize this list of values +/// let values = VecEnumValues(vec![ +/// EnumValue::Int(123), +/// EnumValue::String("FooBar".to_string()), +/// EnumValue::Int(456), +/// EnumValue::String("XXX".to_string()), +/// EnumValue::Unit, +/// EnumValue::Tuple(1, "Middle".to_string(), false), +/// EnumValue::Struct { +/// a: 666, +/// b: "BBB".to_string(), +/// c: true, +/// }, +/// ]); +/// +/// // into this JSON map +/// // Duplicate keys are emitted for identical enum variants. +/// let expected = +/// r#"{ +/// "Int": 123, +/// "String": "FooBar", +/// "Int": 456, +/// "String": "XXX", +/// "Unit": null, +/// "Tuple": [ +/// 1, +/// "Middle", +/// false +/// ], +/// "Struct": { +/// "a": 666, +/// "b": "BBB", +/// "c": true +/// } +/// }"#; +/// +/// // Both serialization and deserialization work flawlessly. +/// let serialized = serde_json::to_string_pretty(&values).unwrap(); +/// assert_eq!(expected, serialized); +/// let deserialized: VecEnumValues = serde_json::from_str(&serialized).unwrap(); +/// assert_eq!(values, deserialized); +/// # } +/// ``` +/// +/// ## XML structure with varying keys +/// +/// With `serde_xml_rs` tuple and struct variants are not supported since they fail to roundtrip. +/// The enum may have such variants as long as they are not serialized or deserialized. +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// use serde_with::EnumMap; +/// +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// enum EnumValue { +/// Int(i32), +/// String(String), +/// Unit, +/// } +/// +/// #[serde_with::serde_as] +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct VecEnumValues { +/// #[serde_as(as = "EnumMap")] +/// vec: Vec<EnumValue>, +/// } +/// +/// // --- +/// +/// // This will serialize this list of values +/// let values = VecEnumValues { +/// vec: vec![ +/// EnumValue::Int(123), +/// EnumValue::String("FooBar".to_string()), +/// EnumValue::Int(456), +/// EnumValue::String("XXX".to_string()), +/// EnumValue::Unit, +/// ], +/// }; +/// +/// // into this XML document +/// // Duplicate keys are emitted for identical enum variants. +/// let expected = r#" +/// <VecEnumValues> +/// <vec> +/// <Int>123</Int> +/// <String>FooBar</String> +/// <Int>456</Int> +/// <String>XXX</String> +/// <Unit></Unit> +/// </vec> +/// </VecEnumValues>"# +/// // Remove whitespace +/// .replace(' ', "") +/// .replace('\n', ""); +/// +/// // Both serialization and deserialization work flawlessly. +/// let serialized = serde_xml_rs::to_string(&values).unwrap(); +/// assert_eq!(expected, serialized); +/// let deserialized: VecEnumValues = serde_xml_rs::from_str(&serialized).unwrap(); +/// assert_eq!(values, deserialized); +/// # } +/// ``` +#[derive(Debug, Copy, Clone)] +pub struct EnumMap; + +impl<T> SerializeAs<Vec<T>> for EnumMap +where + T: Serialize, +{ + fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source.serialize(SeqAsMapSerializer(serializer)) + } +} + +impl<'de, T> DeserializeAs<'de, Vec<T>> for EnumMap +where + T: Deserialize<'de>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error> + where + D: Deserializer<'de>, + { + struct EnumMapVisitor<T>(PhantomData<T>); + + impl<'de, T> Visitor<'de> for EnumMapVisitor<T> + where + T: Deserialize<'de>, + { + type Value = Vec<T>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "a map or enum values") + } + + fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> { + Vec::deserialize(SeqDeserializer(map)) + } + } + + deserializer.deserialize_map(EnumMapVisitor(PhantomData)) + } +} + +static END_OF_MAP_IDENTIFIER: &str = "__PRIVATE_END_OF_MAP_MARKER__"; + +// Serialization code below here + +/// Convert a sequence to a map during serialization. +/// +/// Only `serialize_seq` is implemented and forwarded to `serialize_map` on the inner `Serializer`. +/// The elements are serialized with [`SerializeSeqElement`]. +struct SeqAsMapSerializer<S>(S); + +impl<S> Serializer for SeqAsMapSerializer<S> +where + S: Serializer, +{ + type Ok = S::Ok; + type Error = S::Error; + + type SerializeSeq = SerializeSeqElement<S::SerializeMap>; + type SerializeTuple = Impossible<S::Ok, S::Error>; + type SerializeTupleStruct = Impossible<S::Ok, S::Error>; + type SerializeTupleVariant = Impossible<S::Ok, S::Error>; + type SerializeMap = Impossible<S::Ok, S::Error>; + type SerializeStruct = Impossible<S::Ok, S::Error>; + type SerializeStructVariant = Impossible<S::Ok, S::Error>; + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_newtype_variant<T: ?Sized>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { + let is_human_readable = self.0.is_human_readable(); + self.0 + .serialize_map(len) + .map(|delegate| SerializeSeqElement { + delegate, + is_human_readable, + }) + } + + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } +} + +/// Serialize a single element but turn the sequence into a map logic. +/// +/// It uses [`SerializeEnumAsMapElement`] for the map element serialization. +/// +/// The [`Serializer`] implementation handles all the `serialize_*_variant` functions and defers to [`SerializeVariant`] for the more complicated tuple and struct variants. +struct SerializeSeqElement<M> { + delegate: M, + is_human_readable: bool, +} + +impl<M> SerializeSeq for SerializeSeqElement<M> +where + M: SerializeMap, +{ + type Ok = M::Ok; + type Error = M::Error; + + fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + value.serialize(EnumAsMapElementSerializer { + delegate: &mut self.delegate, + is_human_readable: self.is_human_readable, + })?; + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + self.delegate.end() + } +} + +struct EnumAsMapElementSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, +} + +impl<'a, M> Serializer for EnumAsMapElementSerializer<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + type Error = M::Error; + + type SerializeSeq = Impossible<Self::Ok, Self::Error>; + type SerializeTuple = Impossible<Self::Ok, Self::Error>; + type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>; + type SerializeTupleVariant = SerializeVariant<'a, M>; + type SerializeMap = Impossible<Self::Ok, Self::Error>; + type SerializeStruct = Impossible<Self::Ok, Self::Error>; + type SerializeStructVariant = SerializeVariant<'a, M>; + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + ) -> Result<Self::Ok, Self::Error> { + self.delegate.serialize_entry(variant, &())?; + Ok(()) + } + + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_newtype_variant<T: ?Sized>( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + self.delegate.serialize_entry(variant, value)?; + Ok(()) + } + + fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_tuple_variant( + self, + name: &'static str, + _variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { + Ok(SerializeVariant { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + variant, + content: Content::TupleStruct(name, Vec::with_capacity(len)), + }) + } + + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + Err(ser::Error::custom("wrong type for EnumMap")) + } + + fn serialize_struct_variant( + self, + name: &'static str, + _variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { + Ok(SerializeVariant { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + variant, + content: Content::Struct(name, Vec::with_capacity(len)), + }) + } +} + +/// Serialize a struct or tuple variant enum as a map element +/// +/// [`SerializeStructVariant`] serializes a struct variant, and [`SerializeTupleVariant`] a tuple variant. +struct SerializeVariant<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, + variant: &'static str, + content: Content, +} + +impl<'a, M> SerializeStructVariant for SerializeVariant<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + + type Error = M::Error; + + fn serialize_field<T: ?Sized>( + &mut self, + key: &'static str, + value: &T, + ) -> Result<(), Self::Error> + where + T: Serialize, + { + // Serialize to a Content type first + let value: Content = value.serialize(ContentSerializer::new(self.is_human_readable))?; + if let Content::Struct(_name, fields) = &mut self.content { + fields.push((key, value)); + } + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + self.delegate.serialize_entry(&self.variant, &self.content) + } +} + +impl<'a, M> SerializeTupleVariant for SerializeVariant<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + + type Error = M::Error; + + fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + // Serialize to a Content type first + let value: Content = value.serialize(ContentSerializer::new(self.is_human_readable))?; + if let Content::TupleStruct(_name, fields) = &mut self.content { + fields.push(value); + } + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + self.delegate.serialize_entry(&self.variant, &self.content) + } +} + +// Below is deserialization code + +/// Deserialize the sequence of enum instances. +/// +/// The main [`Deserializer`] implementation handles the outer sequence (e.g., `Vec`), while the [`SeqAccess`] implementation is responsible for the inner elements. +struct SeqDeserializer<M>(M); + +impl<'de, M> Deserializer<'de> for SeqDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + visitor.visit_seq(self) + } + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_seq(visitor) + } + + serde::forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct tuple + tuple_struct map struct enum identifier ignored_any + } +} + +impl<'de, M> SeqAccess<'de> for SeqDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> + where + T: DeserializeSeed<'de>, + { + match seed.deserialize(EnumDeserializer(&mut self.0)) { + Ok(value) => Ok(Some(value)), + Err(err) => { + // Unfortunately we loose the optional aspect of MapAccess, so we need to special case an error value to mark the end of the map. + if err.to_string().contains(END_OF_MAP_IDENTIFIER) { + Ok(None) + } else { + Err(err) + } + } + } + } + + fn size_hint(&self) -> Option<usize> { + self.0.size_hint() + } +} + +/// Deserialize an enum from a map element +/// +/// The [`Deserializer`] implementation is the starting point, which first calls the [`EnumAccess`] methods. +/// The [`EnumAccess`] is used to deserialize the enum variant type of the enum. +/// The [`VariantAccess`] is used to deserialize the value part of the enum. +struct EnumDeserializer<M>(M); + +impl<'de, M> Deserializer<'de> for EnumDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_enum("", &[], visitor) + } + + fn deserialize_enum<V>( + self, + _name: &'static str, + _variants: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + visitor.visit_enum(self) + } + + serde::forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct seq tuple + tuple_struct map struct identifier ignored_any + } +} + +impl<'de, M> EnumAccess<'de> for EnumDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + type Variant = Self; + + fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.0.next_key_seed(seed)? { + Some(key) => Ok((key, self)), + + // Unfortunately we loose the optional aspect of MapAccess, so we need to special case an error value to mark the end of the map. + None => Err(Error::custom(END_OF_MAP_IDENTIFIER)), + } + } +} + +impl<'de, M> VariantAccess<'de> for EnumDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn unit_variant(mut self) -> Result<(), Self::Error> { + self.0.next_value() + } + + fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error> + where + T: DeserializeSeed<'de>, + { + self.0.next_value_seed(seed) + } + + fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.0.next_value_seed(SeedTupleVariant { len, visitor }) + } + + fn struct_variant<V>( + mut self, + _fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.0.next_value_seed(SeedStructVariant { visitor }) + } +} + +struct SeedTupleVariant<V> { + len: usize, + visitor: V, +} + +impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + deserializer.deserialize_tuple(self.len, self.visitor) + } +} + +struct SeedStructVariant<V> { + visitor: V, +} + +impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + deserializer.deserialize_map(self.visitor) + } +} diff --git a/third_party/rust/serde_with/src/flatten_maybe.rs b/third_party/rust/serde_with/src/flatten_maybe.rs new file mode 100644 index 0000000000..e012812d5a --- /dev/null +++ b/third_party/rust/serde_with/src/flatten_maybe.rs @@ -0,0 +1,86 @@ +/// Support deserializing from flattened and non-flattened representation +/// +/// When working with different serialization formats, sometimes it is more idiomatic to flatten +/// fields, while other formats prefer nesting. Using `#[serde(flatten)]` only the flattened form +/// is supported. +/// +/// This helper creates a function, which support deserializing from either the flattened or the +/// nested form. It gives an error, when both forms are provided. The `flatten` attribute is +/// required on the field such that the helper works. The serialization format will always be +/// flattened. +/// +/// # Examples +/// +/// ```rust +/// # use serde::Deserialize; +/// # +/// // Setup the types +/// #[derive(Deserialize, Debug)] +/// struct S { +/// #[serde(flatten, deserialize_with = "deserialize_t")] +/// t: T, +/// } +/// +/// #[derive(Deserialize, Debug)] +/// struct T { +/// i: i32, +/// } +/// +/// // The macro creates custom deserialization code. +/// // You need to specify a function name and the field name of the flattened field. +/// serde_with::flattened_maybe!(deserialize_t, "t"); +/// +/// # fn main() { +/// // Supports both flattened +/// let j = r#" {"i":1} "#; +/// assert!(serde_json::from_str::<S>(j).is_ok()); +/// +/// // and non-flattened versions. +/// let j = r#" {"t":{"i":1}} "#; +/// assert!(serde_json::from_str::<S>(j).is_ok()); +/// +/// // Ensure that the value is given +/// let j = r#" {} "#; +/// assert!(serde_json::from_str::<S>(j).is_err()); +/// +/// // and only occurs once, not multiple times. +/// let j = r#" {"i":1,"t":{"i":1}} "#; +/// assert!(serde_json::from_str::<S>(j).is_err()); +/// # } +/// ``` +#[macro_export] +macro_rules! flattened_maybe { + ($fn:ident, $field:literal) => { + fn $fn<'de, T, D>(deserializer: D) -> ::std::result::Result<T, D::Error> + where + T: $crate::serde::Deserialize<'de>, + D: $crate::serde::Deserializer<'de>, + { + use ::std::{ + option::Option::{self, None, Some}, + result::Result::{self, Err, Ok}, + }; + use $crate::serde; + + #[derive($crate::serde::Deserialize)] + #[serde(crate = "serde")] + pub struct Both<T> { + #[serde(flatten)] + flat: Option<T>, + #[serde(rename = $field)] + not_flat: Option<T>, + } + + let both: Both<T> = $crate::serde::Deserialize::deserialize(deserializer)?; + match (both.flat, both.not_flat) { + (Some(t), None) | (None, Some(t)) => Ok(t), + (None, None) => Err($crate::serde::de::Error::missing_field($field)), + (Some(_), Some(_)) => Err($crate::serde::de::Error::custom(concat!( + "`", + $field, + "` is both flattened and not" + ))), + } + } + }; +} diff --git a/third_party/rust/serde_with/src/formats.rs b/third_party/rust/serde_with/src/formats.rs new file mode 100644 index 0000000000..2d7aaa6965 --- /dev/null +++ b/third_party/rust/serde_with/src/formats.rs @@ -0,0 +1,96 @@ +//! Specify the format and how lenient the deserialization is + +use alloc::string::String; + +/// Specify how to serialize/deserialize a type +/// +/// The format specifier allows to configure how a value is serialized/deserialized. +/// For example, you can serialize a timestamp as an integer using the UNIX epoch, as a string containing an integer, or as a string using ISO 8601. +/// This [`Format`] traits allows more flexibility in configuring the format without the need to create a new type for each case. +pub trait Format {} + +macro_rules! impl_format { + ($(#[$attr:meta] $t:ty)*) => { + $( + #[$attr] + impl Format for $t {} + )* + }; +} +macro_rules! create_format { + ($(#[$attr:meta] $t:ident)*) => { + $( + #[$attr] + #[derive(Copy, Clone, Debug, Default)] + pub struct $t; + impl_format!(#[$attr] $t); + )* + }; +} +impl_format!( + /// Serialize into an i8 + i8 + /// Serialize into a u8 + u8 + /// Serialize into an i16 + i16 + /// Serialize into a u16 + u16 + /// Serialize into an i32 + i32 + /// Serialize into a u32 + u32 + /// Serialize into an i64 + i64 + /// Serialize into a u64 + u64 + + /// Serialize into a f32 + f32 + /// Serialize into a f64 + f64 + + /// Serialize into a bool + bool + + /// Serialize into a String + String +); +serde::serde_if_integer128!(impl_format!( + /// Serialize into an i128 + i128 + /// Serialize into a u128 + u128 +);); + +create_format!( + /// Use uppercase characters + Uppercase + /// Use lowercase characters + Lowercase + + /// Use in combination with [`OneOrMany`](crate::OneOrMany). Emit single element for lists of size 1. + PreferOne + /// Use in combination with [`OneOrMany`](crate::OneOrMany). Always emit the list form. + PreferMany + + /// Emit padding during serialization. + Padded + /// Do not emit padding during serialization. + Unpadded +); + +/// Specify how lenient the deserialization process should be +/// +/// Formats which make use of this trait should specify how it affects the deserialization behavior. +pub trait Strictness {} + +/// Use strict deserialization behavior, see [`Strictness`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct Strict; +impl Strictness for Strict {} + +/// Use a flexible deserialization behavior, see [`Strictness`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct Flexible; +impl Strictness for Flexible {} diff --git a/third_party/rust/serde_with/src/guide.md b/third_party/rust/serde_with/src/guide.md new file mode 100644 index 0000000000..9eb80dd915 --- /dev/null +++ b/third_party/rust/serde_with/src/guide.md @@ -0,0 +1,144 @@ +# `serde_with` User Guide + +This crate provides helper functions to extend and change how [`serde`] serializes different data types. +For example, you can serialize [a map as a sequence of tuples][crate::guide::serde_as#maps-to-vec-of-tuples], serialize [using the `Display` and `FromStr` traits][`DisplayFromStr`], or serialize [an empty `String` like `None`][NoneAsEmptyString]. +`serde_with` covers types from the Rust Standard Library and some common crates like [`chrono`][serde_with_chrono]. + +[**A list of all supported transformations is available on this page.**](crate::guide::serde_as_transformations) + +The crate offers four types of functionality. + +## 1. A more flexible and composable replacement for the with annotation, called `serde_as` *(v1.5.0+)* + +This is an alternative to [serde's with-annotation][with-annotation], which adds flexibility and composability to the scheme. +The main downside is that it work with fewer types than [with-annotations][with-annotation]. +However, all types from the Rust Standard Library should be supported in all combinations and any missing entry is a bug. + +The `serde_as` scheme is based on two new traits: [`SerializeAs`] and [`DeserializeAs`]. +[Check out the detailed page about `serde_as` and the available features.](crate::guide::serde_as) + +### Example + +```rust +# use serde::{Deserialize, Serialize}; +# use serde_with::{serde_as, DisplayFromStr}; +# use std::collections::HashMap; +# use std::net::Ipv4Addr; +# +#[serde_as] +# #[derive(Debug, PartialEq, Eq)] +#[derive(Deserialize, Serialize)] +struct Data { + // Type does not implement Serialize or Deserialize + #[serde_as(as = "DisplayFromStr")] + address: Ipv4Addr, + // Treat the Vec like a map with duplicates + // Convert u32 into a String and keep the String the same type + #[serde_as(as = "HashMap<DisplayFromStr, _>")] + vec_as_map: Vec<(u32, String)>, +} + +let data = Data { + address: Ipv4Addr::new(192, 168, 0, 1), + vec_as_map: vec![ + (123, "Hello".into()), + (456, "World".into()), + (123, "Hello".into()), + ], +}; + +let json = r#"{ + "address": "192.168.0.1", + "vec_as_map": { + "123": "Hello", + "456": "World", + "123": "Hello" + } +}"#; + +// Test Serialization +assert_eq!(json, serde_json::to_string_pretty(&data).unwrap()); +// Test Deserialization +assert_eq!(data, serde_json::from_str(json).unwrap()); +``` + +## 2. Integration with serde's with-annotation + +[serde's with-annotation][with-annotation] allows specifying a different serialization or deserialization function for a field. +It is useful to adapt the serialization of existing types to the requirements of a protocol. +Most modules in this crate can be used together with the with-annotation. + +The annotation approach has one big drawback, in that it is very inflexible. +It allows specifying arbitrary serialization code, but the code has to perform the correct transformations. +It is not possible to combine multiple of those functions. +One common use case for this is the serialization of collections like `Vec`. +If you have a field of type `T`, you can apply the with-annotation, but if you have a field of type `Vec<T>`, there is no way to re-use the same functions for the with-annotation. +This inflexibility is fixed in the `serde_as` scheme presented above. + +The example shows a similar setup as in the `serde_as` example above, but using the with-annotation. + +### Example + +```rust +# use serde::{Deserialize, Serialize}; +# use std::net::Ipv4Addr; +# +# #[derive(Debug, PartialEq, Eq)] +#[derive(Deserialize, Serialize)] +struct Data { + // Type does not implement Serialize or Deserialize + #[serde(with = "serde_with::rust::display_fromstr")] + address: Ipv4Addr, + // Treat the Vec like a map with duplicates + #[serde(with = "serde_with::rust::tuple_list_as_map")] + vec_as_map: Vec<(String, u32)>, +} + +let data = Data { + address: Ipv4Addr::new(192, 168, 0, 1), + vec_as_map: vec![ + ("Hello".into(), 123), + ("World".into(), 456), + ("Hello".into(), 123), + ], +}; + +let json = r#"{ + "address": "192.168.0.1", + "vec_as_map": { + "Hello": 123, + "World": 456, + "Hello": 123 + } +}"#; + +// Test Serialization +assert_eq!(json, serde_json::to_string_pretty(&data).unwrap()); +// Test Deserialization +assert_eq!(data, serde_json::from_str(json).unwrap()); +``` + +## 3. proc-macros to make it easier to use both above parts + +The proc-macros are an optional addition and improve the user experience for common tasks. +We have already seen how the `serde_as` attribute is used to define the serialization instructions. + +The proc-macro attributes are defined in the [`serde_with_macros`] crate and re-exported from the root of this crate. +The proc-macros are optional, but enabled by default. +For further details, please refer to the documentation of each proc-macro. + +## 4. Derive macros to implement `Deserialize` and `Serialize` + +The derive macros work similar to the serde provided ones, but they do implement other de/serialization schemes. +For example, the derives [`DeserializeFromStr`] and [`SerializeDisplay`] require that the type also implement [`FromStr`] and [`Display`] and de/serializes from/to a string instead of the usual way of iterating over all fields. + +## Migrating from the with-annotations to `serde_as` + +Each old style module explains how it can be converted to `serde_as`. +Not all modules have such a description since not all are migrated and some are hard to implement in the `serde_as` system. + +[`Display`]: std::fmt::Display +[`FromStr`]: std::str::FromStr +[`serde_with_macros`]: serde_with_macros +[serde_with_chrono]: crate::chrono +[with-annotation]: https://serde.rs/field-attrs.html#with diff --git a/third_party/rust/serde_with/src/guide/feature_flags.md b/third_party/rust/serde_with/src/guide/feature_flags.md new file mode 100644 index 0000000000..9e80177ad2 --- /dev/null +++ b/third_party/rust/serde_with/src/guide/feature_flags.md @@ -0,0 +1,62 @@ +# Available Feature Flags + +This crate has the following features which can be enabled. +Each entry will explain the feature in more detail. + +1. [`base64`](#base64) +2. [`chrono`](#chrono) +3. [`guide`](#guide) +4. [`hex`](#hex) +5. [`indexmap`](#indexmap) +6. [`json`](#json) +7. [`macros`](#macros) +8. [`time_0_3`](#time_0_3) + +## `base64` + +The `base64` feature enables serializing data in base64 format. + +This pulls in `base64` as a dependency. + +## `chrono` + +The `chrono` feature enables integration of `chrono` specific conversions. +This includes support for the timestamp and duration types. + +This pulls in `chrono` as a dependency. + +## `guide` + +The `guide` feature enables inclusion of this user guide. +The feature only changes the rustdoc output and enables no other effects. + +## `hex` + +The `hex` feature enables serializing data in hex format. + +This pulls in `hex` as a dependency. + +## `indexmap` + +The `indexmap` feature enables implementations of `indexmap` specific checks. +This includes support for checking duplicate keys + +## `json` + +The `json` features enables JSON conversions from the `json` module. + +This pulls in `serde_json` as a dependency. + +## `macros` + +The `macros` features enables all helper macros and derives. +It is enabled by default, since the macros provide a usability benefit, especially for `serde_as`. + +This pulls in `serde_with_macros` as a dependency. + +## `time_0_3` + +The `time_0_3` enables integration of `time` v0.3 specific conversions. +This includes support for the timestamp and duration types. + +This pulls in `time` v0.3 as a dependency. diff --git a/third_party/rust/serde_with/src/guide/serde_as.md b/third_party/rust/serde_with/src/guide/serde_as.md new file mode 100644 index 0000000000..76275f0047 --- /dev/null +++ b/third_party/rust/serde_with/src/guide/serde_as.md @@ -0,0 +1,332 @@ +# `serde_as` Annotation + +This is an alternative to serde's with-annotation. +It is more flexible and composable, but work with fewer types. + +The scheme is based on two new traits, [`SerializeAs`] and [`DeserializeAs`], which need to be implemented by all types which want to be compatible with `serde_as`. +The proc-macro attribute [`#[serde_as]`][crate::serde_as] exists as a usability boost for users. +The basic design of `serde_as` was developed by [@markazmierczak](https://github.com/markazmierczak). + +This page contains some general advice on the usage of `serde_as` and on implementing the necessary traits. +[**A list of all supported transformations enabled by `serde_as` is available on this page.**](crate::guide::serde_as_transformations) + +1. [Switching from serde's with to `serde_as`](#switching-from-serdes-with-to-serde_as) + 1. [Deserializing Optional Fields](#deserializing-optional-fields) + 2. [Gating `serde_as` on Features](#gating-serde_as-on-features) +2. [Implementing `SerializeAs` / `DeserializeAs`](#implementing-serializeas--deserializeas) + 1. [Using `#[serde_as]` on types without `SerializeAs` and `Serialize` implementations](#using-serde_as-on-types-without-serializeas-and-serialize-implementations) + 2. [Using `#[serde_as]` with serde's remote derives](#using-serde_as-with-serdes-remote-derives) +3. [Re-exporting `serde_as`](#re-exporting-serde_as) + +## Switching from serde's with to `serde_as` + +For the user, the main difference is that instead of + +```rust,ignore +#[serde(with = "...")] +``` + +you now have to write + +```rust,ignore +#[serde_as(as = "...")] +``` + +and place the `#[serde_as]` attribute *before* the `#[derive]` attribute. +You still need the `#[derive(Serialize, Deserialize)]` on the struct/enum. + +All together, this looks like: + +```rust +use serde::{Deserialize, Serialize}; +use serde_with::{serde_as, DisplayFromStr}; + +#[serde_as] +#[derive(Serialize, Deserialize)] +struct A { + #[serde_as(as = "DisplayFromStr")] + mime: mime::Mime, +} +``` + +The main advantage is that you can compose `serde_as` stuff, which is impossible with the with-annotation. +For example, the `mime` field from above could be nested in one or more data structures: + +```rust +# use std::collections::BTreeMap; +# use serde::{Deserialize, Serialize}; +# use serde_with::{serde_as, DisplayFromStr}; +# +#[serde_as] +#[derive(Serialize, Deserialize)] +struct A { + #[serde_as(as = "Option<BTreeMap<_, Vec<DisplayFromStr>>>")] + mime: Option<BTreeMap<String, Vec<mime::Mime>>>, +} +``` + +### Deserializing Optional Fields + +During deserialization, serde treats fields of `Option<T>` as optional and does not require them to be present. +This breaks when adding either the `serde_as` annotation or serde's `with` annotation. +The default behavior can be restored by adding serde's `default` attribute. + +```rust +# use serde::{Deserialize, Serialize}; +# use serde_with::{serde_as, DisplayFromStr}; +# +#[serde_as] +#[derive(Serialize, Deserialize)] +struct A { + #[serde_as(as = "Option<DisplayFromStr>")] + // Allows deserialization without providing a value for `val` + #[serde(default)] + val: Option<u32>, +} +``` + +In the future, this behavior might change and `default` would be applied on `Option<T>` fields. +You can add your feedback at [serde_with#185]. + +### Gating `serde_as` on Features + +Gating `serde_as` behind optional features is currently not supported. +More details can be found in the corresponding issue [serde_with#355]. + +```rust,ignore +#[cfg_attr(feature="serde" ,serde_as)] +#[cfg_attr(feature="serde", derive(Serialize, Deserialize))] +struct StructC { + #[cfg_attr(feature="serde" ,serde_as(as = "Vec<(_, _)>"))] + map: HashMap<(i32,i32), i32>, +} +``` + +The `serde_as` proc-macro attribute will not recognize the `serde_as` attribute on the field and will not perform the necessary translation steps. +The problem can be avoided by forcing Rust to evaluate all cfg-expressions before running `serde_as`. +This is possible with the `#[cfg_eval]` attribute, which is considered for stabilization ([rust#82679], [rust#87221]). + +As a workaround, it is possible to remove the `serde_as` proc-macro attribute and perform the transformation manually. +The transformation steps are listed in the [`serde_as`] documentations. +For the example above, this means to replace the field attribute with: + +```rust,ignore +use serde_with::{As, Same}; + +#[cfg_attr(feature="serde", serde(with = "As::<Vec<(Same, Same)>>"))] +map: HashMap<(i32,i32), i32>, +``` + +[rust#82679]: https://github.com/rust-lang/rust/issues/82679 +[rust#87221]: https://github.com/rust-lang/rust/pull/87221 +[serde_with#355]: https://github.com/jonasbb/serde_with/issues/355 + +## Implementing `SerializeAs` / `DeserializeAs` + +You can support [`SerializeAs`] / [`DeserializeAs`] on your own types too. +Most "leaf" types do not need to implement these traits, since they are supported implicitly. +"Leaf" type refers to types which directly serialize like plain data types. +[`SerializeAs`] / [`DeserializeAs`] is very important for collection types, like `Vec` or `BTreeMap`, since they need special handling for the key/value de/serialization such that the conversions can be done on the key/values. +You also find them implemented on the conversion types, such as the [`DisplayFromStr`] type. +These make up the bulk of this crate and allow you to perform all the nice conversions to [hex strings], the [bytes to string converter], or [duration to UNIX epoch]. + +In many cases, conversion is only required from one serializable type to another one, without requiring the full power of the `Serialize` or `Deserialize` traits. +In these cases, the [`serde_conv!`] macro conveniently allows defining conversion types without the boilerplate. +The documentation of [`serde_conv!`] contains more details how to use it. + +The trait documentations for [`SerializeAs`] and [`DeserializeAs`] describe in details how to implement them for container types like `Box` or `Vec` and other types. + +### Using `#[serde_as]` on types without `SerializeAs` and `Serialize` implementations + +The `SerializeAs` and `DeserializeAs` traits can easily be used together with types from other crates without running into orphan rule problems. +This is a distinct advantage of the `serde_as` system. +For this example we assume we have a type `RemoteType` from a dependency which does not implement `Serialize` nor `SerializeAs`. +We assume we have a module containing a `serialize` and a `deserialize` function, which can be used in the `#[serde(with = "MODULE")]` annotation. +You find an example in the [official serde documentation](https://serde.rs/custom-date-format.html). + +Our goal is to serialize this `Data` struct. +Right now, we do not have anything we can use to replace `???` with, since `_` only works if `RemoteType` would implement `Serialize`, which it does not. + +```rust +# #[cfg(FALSE)] { +#[serde_as] +#[derive(serde::Serialize)] +struct Data { + #[serde_as(as = "Vec<???>")] + vec: Vec<RemoteType>, +} +# } +``` + +We need to create a new type for which we can implement `SerializeAs`, to replace the `???`. +The `SerializeAs` implementation is **always** written for a local type. +This allows it to seamlessly work with types from dependencies without running into orphan rule problems. + +```rust +# #[cfg(FALSE)] { +struct LocalType; + +impl SerializeAs<RemoteType> for LocalType { + fn serialize_as<S>(value: &RemoteType, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + MODULE::serialize(value, serializer) + } +} + +impl<'de> DeserializeAs<'de, RemoteType> for LocalType { + fn deserialize_as<D>(deserializer: D) -> Result<RemoteType, D::Error> + where + D: Deserializer<'de>, + { + MODULE::deserialize(deserializer) + } +} +# } +``` + +This is how the final implementation looks like. +We assumed we have a module `MODULE` with a `serialize` function already, which we use here to provide the implementation. +As can be seen, this is mostly boilerplate, since the most part is encapsulated in `$module::serialize`. +The final `Data` struct will now look like: + +```rust +# #[cfg(FALSE)] { +#[serde_as] +#[derive(serde::Serialize)] +struct Data { + #[serde_as(as = "Vec<LocalType>")] + vec: Vec<RemoteType>, +} +# } +``` + +### Using `#[serde_as]` with serde's remote derives + +A special case of the above section is using it on remote derives. +This is a special functionality of serde, where it derives the de/serialization code for a type from another crate if all fields are `pub`. +You can find all the details in the [official serde documentation](https://serde.rs/remote-derive.html). + +```rust +# #[cfg(FALSE)] { +// Pretend that this is somebody else's crate, not a module. +mod other_crate { + // Neither Serde nor the other crate provides Serialize and Deserialize + // impls for this struct. + pub struct Duration { + pub secs: i64, + pub nanos: i32, + } +} + +//////////////////////////////////////////////////////////////////////////////// + +use other_crate::Duration; + +// Serde calls this the definition of the remote type. It is just a copy of the +// remote data structure. The `remote` attribute gives the path to the actual +// type we intend to derive code for. +#[derive(serde::Serialize, serde::Deserialize)] +#[serde(remote = "Duration")] +struct DurationDef { + secs: i64, + nanos: i32, +} +# } +``` + +Our goal is now to use `Duration` within `serde_as`. +We use the existing `DurationDef` type and its `serialize` and `deserialize` functions. +We can write this implementation. +The implementation for `DeserializeAs` works analogue. + +```rust +# #[cfg(FALSE)] { +impl SerializeAs<Duration> for DurationDef { + fn serialize_as<S>(value: &Duration, serializer: S) -> Result<S::Ok, S::Error> + where + S: serde::Serializer, + { + DurationDef::serialize(value, serializer) + } +} +# } +``` + +This now allows us to use `Duration` for serialization. + +```rust +# #[cfg(FALSE)] { +use other_crate::Duration; + +#[serde_as] +#[derive(serde::Serialize)] +struct Data { + #[serde_as(as = "Vec<DurationDef>")] + vec: Vec<Duration>, +} +# } +``` + +## Re-exporting `serde_as` + +If `serde_as` is being used in a context where the `serde_with` crate is not available from the root +path, but is re-exported at some other path, the `crate = "..."` attribute argument should be used +to specify its path. This may be the case if `serde_as` is being used in a procedural macro - +otherwise, users of that macro would need to add `serde_with` to their own Cargo manifest. + +The `crate` argument will generally be used in conjunction with [`serde`'s own `crate` argument]. + +For example, a type definition may be defined in a procedural macro: + +```rust,ignore +// some_other_lib_derive/src/lib.rs + +use proc_macro::TokenStream; +use quote::quote; + +#[proc_macro] +pub fn define_some_type(_item: TokenStream) -> TokenStream { + let def = quote! { + #[serde(crate = "::some_other_lib::serde")] + #[::some_other_lib::serde_with::serde_as(crate = "::some_other_lib::serde_with")] + #[derive(::some_other_lib::serde::Deserialize)] + struct Data { + #[serde_as(as = "_")] + a: u32, + } + }; + + TokenStream::from(def) +} +``` + +This can be re-exported through a library which also re-exports `serde` and `serde_with`: + +```rust,ignore +// some_other_lib/src/lib.rs + +pub use serde; +pub use serde_with; +pub use some_other_lib_derive::define_some_type; +``` + +The procedural macro can be used by other crates without any additional imports: + +```rust,ignore +// consuming_crate/src/main.rs + +some_other_lib::define_some_type!(); +``` + +[`DeserializeAs`]: crate::DeserializeAs +[`DisplayFromStr`]: crate::DisplayFromStr +[`serde_as`]: crate::serde_as +[`serde_conv!`]: crate::serde_conv! +[`serde`'s own `crate` argument]: https://serde.rs/container-attrs.html#crate +[`SerializeAs`]: crate::SerializeAs +[bytes to string converter]: crate::BytesOrString +[duration to UNIX epoch]: crate::DurationSeconds +[hex strings]: crate::hex::Hex +[serde_with#185]: https://github.com/jonasbb/serde_with/issues/185 diff --git a/third_party/rust/serde_with/src/guide/serde_as_transformations.md b/third_party/rust/serde_with/src/guide/serde_as_transformations.md new file mode 100644 index 0000000000..9be67e154b --- /dev/null +++ b/third_party/rust/serde_with/src/guide/serde_as_transformations.md @@ -0,0 +1,518 @@ +# De/Serialize Transformations Available + +This page lists the transformations implemented in this crate and supported by `serde_as`. + +1. [Base64 encode bytes](#base64-encode-bytes) +2. [Big Array support](#big-array-support) +3. [`bool` from integer](#bool-from-integer) +4. [Borrow from the input for `Cow` type](#borrow-from-the-input-for-cow-type) +5. [`Bytes` with more efficiency](#bytes-with-more-efficiency) +6. [Convert to an intermediate type using `Into`](#convert-to-an-intermediate-type-using-into) +7. [Convert to an intermediate type using `TryInto`](#convert-to-an-intermediate-type-using-tryinto) +8. [`Default` from `null`](#default-from-null) +9. [De/Serialize into `Vec`, ignoring errors](#deserialize-into-vec-ignoring-errors) +10. [De/Serialize with `FromStr` and `Display`](#deserialize-with-fromstr-and-display) +11. [`Duration` as seconds](#duration-as-seconds) +12. [Hex encode bytes](#hex-encode-bytes) +13. [Ignore deserialization errors](#ignore-deserialization-errors) +14. [`Maps` to `Vec` of enums](#maps-to-vec-of-enums) +15. [`Maps` to `Vec` of tuples](#maps-to-vec-of-tuples) +16. [`NaiveDateTime` like UTC timestamp](#naivedatetime-like-utc-timestamp) +17. [`None` as empty `String`](#none-as-empty-string) +18. [One or many elements into `Vec`](#one-or-many-elements-into-vec) +19. [Pick first successful deserialization](#pick-first-successful-deserialization) +20. [Timestamps as seconds since UNIX epoch](#timestamps-as-seconds-since-unix-epoch) +21. [Value into JSON String](#value-into-json-string) +22. [`Vec` of tuples to `Maps`](#vec-of-tuples-to-maps) +23. [Well-known time formats for `OffsetDateTime`](#well-known-time-formats-for-offsetdatetime) + +## Base64 encode bytes + +[`Base64`] + +Requires the `base64` feature. +The character set and padding behavior can be configured. + +```ignore +// Rust +#[serde_as(as = "serde_with::base64::Base64")] +value: Vec<u8>, +#[serde_as(as = "Base64<Bcrypt, Unpadded>")] +bcrypt_unpadded: Vec<u8>, + +// JSON +"value": "SGVsbG8gV29ybGQ=", +"bcrypt_unpadded": "QETqZE6eT07wZEO", +``` + +## Big Array support + +Support for arrays of arbitrary size. + +```ignore +// Rust +#[serde_as(as = "[[_; 64]; 33]")] +value: [[u8; 64]; 33], + +// JSON +"value": [[0,0,0,0,0,...], [0,0,0,...], ...], +``` + +## `bool` from integer + +Deserialize an integer and convert it into a `bool`. +[`BoolFromInt<Strict>`] (default) deserializes 0 to `false` and `1` to `true`, other numbers are errors. +[`BoolFromInt<Flexible>`] deserializes any non-zero as `true`. +Serialization only emits 0/1. + +```ignore +// Rust +#[serde_as(as = "BoolFromInt")] // BoolFromInt<Strict> +b: bool, + +// JSON +"b": 1, +``` + +## Borrow from the input for `Cow` type + +The types `Cow<'_, str>`, `Cow<'_, [u8]>`, or `Cow<'_, [u8; N]>` can borrow from the input, avoiding extra copies. + +```ignore +// Rust +#[serde_as(as = "BorrowCow")] +value: Cow<'a, str>, + +// JSON +"value": "foobar", +``` + +## `Bytes` with more efficiency + +[`Bytes`] + +More efficient serialization for byte slices and similar. + +```ignore +// Rust +#[serde_as(as = "Bytes")] +value: Vec<u8>, + +// JSON +"value": [0, 1, 2, 3, ...], +``` + +## Convert to an intermediate type using `Into` + +[`FromInto`] + +```ignore +// Rust +#[serde_as(as = "FromInto<(u8, u8, u8)>")] +value: Rgb, + +impl From<(u8, u8, u8)> for Rgb { ... } +impl From<Rgb> for (u8, u8, u8) { ... } + +// JSON +"value": [128, 64, 32], +``` + +## Convert to an intermediate type using `TryInto` + +[`TryFromInto`] + +```ignore +// Rust +#[serde_as(as = "TryFromInto<i8>")] +value: u8, + +// JSON +"value": 127, +``` + +## `Default` from `null` + +[`DefaultOnNull`] + +```ignore +// Rust +#[serde_as(as = "DefaultOnNull")] +value: u32, +#[serde_as(as = "DefaultOnNull<DisplayFromStr>")] +value2: u32, + +// JSON +"value": 123, +"value2": "999", + +// Deserializes null into the Default value, i.e., +null => 0 +``` + +## De/Serialize into `Vec`, ignoring errors + +[`VecSkipError`] + +For formats with heterogenous-typed sequences, we can collect only the deserializable elements. +This is also useful for unknown enum variants. + +```ignore +#[derive(serde::Deserialize)] +enum Color { + Red, + Green, + Blue, +} + +// JSON +"colors": ["Blue", "Yellow", "Green"], + +// Rust +#[serde_as(as = "VecSkipError<_>")] +colors: Vec<Color>, + +// => vec![Blue, Green] +``` + +## De/Serialize with `FromStr` and `Display` + +Useful if a type implements `FromStr` / `Display` but not `Deserialize` / `Serialize`. + +[`DisplayFromStr`] + +```ignore +// Rust +#[serde_as(as = "serde_with::DisplayFromStr")] +value: u128, +#[serde_as(as = "serde_with::DisplayFromStr")] +mime: mime::Mime, + +// JSON +"value": "340282366920938463463374607431768211455", +"mime": "text/*", +``` + +## `Duration` as seconds + +[`DurationSeconds`] + +```ignore +// Rust +#[serde_as(as = "serde_with::DurationSeconds<u64>")] +value: Duration, + +// JSON +"value": 86400, +``` + +[`DurationSecondsWithFrac`] supports subsecond precision: + +```ignore +// Rust +#[serde_as(as = "serde_with::DurationSecondsWithFrac<f64>")] +value: Duration, + +// JSON +"value": 1.234, +``` + +Different serialization formats are possible: + +```ignore +// Rust +#[serde_as(as = "serde_with::DurationSecondsWithFrac<String>")] +value: Duration, + +// JSON +"value": "1.234", +``` + +The same conversions are also implemented for [`chrono::Duration`] with the `chrono` feature. + +The same conversions are also implemented for [`time::Duration`] with the `time_0_3` feature. + +## Hex encode bytes + +[`Hex`] + +Requires the `hex` feature. +The hex string can use upper- and lowercase characters. + +```ignore +// Rust +#[serde_as(as = "serde_with::hex::Hex")] +lowercase: Vec<u8>, +#[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Uppercase>")] +uppercase: Vec<u8>, + +// JSON +"lowercase": "deadbeef", +"uppercase": "DEADBEEF", +``` + +## Ignore deserialization errors + +Check the documentation for [`DefaultOnError`]. + +## `Maps` to `Vec` of enums + +[`EnumMap`] + +Combine multiple enum values into a single map. +The key is the enum variant name, and the value is the variant value. +This only works with [*externally tagged*] enums, the default enum representation. +Other forms cannot be supported. + +```ignore +enum EnumValue { + Int(i32), + String(String), + Unit, + Tuple(i32, String), + Struct { + a: i32, + b: String, + }, +} + +// Rust +struct VecEnumValues ( + #[serde_as(as = "EnumMap")] + Vec<EnumValue>, +); + +VecEnumValues(vec![ + EnumValue::Int(123), + EnumValue::String("Foo".to_string()), + EnumValue::Unit, + EnumValue::Tuple(1, "Bar".to_string()), + EnumValue::Struct { + a: 666, + b: "Baz".to_string(), + }, +]) + +// JSON +{ + "Int": 123, + "String": "Foo", + "Unit": null, + "Tuple": [ + 1, + "Bar", + ], + "Struct": { + "a": 666, + "b": "Baz", + } +} +``` + +[*externally tagged*]: https://serde.rs/enum-representations.html#externally-tagged + +## `Maps` to `Vec` of tuples + +```ignore +// Rust +#[serde_as(as = "Vec<(_, _)>")] +value: HashMap<String, u32>, // also works with BTreeMap + +// JSON +"value": [ + ["hello", 1], + ["world", 2] +], +``` + +The [inverse operation](#vec-of-tuples-to-maps) is also available. + +## `NaiveDateTime` like UTC timestamp + +Requires the `chrono` feature. + +```ignore +// Rust +#[serde_as(as = "chrono::DateTime<chrono::Utc>")] +value: chrono::NaiveDateTime, + +// JSON +"value": "1994-11-05T08:15:30Z", + ^ Pretend DateTime is UTC +``` + +## `None` as empty `String` + +[`NoneAsEmptyString`] + +```ignore +// Rust +#[serde_as(as = "serde_with::NoneAsEmptyString")] +value: Option<String>, + +// JSON +"value": "", // converts to None + +"value": "Hello World!", // converts to Some +``` + +## One or many elements into `Vec` + +[`OneOrMany`] + +```ignore +// Rust +#[serde_as(as = "serde_with::OneOrMany<_>")] +value: Vec<String>, + +// JSON +"value": "", // Deserializes single elements + +"value": ["Hello", "World!"], // or lists of many +``` + +## Pick first successful deserialization + +[`PickFirst`] + +```ignore +// Rust +#[serde_as(as = "serde_with::PickFirst<(_, serde_with::DisplayFromStr)>")] +value: u32, + +// JSON +// serialize into +"value": 666, +// deserialize from either +"value": 666, +"value": "666", +``` + +## Timestamps as seconds since UNIX epoch + +[`TimestampSeconds`] + +```ignore +// Rust +#[serde_as(as = "serde_with::TimestampSeconds<i64>")] +value: SystemTime, + +// JSON +"value": 86400, +``` + +[`TimestampSecondsWithFrac`] supports subsecond precision: + +```ignore +// Rust +#[serde_as(as = "serde_with::TimestampSecondsWithFrac<f64>")] +value: SystemTime, + +// JSON +"value": 1.234, +``` + +Different serialization formats are possible: + +```ignore +// Rust +#[serde_as(as = "serde_with::TimestampSecondsWithFrac<String>")] +value: SystemTime, + +// JSON +"value": "1.234", +``` + +The same conversions are also implemented for [`chrono::DateTime<Utc>`], [`chrono::DateTime<Local>`], and [`chrono::NaiveDateTime`] with the `chrono` feature. + +The conversions are availble for [`time::OffsetDateTime`] and [`time::PrimitiveDateTime`] with the `time_0_3` feature enabled. + +## Value into JSON String + +Some JSON APIs are weird and return a JSON encoded string in a JSON response + +[`JsonString`] + +Requires the `json` feature. + +```ignore +// Rust +#[derive(Deserialize, Serialize)] +struct OtherStruct { + value: usize, +} + +#[serde_as(as = "serde_with::json::JsonString")] +value: OtherStruct, + +// JSON +"value": "{\"value\":5}", +``` + +## `Vec` of tuples to `Maps` + +```ignore +// Rust +#[serde_as(as = "HashMap<_, _>")] // also works with BTreeMap +value: Vec<(String, u32)>, + +// JSON +"value": { + "hello": 1, + "world": 2 +}, +``` + +This operation is also available for other sequence types. +This includes `BinaryHeap<(K, V)>`, `BTreeSet<(K, V)>`, `HashSet<(K, V)>`, `LinkedList<(K, V)>`, `VecDeque<(K, V)>`, `Option<(K, V)>` and `[(K, V); N]` for all sizes of N. + +The [inverse operation](#maps-to-vec-of-tuples) is also available. + +## Well-known time formats for `OffsetDateTime` + +[`time::OffsetDateTime`] can be serialized in string format in different well-known formats. +Two formats are supported, [`time::format_description::well_known::Rfc2822`] and [`time::format_description::well_known::Rfc3339`]. + +```ignore +// Rust +#[serde_as(as = "time::format_description::well_known::Rfc2822")] +rfc_2822: OffsetDateTime, +#[serde_as(as = "time::format_description::well_known::Rfc3339")] +rfc_3339: OffsetDateTime, + +// JSON +"rfc_2822": "Fri, 21 Nov 1997 09:55:06 -0600", +"rfc_3339": "1997-11-21T09:55:06-06:00", +``` + +These conversions are availble with the `time_0_3` feature flag. + +[`Base64`]: crate::base64::Base64 +[`BoolFromInt<Flexible>`]: crate::BoolFromInt +[`BoolFromInt<Strict>`]: crate::BoolFromInt +[`Bytes`]: crate::Bytes +[`chrono::DateTime<Local>`]: chrono_crate::DateTime +[`chrono::DateTime<Utc>`]: chrono_crate::DateTime +[`chrono::Duration`]: https://docs.rs/chrono/latest/chrono/struct.Duration.html +[`chrono::NaiveDateTime`]: chrono_crate::NaiveDateTime +[`DefaultOnError`]: crate::DefaultOnError +[`DefaultOnNull`]: crate::DefaultOnNull +[`DisplayFromStr`]: crate::DisplayFromStr +[`DurationSeconds`]: crate::DurationSeconds +[`DurationSecondsWithFrac`]: crate::DurationSecondsWithFrac +[`EnumMap`]: crate::EnumMap +[`FromInto`]: crate::FromInto +[`Hex`]: crate::hex::Hex +[`JsonString`]: crate::json::JsonString +[`NoneAsEmptyString`]: crate::NoneAsEmptyString +[`OneOrMany`]: crate::OneOrMany +[`PickFirst`]: crate::PickFirst +[`time::Duration`]: time_0_3::Duration +[`time::format_description::well_known::Rfc2822`]: time_0_3::format_description::well_known::Rfc2822 +[`time::format_description::well_known::Rfc3339`]: time_0_3::format_description::well_known::Rfc3339 +[`time::OffsetDateTime`]: time_0_3::OffsetDateTime +[`time::PrimitiveDateTime`]: time_0_3::PrimitiveDateTime +[`TimestampSeconds`]: crate::TimestampSeconds +[`TimestampSecondsWithFrac`]: crate::TimestampSecondsWithFrac +[`TryFromInto`]: crate::TryFromInto +[`VecSkipError`]: crate::VecSkipError diff --git a/third_party/rust/serde_with/src/hex.rs b/third_party/rust/serde_with/src/hex.rs new file mode 100644 index 0000000000..1937e35394 --- /dev/null +++ b/third_party/rust/serde_with/src/hex.rs @@ -0,0 +1,155 @@ +//! De/Serialization of hexadecimal encoded bytes +//! +//! This modules is only available when using the `hex` feature of the crate. +//! +//! Please check the documentation on the [`Hex`] type for details. + +use crate::{ + de::DeserializeAs, + formats::{Format, Lowercase, Uppercase}, + ser::SerializeAs, +}; +use alloc::{borrow::Cow, format, vec::Vec}; +use core::{ + convert::{TryFrom, TryInto}, + marker::PhantomData, +}; +use serde::{de::Error, Deserialize, Deserializer, Serializer}; + +/// Serialize bytes as a hex string +/// +/// The type serializes a sequence of bytes as a hexadecimal string. +/// It works on any type implementing `AsRef<[u8]>` for serialization and `TryFrom<Vec<u8>>` for deserialization. +/// +/// The format type parameter specifies if the hex string should use lower- or uppercase characters. +/// Valid options are the types [`Lowercase`] and [`Uppercase`]. +/// Deserialization always supports lower- and uppercase characters, even mixed in one string. +/// +/// # Example +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::serde_as; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq, Eq)] +/// #[derive(Deserialize, Serialize)] +/// struct BytesLowercase( +/// // Equivalent to serde_with::hex::Hex<serde_with::formats::Lowercase> +/// #[serde_as(as = "serde_with::hex::Hex")] +/// Vec<u8> +/// ); +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq, Eq)] +/// #[derive(Deserialize, Serialize)] +/// struct BytesUppercase( +/// #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Uppercase>")] +/// Vec<u8> +/// ); +/// +/// let b = b"Hello World!"; +/// +/// // Hex with lowercase letters +/// assert_eq!( +/// json!("48656c6c6f20576f726c6421"), +/// serde_json::to_value(BytesLowercase(b.to_vec())).unwrap() +/// ); +/// // Hex with uppercase letters +/// assert_eq!( +/// json!("48656C6C6F20576F726C6421"), +/// serde_json::to_value(BytesUppercase(b.to_vec())).unwrap() +/// ); +/// +/// // Serialization always work from lower- and uppercase characters, even mixed case. +/// assert_eq!( +/// BytesLowercase(vec![0x00, 0xaa, 0xbc, 0x99, 0xff]), +/// serde_json::from_value(json!("00aAbc99FF")).unwrap() +/// ); +/// assert_eq!( +/// BytesUppercase(vec![0x00, 0xaa, 0xbc, 0x99, 0xff]), +/// serde_json::from_value(json!("00aAbc99FF")).unwrap() +/// ); +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq, Eq)] +/// #[derive(Deserialize, Serialize)] +/// struct ByteArray( +/// // Equivalent to serde_with::hex::Hex<serde_with::formats::Lowercase> +/// #[serde_as(as = "serde_with::hex::Hex")] +/// [u8; 12] +/// ); +/// +/// let b = b"Hello World!"; +/// +/// assert_eq!( +/// json!("48656c6c6f20576f726c6421"), +/// serde_json::to_value(ByteArray(b.clone())).unwrap() +/// ); +/// +/// // Serialization always work from lower- and uppercase characters, even mixed case. +/// assert_eq!( +/// ByteArray([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0xaa, 0xbc, 0x99, 0xff]), +/// serde_json::from_value(json!("0011223344556677aAbc99FF")).unwrap() +/// ); +/// +/// // Remember that the conversion may fail. (The following errors are specific to fixed-size arrays) +/// let error_result: Result<ByteArray, _> = serde_json::from_value(json!("42")); // Too short +/// error_result.unwrap_err(); +/// +/// let error_result: Result<ByteArray, _> = +/// serde_json::from_value(json!("000000000000000000000000000000")); // Too long +/// error_result.unwrap_err(); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct Hex<FORMAT: Format = Lowercase>(PhantomData<FORMAT>); + +impl<T> SerializeAs<T> for Hex<Lowercase> +where + T: AsRef<[u8]>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_str(&hex::encode(source)) + } +} + +impl<T> SerializeAs<T> for Hex<Uppercase> +where + T: AsRef<[u8]>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_str(&hex::encode_upper(source)) + } +} + +impl<'de, T, FORMAT> DeserializeAs<'de, T> for Hex<FORMAT> +where + T: TryFrom<Vec<u8>>, + FORMAT: Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + <Cow<'de, str> as Deserialize<'de>>::deserialize(deserializer) + .and_then(|s| hex::decode(&*s).map_err(Error::custom)) + .and_then(|vec: Vec<u8>| { + let length = vec.len(); + vec.try_into().map_err(|_e: T::Error| { + Error::custom(format!( + "Can't convert a Byte Vector of length {} to the output type.", + length + )) + }) + }) + } +} diff --git a/third_party/rust/serde_with/src/json.rs b/third_party/rust/serde_with/src/json.rs new file mode 100644 index 0000000000..699d31c8d2 --- /dev/null +++ b/third_party/rust/serde_with/src/json.rs @@ -0,0 +1,150 @@ +//! De/Serialization of JSON +//! +//! This modules is only available when using the `json` feature of the crate. + +use crate::{de::DeserializeAs, ser::SerializeAs}; +use serde::{de::DeserializeOwned, Deserializer, Serialize, Serializer}; + +/// Serialize value as string containing JSON +/// +/// The same functionality is also available as [`serde_with::json::JsonString`][crate::json::JsonString] compatible with the `serde_as`-annotation. +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::json::nested")] +/// other_struct: B, +/// } +/// #[derive(Deserialize, Serialize)] +/// struct B { +/// value: usize, +/// } +/// +/// let v: A = serde_json::from_str(r#"{"other_struct":"{\"value\":5}"}"#).unwrap(); +/// assert_eq!(5, v.other_struct.value); +/// +/// let x = A { +/// other_struct: B { value: 10 }, +/// }; +/// assert_eq!( +/// r#"{"other_struct":"{\"value\":10}"}"#, +/// serde_json::to_string(&x).unwrap() +/// ); +/// ``` +pub mod nested { + use core::{fmt, marker::PhantomData}; + use serde::{ + de::{DeserializeOwned, Deserializer, Error, Visitor}, + ser::{self, Serialize, Serializer}, + }; + + /// Deserialize value from a string which is valid JSON + pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: DeserializeOwned, + { + #[derive(Default)] + struct Helper<S: DeserializeOwned>(PhantomData<S>); + + impl<'de, S> Visitor<'de> for Helper<S> + where + S: DeserializeOwned, + { + type Value = S; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "valid json object") + } + + fn visit_str<E>(self, value: &str) -> Result<S, E> + where + E: Error, + { + serde_json::from_str(value).map_err(Error::custom) + } + } + + deserializer.deserialize_str(Helper(PhantomData)) + } + + /// Serialize value as string containing JSON + /// + /// # Errors + /// + /// Serialization can fail if `T`'s implementation of `Serialize` decides to + /// fail, or if `T` contains a map with non-string keys. + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + let s = serde_json::to_string(value).map_err(ser::Error::custom)?; + serializer.serialize_str(&*s) + } +} + +/// Serialize value as string containing JSON +/// +/// The same functionality is also available as [`serde_with::json::nested`][crate::json::nested] compatible with serde's with-annotation. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{serde_as, json::JsonString}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "JsonString")] +/// other_struct: B, +/// } +/// #[derive(Deserialize, Serialize)] +/// struct B { +/// value: usize, +/// } +/// +/// let v: A = serde_json::from_str(r#"{"other_struct":"{\"value\":5}"}"#).unwrap(); +/// assert_eq!(5, v.other_struct.value); +/// +/// let x = A { +/// other_struct: B { value: 10 }, +/// }; +/// assert_eq!( +/// r#"{"other_struct":"{\"value\":10}"}"#, +/// serde_json::to_string(&x).unwrap() +/// ); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct JsonString; + +impl<T> SerializeAs<T> for JsonString +where + T: Serialize, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + crate::json::nested::serialize(source, serializer) + } +} + +impl<'de, T> DeserializeAs<'de, T> for JsonString +where + T: DeserializeOwned, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + crate::json::nested::deserialize(deserializer) + } +} diff --git a/third_party/rust/serde_with/src/lib.rs b/third_party/rust/serde_with/src/lib.rs new file mode 100644 index 0000000000..6285a6f695 --- /dev/null +++ b/third_party/rust/serde_with/src/lib.rs @@ -0,0 +1,2034 @@ +#![warn( + clippy::semicolon_if_nothing_returned, + missing_copy_implementations, + // missing_crate_level_docs, not available in MSRV + missing_debug_implementations, + missing_docs, + rust_2018_idioms, + trivial_casts, + trivial_numeric_casts, + unused_extern_crates, + unused_import_braces, + unused_qualifications, + variant_size_differences +)] +#![doc(test(attr(forbid(unsafe_code))))] +#![doc(test(attr(deny( + missing_copy_implementations, + missing_debug_implementations, + trivial_casts, + trivial_numeric_casts, + unused_extern_crates, + unused_import_braces, + unused_qualifications, +))))] +#![doc(test(attr(warn(rust_2018_idioms))))] +// Not needed for 2018 edition and conflicts with `rust_2018_idioms` +#![doc(test(no_crate_inject))] +#![doc(html_root_url = "https://docs.rs/serde_with/1.14.0")] +#![cfg_attr(docsrs, feature(doc_cfg))] +#![allow( + // clippy is broken and shows wrong warnings + // clippy on stable does not know yet about the lint name + unknown_lints, + // https://github.com/rust-lang/rust-clippy/issues/8560 + clippy::only_used_in_recursion, + // https://github.com/rust-lang/rust-clippy/issues/8867 + clippy::derive_partial_eq_without_eq, +)] +#![no_std] + +//! [](https://crates.io/crates/serde_with/) +//! [](https://github.com/jonasbb/serde_with) +//! [](https://codecov.io/gh/jonasbb/serde_with) +//! [](https://bestpractices.coreinfrastructure.org/projects/4322) +//! [](https://mybinder.org/v2/gist/jonasbb/18b9aece4c17f617b1c2b3946d29eeb0/HEAD?filepath=serde-with-demo.ipynb) +//! +//! --- +//! +//! This crate provides custom de/serialization helpers to use in combination with [serde's with-annotation][with-annotation] and with the improved [`serde_as`][as-annotation]-annotation. +//! Some common use cases are: +//! +//! * De/Serializing a type using the `Display` and `FromStr` traits, e.g., for `u8`, `url::Url`, or `mime::Mime`. +//! Check [`DisplayFromStr`][] or [`serde_with::rust::display_fromstr`][display_fromstr] for details. +//! * Support for arrays larger than 32 elements or using const generics. +//! With `serde_as` large arrays are supported, even if they are nested in other types. +//! `[bool; 64]`, `Option<[u8; M]>`, and `Box<[[u8; 64]; N]>` are all supported, as [this examples shows](#large-and-const-generic-arrays). +//! * Skip serializing all empty `Option` types with [`#[skip_serializing_none]`][skip_serializing_none]. +//! * Apply a prefix to each field name of a struct, without changing the de/serialize implementations of the struct using [`with_prefix!`][]. +//! * Deserialize a comma separated list like `#hash,#tags,#are,#great` into a `Vec<String>`. +//! Check the documentation for [`serde_with::rust::StringWithSeparator::<CommaSeparator>`][StringWithSeparator]. +//! +//! ## Getting Help +//! +//! **Check out the [user guide][user guide] to find out more tips and tricks about this crate.** +//! +//! For further help using this crate you can [open a new discussion](https://github.com/jonasbb/serde_with/discussions/new) or ask on [users.rust-lang.org](https://users.rust-lang.org/). +//! For bugs, please open a [new issue](https://github.com/jonasbb/serde_with/issues/new) on GitHub. +//! +//! # Use `serde_with` in your Project +//! +//! Add this to your `Cargo.toml`: +//! +//! ```toml +//! [dependencies.serde_with] +//! version = "1.14.0" +//! features = [ "..." ] +//! ``` +//! +//! The crate contains different features for integration with other common crates. +//! Check the [feature flags][] section for information about all available features. +//! +//! # Examples +//! +//! Annotate your struct or enum to enable the custom de/serializer. +//! The `#[serde_as]` attribute must be place *before* the `#[derive]`. +//! +//! ## `DisplayFromStr` +//! +//! ```rust +//! # #[cfg(feature = "macros")] +//! # use serde::{Deserialize, Serialize}; +//! # #[cfg(feature = "macros")] +//! # use serde_with::{serde_as, DisplayFromStr}; +//! # #[cfg(feature = "macros")] +//! #[serde_as] +//! # #[derive(Debug, Eq, PartialEq)] +//! #[derive(Deserialize, Serialize)] +//! struct Foo { +//! // Serialize with Display, deserialize with FromStr +//! #[serde_as(as = "DisplayFromStr")] +//! bar: u8, +//! } +//! +//! # #[cfg(all(feature = "macros", feature = "json"))] { +//! // This will serialize +//! # let foo = +//! Foo {bar: 12} +//! # ; +//! +//! // into this JSON +//! # let json = r#" +//! {"bar": "12"} +//! # "#; +//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap()); +//! # assert_eq!(foo, serde_json::from_str(&json).unwrap()); +//! # } +//! ``` +//! +//! ## Large and const-generic arrays +//! +//! serde does not support arrays with more than 32 elements or using const-generics. +//! The `serde_as` attribute allows circumventing this restriction, even for nested types and nested arrays. +//! +//! ```rust +//! # #[cfg(FALSE)] { +//! # #[cfg(feature = "macros")] +//! # use serde::{Deserialize, Serialize}; +//! # #[cfg(feature = "macros")] +//! # use serde_with::serde_as; +//! # #[cfg(feature = "macros")] +//! #[serde_as] +//! # #[derive(Debug, Eq, PartialEq)] +//! #[derive(Deserialize, Serialize)] +//! struct Arrays<const N: usize, const M: usize> { +//! #[serde_as(as = "[_; N]")] +//! constgeneric: [bool; N], +//! +//! #[serde_as(as = "Box<[[_; 64]; N]>")] +//! nested: Box<[[u8; 64]; N]>, +//! +//! #[serde_as(as = "Option<[_; M]>")] +//! optional: Option<[u8; M]>, +//! } +//! +//! # #[cfg(all(feature = "macros", feature = "json"))] { +//! // This allows us to serialize a struct like this +//! let arrays: Arrays<100, 128> = Arrays { +//! constgeneric: [true; 100], +//! nested: Box::new([[111; 64]; 100]), +//! optional: Some([222; 128]) +//! }; +//! assert!(serde_json::to_string(&arrays).is_ok()); +//! # } +//! # } +//! ``` +//! +//! ## `skip_serializing_none` +//! +//! This situation often occurs with JSON, but other formats also support optional fields. +//! If many fields are optional, putting the annotations on the structs can become tedious. +//! The `#[skip_serializing_none]` attribute must be place *before* the `#[derive]`. +//! +//! ```rust +//! # #[cfg(feature = "macros")] +//! # use serde::{Deserialize, Serialize}; +//! # #[cfg(feature = "macros")] +//! # use serde_with::skip_serializing_none; +//! # #[cfg(feature = "macros")] +//! #[skip_serializing_none] +//! # #[derive(Debug, Eq, PartialEq)] +//! #[derive(Deserialize, Serialize)] +//! struct Foo { +//! a: Option<usize>, +//! b: Option<usize>, +//! c: Option<usize>, +//! d: Option<usize>, +//! e: Option<usize>, +//! f: Option<usize>, +//! g: Option<usize>, +//! } +//! +//! # #[cfg(all(feature = "macros", feature = "json"))] { +//! // This will serialize +//! # let foo = +//! Foo {a: None, b: None, c: None, d: Some(4), e: None, f: None, g: Some(7)} +//! # ; +//! +//! // into this JSON +//! # let json = r#" +//! {"d": 4, "g": 7} +//! # "#; +//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap()); +//! # assert_eq!(foo, serde_json::from_str(&json).unwrap()); +//! # } +//! ``` +//! +//! ## Advanced `serde_as` usage +//! +//! This example is mainly supposed to highlight the flexibility of the `serde_as`-annotation compared to [serde's with-annotation][with-annotation]. +//! More details about `serde_as` can be found in the [user guide][]. +//! +//! ```rust +//! # #[cfg(all(feature = "macros", feature = "hex"))] +//! # use { +//! # serde::{Deserialize, Serialize}, +//! # serde_with::{serde_as, DisplayFromStr, DurationSeconds, hex::Hex}, +//! # std::time::Duration, +//! # std::collections::BTreeMap, +//! # }; +//! # #[cfg(all(feature = "macros", feature = "hex"))] +//! #[serde_as] +//! # #[derive(Debug, Eq, PartialEq)] +//! #[derive(Deserialize, Serialize)] +//! struct Foo { +//! // Serialize them into a list of number as seconds +//! #[serde_as(as = "Vec<DurationSeconds>")] +//! durations: Vec<Duration>, +//! // We can treat a Vec like a map with duplicates. +//! // JSON only allows string keys, so convert i32 to strings +//! // The bytes will be hex encoded +//! #[serde_as(as = "BTreeMap<DisplayFromStr, Hex>")] +//! bytes: Vec<(i32, Vec<u8>)>, +//! } +//! +//! # #[cfg(all(feature = "macros", feature = "json", feature = "hex"))] { +//! // This will serialize +//! # let foo = +//! Foo { +//! durations: vec![Duration::new(5, 0), Duration::new(3600, 0), Duration::new(0, 0)], +//! bytes: vec![ +//! (1, vec![0, 1, 2]), +//! (-100, vec![100, 200, 255]), +//! (1, vec![0, 111, 222]), +//! ], +//! } +//! # ; +//! +//! // into this JSON +//! # let json = r#" +//! { +//! "durations": [5, 3600, 0], +//! "bytes": { +//! "1": "000102", +//! "-100": "64c8ff", +//! "1": "006fde" +//! } +//! } +//! # "#; +//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap()); +//! # assert_eq!(foo, serde_json::from_str(&json).unwrap()); +//! # } +//! ``` +//! +//! [`DisplayFromStr`]: https://docs.rs/serde_with/1.14.0/serde_with/struct.DisplayFromStr.html +//! [`with_prefix!`]: https://docs.rs/serde_with/1.14.0/serde_with/macro.with_prefix.html +//! [display_fromstr]: https://docs.rs/serde_with/1.14.0/serde_with/rust/display_fromstr/index.html +//! [feature flags]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html +//! [skip_serializing_none]: https://docs.rs/serde_with/1.14.0/serde_with/attr.skip_serializing_none.html +//! [StringWithSeparator]: https://docs.rs/serde_with/1.14.0/serde_with/rust/struct.StringWithSeparator.html +//! [user guide]: https://docs.rs/serde_with/1.14.0/serde_with/guide/index.html +//! [with-annotation]: https://serde.rs/field-attrs.html#with +//! [as-annotation]: https://docs.rs/serde_with/1.14.0/serde_with/guide/serde_as/index.html + +extern crate alloc; +#[doc(hidden)] +pub extern crate serde; +extern crate std; + +#[cfg(feature = "base64")] +#[cfg_attr(docsrs, doc(cfg(feature = "base64")))] +pub mod base64; +#[cfg(feature = "chrono")] +#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))] +pub mod chrono; +mod content; +pub mod de; +mod duplicate_key_impls; +mod enum_map; +mod flatten_maybe; +pub mod formats; +#[cfg(feature = "hex")] +#[cfg_attr(docsrs, doc(cfg(feature = "hex")))] +pub mod hex; +#[cfg(feature = "json")] +#[cfg_attr(docsrs, doc(cfg(feature = "json")))] +pub mod json; +pub mod rust; +pub mod ser; +mod serde_conv; +#[cfg(feature = "time_0_3")] +#[cfg_attr(docsrs, doc(cfg(feature = "time_0_3")))] +pub mod time_0_3; +mod utils; +#[doc(hidden)] +pub mod with_prefix; + +// Taken from shepmaster/snafu +// Originally licensed as MIT+Apache 2 +// https://github.com/shepmaster/snafu/blob/fd37d79d4531ed1d3eebffad0d658928eb860cfe/src/lib.rs#L121-L165 +#[cfg(feature = "guide")] +#[allow(unused_macro_rules)] +macro_rules! generate_guide { + (pub mod $name:ident; $($rest:tt)*) => { + generate_guide!(@gen ".", pub mod $name { } $($rest)*); + }; + (pub mod $name:ident { $($children:tt)* } $($rest:tt)*) => { + generate_guide!(@gen ".", pub mod $name { $($children)* } $($rest)*); + }; + (@gen $prefix:expr, ) => {}; + (@gen $prefix:expr, pub mod $name:ident; $($rest:tt)*) => { + generate_guide!(@gen $prefix, pub mod $name { } $($rest)*); + }; + (@gen $prefix:expr, @code pub mod $name:ident; $($rest:tt)*) => { + pub mod $name; + generate_guide!(@gen $prefix, $($rest)*); + }; + (@gen $prefix:expr, pub mod $name:ident { $($children:tt)* } $($rest:tt)*) => { + doc_comment::doc_comment! { + include_str!(concat!($prefix, "/", stringify!($name), ".md")), + pub mod $name { + generate_guide!(@gen concat!($prefix, "/", stringify!($name)), $($children)*); + } + } + generate_guide!(@gen $prefix, $($rest)*); + }; +} + +#[cfg(feature = "guide")] +generate_guide! { + pub mod guide { + pub mod feature_flags; + pub mod serde_as; + pub mod serde_as_transformations; + } +} + +#[doc(inline)] +pub use crate::{ + de::DeserializeAs, enum_map::EnumMap, rust::StringWithSeparator, ser::SerializeAs, +}; +use core::marker::PhantomData; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +// Re-Export all proc_macros, as these should be seen as part of the serde_with crate +#[cfg(feature = "macros")] +#[cfg_attr(docsrs, doc(cfg(feature = "macros")))] +#[doc(inline)] +pub use serde_with_macros::*; + +/// Separator for string-based collection de/serialization +pub trait Separator { + /// Return the string delimiting two elements in the string-based collection + fn separator() -> &'static str; +} + +/// Predefined separator using a single space +#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)] +pub struct SpaceSeparator; + +impl Separator for SpaceSeparator { + #[inline] + fn separator() -> &'static str { + " " + } +} + +/// Predefined separator using a single comma +#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)] +pub struct CommaSeparator; + +impl Separator for CommaSeparator { + #[inline] + fn separator() -> &'static str { + "," + } +} + +/// Adapter to convert from `serde_as` to the serde traits. +/// +/// The `As` type adapter allows using types which implement [`DeserializeAs`] or [`SerializeAs`] in place of serde's with-annotation. +/// The with-annotation allows running custom code when de/serializing, however it is quite inflexible. +/// The traits [`DeserializeAs`]/[`SerializeAs`] are more flexible, as they allow composition and nesting of types to create more complex de/serialization behavior. +/// However, they are not directly compatible with serde, as they are not provided by serde. +/// The `As` type adapter makes them compatible, by forwarding the function calls to `serialize`/`deserialize` to the corresponding functions `serialize_as` and `deserialize_as`. +/// +/// It is not required to use this type directly. +/// Instead, it is highly encouraged to use the [`#[serde_as]`][serde_as] attribute since it includes further usability improvements. +/// If the use of the use of the proc-macro is not acceptable, then `As` can be used directly with serde. +/// +/// ```rust +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{As, DisplayFromStr}; +/// # +/// #[derive(Deserialize, Serialize)] +/// # struct S { +/// // Serialize numbers as sequence of strings, using Display and FromStr +/// #[serde(with = "As::<Vec<DisplayFromStr>>")] +/// field: Vec<u8>, +/// # } +/// ``` +/// If the normal `Deserialize`/`Serialize` traits should be used, the placeholder type [`Same`] can be used. +/// It implements [`DeserializeAs`][]/[`SerializeAs`][], when the underlying type implements `Deserialize`/`Serialize`. +/// +/// ```rust +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{As, DisplayFromStr, Same}; +/// # use std::collections::BTreeMap; +/// # +/// #[derive(Deserialize, Serialize)] +/// # struct S { +/// // Serialize map, turn keys into strings but keep type of value +/// #[serde(with = "As::<BTreeMap<DisplayFromStr, Same>>")] +/// field: BTreeMap<u8, i32>, +/// # } +/// ``` +/// +/// [serde_as]: https://docs.rs/serde_with/1.14.0/serde_with/attr.serde_as.html +#[derive(Copy, Clone, Debug, Default)] +pub struct As<T: ?Sized>(PhantomData<T>); + +impl<T: ?Sized> As<T> { + /// Serialize type `T` using [`SerializeAs`][] + /// + /// The function signature is compatible with [serde's with-annotation][with-annotation]. + /// + /// [with-annotation]: https://serde.rs/field-attrs.html#with + pub fn serialize<S, I>(value: &I, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + T: SerializeAs<I>, + I: ?Sized, + { + T::serialize_as(value, serializer) + } + + /// Deserialize type `T` using [`DeserializeAs`][] + /// + /// The function signature is compatible with [serde's with-annotation][with-annotation]. + /// + /// [with-annotation]: https://serde.rs/field-attrs.html#with + pub fn deserialize<'de, D, I>(deserializer: D) -> Result<I, D::Error> + where + T: DeserializeAs<'de, I>, + D: Deserializer<'de>, + { + T::deserialize_as(deserializer) + } +} + +/// Adapter to convert from `serde_as` to the serde traits. +/// +/// This is the counter-type to [`As`][]. +/// It can be used whenever a type implementing [`DeserializeAs`][]/[`SerializeAs`][] is required but the normal `Deserialize`/`Serialize` traits should be used. +/// Check [`As`] for an example. +#[derive(Copy, Clone, Debug, Default)] +pub struct Same; + +/// De/Serialize using [`Display`] and [`FromStr`] implementation +/// +/// This allows deserializing a string as a number. +/// It can be very useful for serialization formats like JSON, which do not support integer +/// numbers and have to resort to strings to represent them. +/// +/// Another use case is types with [`Display`] and [`FromStr`] implementations, but without serde +/// support, which can be found in some crates. +/// +/// If you control the type you want to de/serialize, you can instead use the two derive macros, [`SerializeDisplay`] and [`DeserializeFromStr`]. +/// They properly implement the traits [`Serialize`] and [`Deserialize`] such that user of the type no longer have to use the `serde_as` system. +/// +/// The same functionality is also available as [`serde_with::rust::display_fromstr`][crate::rust::display_fromstr] compatible with serde's with-annotation. +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DisplayFromStr}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "DisplayFromStr")] +/// mime: mime::Mime, +/// #[serde_as(as = "DisplayFromStr")] +/// number: u32, +/// } +/// +/// let v: A = serde_json::from_value(json!({ +/// "mime": "text/plain", +/// "number": "159", +/// })).unwrap(); +/// assert_eq!(mime::TEXT_PLAIN, v.mime); +/// assert_eq!(159, v.number); +/// +/// let x = A { +/// mime: mime::STAR_STAR, +/// number: 777, +/// }; +/// assert_eq!(json!({ "mime": "*/*", "number": "777" }), serde_json::to_value(&x).unwrap()); +/// # } +/// ``` +/// +/// [`Display`]: std::fmt::Display +/// [`FromStr`]: std::str::FromStr +#[derive(Copy, Clone, Debug, Default)] +pub struct DisplayFromStr; + +/// De/Serialize a [`Option<String>`] type while transforming the empty string to [`None`] +/// +/// Convert an [`Option<T>`] from/to string using [`FromStr`] and [`AsRef<str>`] implementations. +/// An empty string is deserialized as [`None`] and a [`None`] vice versa. +/// +/// The same functionality is also available as [`serde_with::rust::string_empty_as_none`][crate::rust::string_empty_as_none] compatible with serde's with-annotation. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, NoneAsEmptyString}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "NoneAsEmptyString")] +/// tags: Option<String>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ "tags": "" })).unwrap(); +/// assert_eq!(None, v.tags); +/// +/// let v: A = serde_json::from_value(json!({ "tags": "Hi" })).unwrap(); +/// assert_eq!(Some("Hi".to_string()), v.tags); +/// +/// let x = A { +/// tags: Some("This is text".to_string()), +/// }; +/// assert_eq!(json!({ "tags": "This is text" }), serde_json::to_value(&x).unwrap()); +/// +/// let x = A { +/// tags: None, +/// }; +/// assert_eq!(json!({ "tags": "" }), serde_json::to_value(&x).unwrap()); +/// # } +/// ``` +/// +/// [`FromStr`]: std::str::FromStr +#[derive(Copy, Clone, Debug, Default)] +pub struct NoneAsEmptyString; + +/// Deserialize value and return [`Default`] on error +/// +/// The main use case is ignoring error while deserializing. +/// Instead of erroring, it simply deserializes the [`Default`] variant of the type. +/// It is not possible to find the error location, i.e., which field had a deserialization error, with this method. +/// During serialization this wrapper does nothing. +/// The serialization behavior of the underlying type is preserved. +/// The type must implement [`Default`] for this conversion to work. +/// +/// The same functionality is also available as [`serde_with::rust::default_on_error`][crate::rust::default_on_error] compatible with serde's with-annotation. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, DefaultOnError}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Debug)] +/// struct A { +/// #[serde_as(deserialize_as = "DefaultOnError")] +/// value: u32, +/// } +/// +/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap(); +/// assert_eq!(123, a.value); +/// +/// // null is of invalid type +/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // String is of invalid type +/// let a: A = serde_json::from_str(r#"{"value": "123"}"#).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // Map is of invalid type +/// let a: A = dbg!(serde_json::from_str(r#"{"value": {}}"#)).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // Missing entries still cause errors +/// assert!(serde_json::from_str::<A>(r#"{ }"#).is_err()); +/// # } +/// ``` +/// +/// Deserializing missing values can be supported by adding the `default` field attribute: +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, DefaultOnError}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct B { +/// #[serde_as(deserialize_as = "DefaultOnError")] +/// #[serde(default)] +/// value: u32, +/// } +/// +/// let b: B = serde_json::from_str(r#"{ }"#).unwrap(); +/// assert_eq!(0, b.value); +/// # } +/// ``` +/// +/// `DefaultOnError` can be combined with other conversion methods. +/// In this example, we deserialize a `Vec`, each element is deserialized from a string. +/// If the string does not parse as a number, then we get the default value of 0. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DefaultOnError, DisplayFromStr}; +/// # +/// #[serde_as] +/// #[derive(Serialize, Deserialize)] +/// struct C { +/// #[serde_as(as = "Vec<DefaultOnError<DisplayFromStr>>")] +/// value: Vec<u32>, +/// }; +/// +/// let c: C = serde_json::from_value(json!({ +/// "value": ["1", "2", "a3", "", {}, "6"] +/// })).unwrap(); +/// assert_eq!(vec![1, 2, 0, 0, 0, 6], c.value); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct DefaultOnError<T = Same>(PhantomData<T>); + +/// Deserialize [`Default`] from `null` values +/// +/// Instead of erroring on `null` values, it simply deserializes the [`Default`] variant of the type. +/// During serialization this wrapper does nothing. +/// The serialization behavior of the underlying type is preserved. +/// The type must implement [`Default`] for this conversion to work. +/// +/// The same functionality is also available as [`serde_with::rust::default_on_null`][crate::rust::default_on_null] compatible with serde's with-annotation. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, DefaultOnNull}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Debug)] +/// struct A { +/// #[serde_as(deserialize_as = "DefaultOnNull")] +/// value: u32, +/// } +/// +/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap(); +/// assert_eq!(123, a.value); +/// +/// // null values are deserialized into the default, here 0 +/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap(); +/// assert_eq!(0, a.value); +/// # } +/// ``` +/// +/// `DefaultOnNull` can be combined with other conversion methods. +/// In this example, we deserialize a `Vec`, each element is deserialized from a string. +/// If we encounter null, then we get the default value of 0. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DefaultOnNull, DisplayFromStr}; +/// # +/// #[serde_as] +/// #[derive(Serialize, Deserialize)] +/// struct C { +/// #[serde_as(as = "Vec<DefaultOnNull<DisplayFromStr>>")] +/// value: Vec<u32>, +/// }; +/// +/// let c: C = serde_json::from_value(json!({ +/// "value": ["1", "2", null, null, "5"] +/// })).unwrap(); +/// assert_eq!(vec![1, 2, 0, 0, 5], c.value); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct DefaultOnNull<T = Same>(PhantomData<T>); + +/// Deserialize from bytes or string +/// +/// Any Rust [`String`] can be converted into bytes, i.e., `Vec<u8>`. +/// Accepting both as formats while deserializing can be helpful while interacting with language +/// which have a looser definition of string than Rust. +/// +/// # Example +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, BytesOrString}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "BytesOrString")] +/// bytes_or_string: Vec<u8>, +/// } +/// +/// // Here we deserialize from a byte array ... +/// let j = json!({ +/// "bytes_or_string": [ +/// 0, +/// 1, +/// 2, +/// 3 +/// ] +/// }); +/// +/// let a: A = serde_json::from_value(j.clone()).unwrap(); +/// assert_eq!(vec![0, 1, 2, 3], a.bytes_or_string); +/// +/// // and serialization works too. +/// assert_eq!(j, serde_json::to_value(&a).unwrap()); +/// +/// // But we also support deserializing from a String +/// let j = json!({ +/// "bytes_or_string": "✨Works!" +/// }); +/// +/// let a: A = serde_json::from_value(j).unwrap(); +/// assert_eq!("✨Works!".as_bytes(), &*a.bytes_or_string); +/// # } +/// ``` +/// [`String`]: std::string::String +#[derive(Copy, Clone, Debug, Default)] +pub struct BytesOrString; + +/// De/Serialize Durations as number of seconds. +/// +/// De/serialize durations as number of seconds with subsecond precision. +/// Subsecond precision is *only* supported for [`DurationSecondsWithFrac`], but not for [`DurationSeconds`]. +/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier. +/// +/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`]. +/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `u64` deserialization from a `f64` will error. +/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct duration and allows deserialization from any type. +/// For example, deserializing `DurationSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number. +/// +/// This type also supports [`chrono::Duration`] with the `chrono`-[feature flag]. +/// This type also supports [`time::Duration`][::time_0_3::Duration] with the `time_0_3`-[feature flag]. +/// +/// | Duration Type | Converter | Available `FORMAT`s | +/// | --------------------- | ------------------------- | ---------------------- | +/// | `std::time::Duration` | `DurationSeconds` | `u64`, `f64`, `String` | +/// | `std::time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` | +/// | `chrono::Duration` | `DurationSeconds` | `i64`, `f64`, `String` | +/// | `chrono::Duration` | `DurationSecondsWithFrac` | `f64`, `String` | +/// | `time::Duration` | `DurationSeconds` | `i64`, `f64`, `String` | +/// | `time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` | +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DurationSeconds}; +/// use std::time::Duration; +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Durations { +/// #[serde_as(as = "DurationSeconds<u64>")] +/// d_u64: Duration, +/// #[serde_as(as = "DurationSeconds<f64>")] +/// d_f64: Duration, +/// #[serde_as(as = "DurationSeconds<String>")] +/// d_string: Duration, +/// }; +/// +/// // Serialization +/// // See how the values get rounded, since subsecond precision is not allowed. +/// +/// let d = Durations { +/// d_u64: Duration::new(12345, 0), // Create from seconds and nanoseconds +/// d_f64: Duration::new(12345, 500_000_000), +/// d_string: Duration::new(12345, 999_999_999), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "d_u64": 12345, +/// "d_f64": 12346.0, +/// "d_string": "12346", +/// }); +/// assert_eq!(expected, serde_json::to_value(&d).unwrap()); +/// +/// // Deserialization works too +/// // Subsecond precision in numbers will be rounded away +/// +/// let json = json!({ +/// "d_u64": 12345, +/// "d_f64": 12345.5, +/// "d_string": "12346", +/// }); +/// let expected = Durations { +/// d_u64: Duration::new(12345, 0), // Create from seconds and nanoseconds +/// d_f64: Duration::new(12346, 0), +/// d_string: Duration::new(12346, 0), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`chrono::Duration`] is also supported when using the `chrono` feature. +/// It is a signed duration, thus can be de/serialized as an `i64` instead of a `u64`. +/// +/// ```rust +/// # #[cfg(all(feature = "macros", feature = "chrono"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DurationSeconds}; +/// # use chrono_crate::Duration; +/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate +/// use chrono::Duration; +/// # */ +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Durations { +/// #[serde_as(as = "DurationSeconds<i64>")] +/// d_i64: Duration, +/// #[serde_as(as = "DurationSeconds<f64>")] +/// d_f64: Duration, +/// #[serde_as(as = "DurationSeconds<String>")] +/// d_string: Duration, +/// }; +/// +/// // Serialization +/// // See how the values get rounded, since subsecond precision is not allowed. +/// +/// let d = Durations { +/// d_i64: Duration::seconds(-12345), +/// d_f64: Duration::seconds(-12345) + Duration::milliseconds(500), +/// d_string: Duration::seconds(12345) + Duration::nanoseconds(999_999_999), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "d_i64": -12345, +/// "d_f64": -12345.0, +/// "d_string": "12346", +/// }); +/// assert_eq!(expected, serde_json::to_value(&d).unwrap()); +/// +/// // Deserialization works too +/// // Subsecond precision in numbers will be rounded away +/// +/// let json = json!({ +/// "d_i64": -12345, +/// "d_f64": -12345.5, +/// "d_string": "12346", +/// }); +/// let expected = Durations { +/// d_i64: Duration::seconds(-12345), +/// d_f64: Duration::seconds(-12346), +/// d_string: Duration::seconds(12346), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`chrono::Duration`]: chrono_crate::Duration +/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationSeconds< + FORMAT: formats::Format = u64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// De/Serialize Durations as number of seconds. +/// +/// De/serialize durations as number of seconds with subsecond precision. +/// Subsecond precision is *only* supported for [`DurationSecondsWithFrac`], but not for [`DurationSeconds`]. +/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier. +/// +/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`]. +/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `u64` deserialization from a `f64` will error. +/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct duration and allows deserialization from any type. +/// For example, deserializing `DurationSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number. +/// +/// This type also supports [`chrono::Duration`] with the `chrono`-[feature flag]. +/// This type also supports [`time::Duration`][::time_0_3::Duration] with the `time_0_3`-[feature flag]. +/// +/// | Duration Type | Converter | Available `FORMAT`s | +/// | --------------------- | ------------------------- | ---------------------- | +/// | `std::time::Duration` | `DurationSeconds` | `u64`, `f64`, `String` | +/// | `std::time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` | +/// | `chrono::Duration` | `DurationSeconds` | `i64`, `f64`, `String` | +/// | `chrono::Duration` | `DurationSecondsWithFrac` | `f64`, `String` | +/// | `time::Duration` | `DurationSeconds` | `i64`, `f64`, `String` | +/// | `time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` | +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DurationSecondsWithFrac}; +/// use std::time::Duration; +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Durations { +/// #[serde_as(as = "DurationSecondsWithFrac<f64>")] +/// d_f64: Duration, +/// #[serde_as(as = "DurationSecondsWithFrac<String>")] +/// d_string: Duration, +/// }; +/// +/// // Serialization +/// // See how the values get rounded, since subsecond precision is not allowed. +/// +/// let d = Durations { +/// d_f64: Duration::new(12345, 500_000_000), // Create from seconds and nanoseconds +/// d_string: Duration::new(12345, 999_999_000), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "d_f64": 12345.5, +/// "d_string": "12345.999999", +/// }); +/// assert_eq!(expected, serde_json::to_value(&d).unwrap()); +/// +/// // Deserialization works too +/// // Subsecond precision in numbers will be rounded away +/// +/// let json = json!({ +/// "d_f64": 12345.5, +/// "d_string": "12345.987654", +/// }); +/// let expected = Durations { +/// d_f64: Duration::new(12345, 500_000_000), // Create from seconds and nanoseconds +/// d_string: Duration::new(12345, 987_654_000), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`chrono::Duration`] is also supported when using the `chrono` feature. +/// It is a signed duration, thus can be de/serialized as an `i64` instead of a `u64`. +/// +/// ```rust +/// # #[cfg(all(feature = "macros", feature = "chrono"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DurationSecondsWithFrac}; +/// # use chrono_crate::Duration; +/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate +/// use chrono::Duration; +/// # */ +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Durations { +/// #[serde_as(as = "DurationSecondsWithFrac<f64>")] +/// d_f64: Duration, +/// #[serde_as(as = "DurationSecondsWithFrac<String>")] +/// d_string: Duration, +/// }; +/// +/// // Serialization +/// +/// let d = Durations { +/// d_f64: Duration::seconds(-12345) + Duration::milliseconds(500), +/// d_string: Duration::seconds(12345) + Duration::nanoseconds(999_999_000), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "d_f64": -12344.5, +/// "d_string": "12345.999999", +/// }); +/// assert_eq!(expected, serde_json::to_value(&d).unwrap()); +/// +/// // Deserialization works too +/// +/// let json = json!({ +/// "d_f64": -12344.5, +/// "d_string": "12345.987", +/// }); +/// let expected = Durations { +/// d_f64: Duration::seconds(-12345) + Duration::milliseconds(500), +/// d_string: Duration::seconds(12345) + Duration::milliseconds(987), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`chrono::Duration`]: chrono_crate::Duration +/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`DurationSeconds`] with milli-seconds as base unit. +/// +/// This type is equivalent to [`DurationSeconds`] except that each unit represents 1 milli-second instead of 1 second for [`DurationSeconds`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationMilliSeconds< + FORMAT: formats::Format = u64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`DurationSecondsWithFrac`] with milli-seconds as base unit. +/// +/// This type is equivalent to [`DurationSecondsWithFrac`] except that each unit represents 1 milli-second instead of 1 second for [`DurationSecondsWithFrac`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationMilliSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`DurationSeconds`] with micro-seconds as base unit. +/// +/// This type is equivalent to [`DurationSeconds`] except that each unit represents 1 micro-second instead of 1 second for [`DurationSeconds`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationMicroSeconds< + FORMAT: formats::Format = u64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`DurationSecondsWithFrac`] with micro-seconds as base unit. +/// +/// This type is equivalent to [`DurationSecondsWithFrac`] except that each unit represents 1 micro-second instead of 1 second for [`DurationSecondsWithFrac`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationMicroSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`DurationSeconds`] with nano-seconds as base unit. +/// +/// This type is equivalent to [`DurationSeconds`] except that each unit represents 1 nano-second instead of 1 second for [`DurationSeconds`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationNanoSeconds< + FORMAT: formats::Format = u64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`DurationSecondsWithFrac`] with nano-seconds as base unit. +/// +/// This type is equivalent to [`DurationSecondsWithFrac`] except that each unit represents 1 nano-second instead of 1 second for [`DurationSecondsWithFrac`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct DurationNanoSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// De/Serialize timestamps as seconds since the UNIX epoch +/// +/// De/serialize timestamps as seconds since the UNIX epoch. +/// Subsecond precision is *only* supported for [`TimestampSecondsWithFrac`], but not for [`TimestampSeconds`]. +/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier. +/// +/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`]. +/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `i64` deserialization from a `f64` will error. +/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct timestamp and allows deserialization from any type. +/// For example, deserializing `TimestampSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number. +/// +/// This type also supports [`chrono::DateTime`][DateTime] with the `chrono`-[feature flag]. +/// This type also supports [`time::OffsetDateTime`][::time_0_3::OffsetDateTime] and [`time::PrimitiveDateTime`][::time_0_3::PrimitiveDateTime] with the `time_0_3`-[feature flag]. +/// +/// | Timestamp Type | Converter | Available `FORMAT`s | +/// | ------------------------- | -------------------------- | ---------------------- | +/// | `std::time::SystemTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `std::time::SystemTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `chrono::DateTime<Utc>` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `chrono::DateTime<Utc>` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `chrono::DateTime<Local>` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `chrono::DateTime<Local>` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `time::OffsetDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `time::OffsetDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `time::PrimitiveDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `time::PrimitiveDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TimestampSeconds}; +/// use std::time::{Duration, SystemTime}; +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Timestamps { +/// #[serde_as(as = "TimestampSeconds<i64>")] +/// st_i64: SystemTime, +/// #[serde_as(as = "TimestampSeconds<f64>")] +/// st_f64: SystemTime, +/// #[serde_as(as = "TimestampSeconds<String>")] +/// st_string: SystemTime, +/// }; +/// +/// // Serialization +/// // See how the values get rounded, since subsecond precision is not allowed. +/// +/// let ts = Timestamps { +/// st_i64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 0)).unwrap(), +/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(), +/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 999_999_999)).unwrap(), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "st_i64": 12345, +/// "st_f64": 12346.0, +/// "st_string": "12346", +/// }); +/// assert_eq!(expected, serde_json::to_value(&ts).unwrap()); +/// +/// // Deserialization works too +/// // Subsecond precision in numbers will be rounded away +/// +/// let json = json!({ +/// "st_i64": 12345, +/// "st_f64": 12345.5, +/// "st_string": "12346", +/// }); +/// let expected = Timestamps { +/// st_i64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 0)).unwrap(), +/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12346, 0)).unwrap(), +/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12346, 0)).unwrap(), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`chrono::DateTime<Utc>`][DateTime] and [`chrono::DateTime<Local>`][DateTime] are also supported when using the `chrono` feature. +/// Like [`SystemTime`], it is a signed timestamp, thus can be de/serialized as an `i64`. +/// +/// ```rust +/// # #[cfg(all(feature = "macros", feature = "chrono"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TimestampSeconds}; +/// # use chrono_crate::{DateTime, Local, TimeZone, Utc}; +/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate +/// use chrono::{DateTime, Local, TimeZone, Utc}; +/// # */ +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Timestamps { +/// #[serde_as(as = "TimestampSeconds<i64>")] +/// dt_i64: DateTime<Utc>, +/// #[serde_as(as = "TimestampSeconds<f64>")] +/// dt_f64: DateTime<Local>, +/// #[serde_as(as = "TimestampSeconds<String>")] +/// dt_string: DateTime<Utc>, +/// }; +/// +/// // Serialization +/// // See how the values get rounded, since subsecond precision is not allowed. +/// +/// let ts = Timestamps { +/// dt_i64: Utc.timestamp(-12345, 0), +/// dt_f64: Local.timestamp(-12345, 500_000_000), +/// dt_string: Utc.timestamp(12345, 999_999_999), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "dt_i64": -12345, +/// "dt_f64": -12345.0, +/// "dt_string": "12346", +/// }); +/// assert_eq!(expected, serde_json::to_value(&ts).unwrap()); +/// +/// // Deserialization works too +/// // Subsecond precision in numbers will be rounded away +/// +/// let json = json!({ +/// "dt_i64": -12345, +/// "dt_f64": -12345.5, +/// "dt_string": "12346", +/// }); +/// let expected = Timestamps { +/// dt_i64: Utc.timestamp(-12345, 0), +/// dt_f64: Local.timestamp(-12346, 0), +/// dt_string: Utc.timestamp(12346, 0), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`SystemTime`]: std::time::SystemTime +/// [DateTime]: chrono_crate::DateTime +/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampSeconds< + FORMAT: formats::Format = i64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// De/Serialize timestamps as seconds since the UNIX epoch +/// +/// De/serialize timestamps as seconds since the UNIX epoch. +/// Subsecond precision is *only* supported for [`TimestampSecondsWithFrac`], but not for [`TimestampSeconds`]. +/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier. +/// +/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`]. +/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `i64` deserialization from a `f64` will error. +/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct timestamp and allows deserialization from any type. +/// For example, deserializing `TimestampSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number. +/// +/// This type also supports [`chrono::DateTime`][DateTime] and [`chrono::NaiveDateTime`][NaiveDateTime] with the `chrono`-[feature flag]. +/// This type also supports [`time::OffsetDateTime`][::time_0_3::OffsetDateTime] and [`time::PrimitiveDateTime`][::time_0_3::PrimitiveDateTime] with the `time_0_3`-[feature flag]. +/// +/// | Timestamp Type | Converter | Available `FORMAT`s | +/// | ------------------------- | -------------------------- | ---------------------- | +/// | `std::time::SystemTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `std::time::SystemTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `chrono::DateTime<Utc>` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `chrono::DateTime<Utc>` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `chrono::DateTime<Local>` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `chrono::DateTime<Local>` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `chrono::NaiveDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `chrono::NaiveDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `time::OffsetDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `time::OffsetDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// | `time::PrimitiveDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` | +/// | `time::PrimitiveDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` | +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TimestampSecondsWithFrac}; +/// use std::time::{Duration, SystemTime}; +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Timestamps { +/// #[serde_as(as = "TimestampSecondsWithFrac<f64>")] +/// st_f64: SystemTime, +/// #[serde_as(as = "TimestampSecondsWithFrac<String>")] +/// st_string: SystemTime, +/// }; +/// +/// // Serialization +/// // See how the values get rounded, since subsecond precision is not allowed. +/// +/// let ts = Timestamps { +/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(), +/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 999_999_000)).unwrap(), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "st_f64": 12345.5, +/// "st_string": "12345.999999", +/// }); +/// assert_eq!(expected, serde_json::to_value(&ts).unwrap()); +/// +/// // Deserialization works too +/// // Subsecond precision in numbers will be rounded away +/// +/// let json = json!({ +/// "st_f64": 12345.5, +/// "st_string": "12345.987654", +/// }); +/// let expected = Timestamps { +/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(), +/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 987_654_000)).unwrap(), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`chrono::DateTime<Utc>`][DateTime] and [`chrono::DateTime<Local>`][DateTime] are also supported when using the `chrono` feature. +/// Like [`SystemTime`], it is a signed timestamp, thus can be de/serialized as an `i64`. +/// +/// ```rust +/// # #[cfg(all(feature = "macros", feature = "chrono"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TimestampSecondsWithFrac}; +/// # use chrono_crate::{DateTime, Local, TimeZone, Utc}; +/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate +/// use chrono::{DateTime, Local, TimeZone, Utc}; +/// # */ +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Timestamps { +/// #[serde_as(as = "TimestampSecondsWithFrac<f64>")] +/// dt_f64: DateTime<Utc>, +/// #[serde_as(as = "TimestampSecondsWithFrac<String>")] +/// dt_string: DateTime<Local>, +/// }; +/// +/// // Serialization +/// +/// let ts = Timestamps { +/// dt_f64: Utc.timestamp(-12345, 500_000_000), +/// dt_string: Local.timestamp(12345, 999_999_000), +/// }; +/// // Observe the different data types +/// let expected = json!({ +/// "dt_f64": -12344.5, +/// "dt_string": "12345.999999", +/// }); +/// assert_eq!(expected, serde_json::to_value(&ts).unwrap()); +/// +/// // Deserialization works too +/// +/// let json = json!({ +/// "dt_f64": -12344.5, +/// "dt_string": "12345.987", +/// }); +/// let expected = Timestamps { +/// dt_f64: Utc.timestamp(-12345, 500_000_000), +/// dt_string: Local.timestamp(12345, 987_000_000), +/// }; +/// assert_eq!(expected, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +/// +/// [`SystemTime`]: std::time::SystemTime +/// [DateTime]: chrono_crate::DateTime +/// [NaiveDateTime]: chrono_crate::NaiveDateTime +/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`TimestampSeconds`] with milli-seconds as base unit. +/// +/// This type is equivalent to [`TimestampSeconds`] except that each unit represents 1 milli-second instead of 1 second for [`TimestampSeconds`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampMilliSeconds< + FORMAT: formats::Format = i64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`TimestampSecondsWithFrac`] with milli-seconds as base unit. +/// +/// This type is equivalent to [`TimestampSecondsWithFrac`] except that each unit represents 1 milli-second instead of 1 second for [`TimestampSecondsWithFrac`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampMilliSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`TimestampSeconds`] with micro-seconds as base unit. +/// +/// This type is equivalent to [`TimestampSeconds`] except that each unit represents 1 micro-second instead of 1 second for [`TimestampSeconds`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampMicroSeconds< + FORMAT: formats::Format = i64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`TimestampSecondsWithFrac`] with micro-seconds as base unit. +/// +/// This type is equivalent to [`TimestampSecondsWithFrac`] except that each unit represents 1 micro-second instead of 1 second for [`TimestampSecondsWithFrac`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampMicroSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`TimestampSeconds`] with nano-seconds as base unit. +/// +/// This type is equivalent to [`TimestampSeconds`] except that each unit represents 1 nano-second instead of 1 second for [`TimestampSeconds`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampNanoSeconds< + FORMAT: formats::Format = i64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Equivalent to [`TimestampSecondsWithFrac`] with nano-seconds as base unit. +/// +/// This type is equivalent to [`TimestampSecondsWithFrac`] except that each unit represents 1 nano-second instead of 1 second for [`TimestampSecondsWithFrac`]. +#[derive(Copy, Clone, Debug, Default)] +pub struct TimestampNanoSecondsWithFrac< + FORMAT: formats::Format = f64, + STRICTNESS: formats::Strictness = formats::Strict, +>(PhantomData<(FORMAT, STRICTNESS)>); + +/// Optimized handling of owned and borrowed byte representations. +/// +/// Serialization of byte sequences like `&[u8]` or `Vec<u8>` is quite inefficient since each value will be serialized individually. +/// This converter type optimizes the serialization and deserialization. +/// +/// This is a port of the [`serde_bytes`] crate making it compatible with the `serde_as`-annotation, which allows it to be used in more cases than provided by [`serde_bytes`]. +/// +/// The type provides de/serialization for these types: +/// +/// * `[u8; N]`, not possible using `serde_bytes` +/// * `&[u8; N]`, not possible using `serde_bytes` +/// * `&[u8]` +/// * `Box<[u8; N]>`, not possible using `serde_bytes` +/// * `Box<[u8]>` +/// * `Vec<u8>` +/// * `Cow<'_, [u8]>` +/// * `Cow<'_, [u8; N]>`, not possible using `serde_bytes` +/// +/// [`serde_bytes`]: https://crates.io/crates/serde_bytes +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{serde_as, Bytes}; +/// # use std::borrow::Cow; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Test<'a> { +/// # #[cfg(FALSE)] +/// #[serde_as(as = "Bytes")] +/// array: [u8; 15], +/// #[serde_as(as = "Bytes")] +/// boxed: Box<[u8]>, +/// #[serde_as(as = "Bytes")] +/// #[serde(borrow)] +/// cow: Cow<'a, [u8]>, +/// # #[cfg(FALSE)] +/// #[serde_as(as = "Bytes")] +/// #[serde(borrow)] +/// cow_array: Cow<'a, [u8; 15]>, +/// #[serde_as(as = "Bytes")] +/// vec: Vec<u8>, +/// } +/// +/// let value = Test { +/// # #[cfg(FALSE)] +/// array: b"0123456789ABCDE".clone(), +/// boxed: b"...".to_vec().into_boxed_slice(), +/// cow: Cow::Borrowed(b"FooBar"), +/// # #[cfg(FALSE)] +/// cow_array: Cow::Borrowed(&[42u8; 15]), +/// vec: vec![0x41, 0x61, 0x21], +/// }; +/// let expected = r#"( +/// array: "MDEyMzQ1Njc4OUFCQ0RF", +/// boxed: "Li4u", +/// cow: "Rm9vQmFy", +/// cow_array: "KioqKioqKioqKioqKioq", +/// vec: "QWEh", +/// )"#; +/// # drop(expected); +/// # // Create a fake expected value that doesn't use const generics +/// # let expected = r#"( +/// # boxed: "Li4u", +/// # cow: "Rm9vQmFy", +/// # vec: "QWEh", +/// # )"#; +/// +/// # let pretty_config = ron::ser::PrettyConfig::new() +/// # .new_line("\n".into()); +/// assert_eq!(expected, ron::ser::to_string_pretty(&value, pretty_config).unwrap()); +/// assert_eq!(value, ron::from_str(&expected).unwrap()); +/// # } +/// ``` +/// +/// Fully borrowed types can also be used but you'll need a Deserializer that +/// supports Serde's 0-copy deserialization: +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{serde_as, Bytes}; +/// # use std::borrow::Cow; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct TestBorrows<'a> { +/// # #[cfg(FALSE)] +/// #[serde_as(as = "Bytes")] +/// #[serde(borrow)] +/// array_buf: &'a [u8; 15], +/// #[serde_as(as = "Bytes")] +/// #[serde(borrow)] +/// buf: &'a [u8], +/// } +/// +/// let value = TestBorrows { +/// # #[cfg(FALSE)] +/// array_buf: &[10u8; 15], +/// buf: &[20u8, 21u8, 22u8], +/// }; +/// let expected = r#"( +/// array_buf: "CgoKCgoKCgoKCgoKCgoK", +/// buf: "FBUW", +/// )"#; +/// # drop(expected); +/// # // Create a fake expected value that doesn't use const generics +/// # let expected = r#"( +/// # buf: "FBUW", +/// # )"#; +/// +/// # let pretty_config = ron::ser::PrettyConfig::new() +/// # .new_line("\n".into()); +/// assert_eq!(expected, ron::ser::to_string_pretty(&value, pretty_config).unwrap()); +/// // RON doesn't support borrowed deserialization of byte arrays +/// # } +/// ``` +/// +/// ## Alternative to [`BytesOrString`] +/// +/// The [`Bytes`] can replace [`BytesOrString`]. +/// [`Bytes`] is implemented for more types, which makes it better. +/// The serialization behavior of [`Bytes`] differs from [`BytesOrString`], therefore only `deserialize_as` should be used. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_json::json; +/// # use serde_with::{serde_as, Bytes}; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, serde::Serialize)] +/// struct Test { +/// #[serde_as(deserialize_as = "Bytes")] +/// from_bytes: Vec<u8>, +/// #[serde_as(deserialize_as = "Bytes")] +/// from_str: Vec<u8>, +/// } +/// +/// // Different serialized values ... +/// let j = json!({ +/// "from_bytes": [70,111,111,45,66,97,114], +/// "from_str": "Foo-Bar", +/// }); +/// +/// // can be deserialized ... +/// let test = Test { +/// from_bytes: b"Foo-Bar".to_vec(), +/// from_str: b"Foo-Bar".to_vec(), +/// }; +/// assert_eq!(test, serde_json::from_value(j).unwrap()); +/// +/// // and serialization will always be a byte sequence +/// # assert_eq!(json!( +/// { +/// "from_bytes": [70,111,111,45,66,97,114], +/// "from_str": [70,111,111,45,66,97,114], +/// } +/// # ), serde_json::to_value(&test).unwrap()); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct Bytes; + +/// Deserialize one or many elements +/// +/// Sometimes it is desirable to have a shortcut in writing 1-element lists in a config file. +/// Usually, this is done by either writing a list or the list element itself. +/// This distinction is not semantically important on the Rust side, thus both forms should deserialize into the same `Vec`. +/// +/// The `OneOrMany` adapter achieves exactly this use case. +/// The serialization behavior can be tweaked to either always serialize as a list using `PreferMany` or to serialize as the inner element if possible using `PreferOne`. +/// By default, `PreferOne` is assumed, which can also be omitted like `OneOrMany<_>`. +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_json::json; +/// # use serde_with::{serde_as, OneOrMany}; +/// # use serde_with::formats::{PreferOne, PreferMany}; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, serde::Serialize)] +/// struct Data { +/// #[serde_as(deserialize_as = "OneOrMany<_, PreferOne>")] +/// countries: Vec<String>, +/// #[serde_as(deserialize_as = "OneOrMany<_, PreferMany>")] +/// cities: Vec<String>, +/// } +/// +/// // The adapter allows deserializing a `Vec` from either +/// // a single element +/// let j = json!({ +/// "countries": "Spain", +/// "cities": "Berlin", +/// }); +/// assert!(serde_json::from_value::<Data>(j).is_ok()); +/// +/// // or from a list. +/// let j = json!({ +/// "countries": ["Germany", "France"], +/// "cities": ["Amsterdam"], +/// }); +/// assert!(serde_json::from_value::<Data>(j).is_ok()); +/// +/// // For serialization you can choose how a single element should be encoded. +/// // Either directly, with `PreferOne` (default), or as a list with `PreferMany`. +/// let data = Data { +/// countries: vec!["Spain".to_string()], +/// cities: vec!["Berlin".to_string()], +/// }; +/// let j = json!({ +/// "countries": "Spain", +/// "cities": ["Berlin"], +/// }); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct OneOrMany<T, FORMAT: formats::Format = formats::PreferOne>(PhantomData<(T, FORMAT)>); + +/// Try multiple deserialization options until one succeeds. +/// +/// This adapter allows you to specify a list of deserialization options. +/// They are tried in order and the first one working is applied. +/// Serialization always picks the first option. +/// +/// `PickFirst` has one type parameter which must be instantiated with a tuple of two, three, or four elements. +/// For example, `PickFirst<(_, DisplayFromStr)>` on a field of type `u32` allows deserializing from a number or from a string via the `FromStr` trait. +/// The value will be serialized as a number, since that is what the first type `_` indicates. +/// +/// # Examples +/// +/// Deserialize a number from either a number or a string. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DisplayFromStr, PickFirst}; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Data { +/// #[serde_as(as = "PickFirst<(_, DisplayFromStr)>")] +/// as_number: u32, +/// #[serde_as(as = "PickFirst<(DisplayFromStr, _)>")] +/// as_string: u32, +/// } +/// let data = Data { +/// as_number: 123, +/// as_string: 456 +/// }; +/// +/// // Both fields can be deserialized from numbers: +/// let j = json!({ +/// "as_number": 123, +/// "as_string": 456, +/// }); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +/// +/// // or from a string: +/// let j = json!({ +/// "as_number": "123", +/// "as_string": "456", +/// }); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +/// +/// // For serialization the first type in the tuple determines the behavior. +/// // The `as_number` field will use the normal `Serialize` behavior and produce a number, +/// // while `as_string` used `Display` to produce a string. +/// let expected = json!({ +/// "as_number": 123, +/// "as_string": "456", +/// }); +/// assert_eq!(expected, serde_json::to_value(&data).unwrap()); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct PickFirst<T>(PhantomData<T>); + +/// Serialize value by converting to/from a proxy type with serde support. +/// +/// This adapter serializes a type `O` by converting it into a second type `T` and serializing `T`. +/// Deserializing works analogue, by deserializing a `T` and then converting into `O`. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// struct S { +/// #[serde_as(as = "FromInto<T>")] +/// value: O, +/// } +/// # } +/// ``` +/// +/// For serialization `O` needs to be `O: Into<T> + Clone`. +/// For deserialization the opposite `T: Into<O>` is required. +/// The `Clone` bound is required since `serialize` operates on a reference but `Into` implementations on references are uncommon. +/// +/// **Note**: [`TryFromInto`] is the more generalized version of this adapter which uses the [`TryInto`](std::convert::TryInto) trait instead. +/// +/// # Example +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, FromInto}; +/// # +/// #[derive(Clone, Debug, PartialEq)] +/// struct Rgb { +/// red: u8, +/// green: u8, +/// blue: u8, +/// } +/// +/// # /* +/// impl From<(u8, u8, u8)> for Rgb { ... } +/// impl From<Rgb> for (u8, u8, u8) { ... } +/// # */ +/// # +/// # impl From<(u8, u8, u8)> for Rgb { +/// # fn from(v: (u8, u8, u8)) -> Self { +/// # Rgb { +/// # red: v.0, +/// # green: v.1, +/// # blue: v.2, +/// # } +/// # } +/// # } +/// # +/// # impl From<Rgb> for (u8, u8, u8) { +/// # fn from(v: Rgb) -> Self { +/// # (v.red, v.green, v.blue) +/// # } +/// # } +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Color { +/// #[serde_as(as = "FromInto<(u8, u8, u8)>")] +/// rgb: Rgb, +/// } +/// let color = Color { +/// rgb: Rgb { +/// red: 128, +/// green: 64, +/// blue: 32, +/// }, +/// }; +/// +/// // Define our expected JSON form +/// let j = json!({ +/// "rgb": [128, 64, 32], +/// }); +/// // Ensure serialization and deserialization produce the expected results +/// assert_eq!(j, serde_json::to_value(&color).unwrap()); +/// assert_eq!(color, serde_json::from_value(j).unwrap()); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct FromInto<T>(PhantomData<T>); + +/// Serialize value by converting to/from a proxy type with serde support. +/// +/// This adapter serializes a type `O` by converting it into a second type `T` and serializing `T`. +/// Deserializing works analogue, by deserializing a `T` and then converting into `O`. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// struct S { +/// #[serde_as(as = "TryFromInto<T>")] +/// value: O, +/// } +/// # } +/// ``` +/// +/// For serialization `O` needs to be `O: TryInto<T> + Clone`. +/// For deserialization the opposite `T: TryInto<O>` is required. +/// The `Clone` bound is required since `serialize` operates on a reference but `TryInto` implementations on references are uncommon. +/// In both cases the `TryInto::Error` type must implement [`Display`](std::fmt::Display). +/// +/// **Note**: [`FromInto`] is the more specialized version of this adapter which uses the infallible [`Into`] trait instead. +/// [`TryFromInto`] is strictly more general and can also be used where [`FromInto`] is applicable. +/// The example shows a use case, when only the deserialization behavior is fallible, but not serializing. +/// +/// # Example +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TryFromInto}; +/// # use std::convert::TryFrom; +/// # +/// #[derive(Clone, Debug, PartialEq)] +/// enum Boollike { +/// True, +/// False, +/// } +/// +/// # /* +/// impl From<Boollike> for u8 { ... } +/// # */ +/// # +/// impl TryFrom<u8> for Boollike { +/// type Error = String; +/// fn try_from(v: u8) -> Result<Self, Self::Error> { +/// match v { +/// 0 => Ok(Boollike::False), +/// 1 => Ok(Boollike::True), +/// _ => Err(format!("Boolikes can only be constructed from 0 or 1 but found {}", v)) +/// } +/// } +/// } +/// # +/// # impl From<Boollike> for u8 { +/// # fn from(v: Boollike) -> Self { +/// # match v { +/// # Boollike::True => 1, +/// # Boollike::False => 0, +/// # } +/// # } +/// # } +/// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Data { +/// #[serde_as(as = "TryFromInto<u8>")] +/// b: Boollike, +/// } +/// let data = Data { +/// b: Boollike::True, +/// }; +/// +/// // Define our expected JSON form +/// let j = json!({ +/// "b": 1, +/// }); +/// // Ensure serialization and deserialization produce the expected results +/// assert_eq!(j, serde_json::to_value(&data).unwrap()); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +/// +/// // Numbers besides 0 or 1 should be an error +/// let j = json!({ +/// "b": 2, +/// }); +/// assert_eq!("Boolikes can only be constructed from 0 or 1 but found 2", serde_json::from_value::<Data>(j).unwrap_err().to_string()); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct TryFromInto<T>(PhantomData<T>); + +/// Borrow `Cow` data during deserialization when possible. +/// +/// The types `Cow<'a, [u8]>`, `Cow<'a, [u8; N]>`, and `Cow<'a, str>` can borrow from the input data during deserialization. +/// serde supports this, by annotating the fields with `#[serde(borrow)]`. but does not support borrowing on nested types. +/// This gap is filled by this `BorrowCow` adapter. +/// +/// Using this adapter with `Cow<'a, [u8]>`/Cow<'a, [u8; N]>` will serialize the value as a sequence of `u8` values. +/// This *might* not allow to borrow the data during deserialization. +/// For a different format, which is also more efficient, use the [`Bytes`] adapter, which is also implemented for `Cow`. +/// +/// When combined with the [`serde_as`] attribute, the `#[serde(borrow)]` annotation will be added automatically. +/// If the annotation is wrong or too broad, for example because of multiple lifetime parameters, a manual annotation is required. +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{serde_as, BorrowCow}; +/// # use std::borrow::Cow; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Data<'a, 'b, 'c> { +/// #[serde_as(as = "BorrowCow")] +/// str: Cow<'a, str>, +/// #[serde_as(as = "BorrowCow")] +/// slice: Cow<'b, [u8]>, +/// +/// #[serde_as(as = "Option<[BorrowCow; 1]>")] +/// nested: Option<[Cow<'c, str>; 1]>, +/// } +/// let data = Data { +/// str: "foobar".into(), +/// slice: b"foobar"[..].into(), +/// nested: Some(["HelloWorld".into()]), +/// }; +/// +/// // Define our expected JSON form +/// let j = r#"{ +/// "str": "foobar", +/// "slice": [ +/// 102, +/// 111, +/// 111, +/// 98, +/// 97, +/// 114 +/// ], +/// "nested": [ +/// "HelloWorld" +/// ] +/// }"#; +/// // Ensure serialization and deserialization produce the expected results +/// assert_eq!(j, serde_json::to_string_pretty(&data).unwrap()); +/// assert_eq!(data, serde_json::from_str(j).unwrap()); +/// +/// // Cow borrows from the input data +/// let deserialized: Data<'_, '_, '_> = serde_json::from_str(j).unwrap(); +/// assert!(matches!(deserialized.str, Cow::Borrowed(_))); +/// assert!(matches!(deserialized.nested, Some([Cow::Borrowed(_)]))); +/// // JSON does not allow borrowing bytes, so `slice` does not borrow +/// assert!(matches!(deserialized.slice, Cow::Owned(_))); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct BorrowCow; + +/// Deserialize a sequence into `Vec<T>`, skipping elements which fail to deserialize. +/// +/// The serialization behavior is identical to `Vec<T>`. This is an alternative to `Vec<T>` +/// which is resilient against unexpected data. +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{serde_as, VecSkipError}; +/// # +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// # #[non_exhaustive] +/// enum Color { +/// Red, +/// Green, +/// Blue, +/// } +/// # use Color::*; +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Palette(#[serde_as(as = "VecSkipError<_>")] Vec<Color>); +/// +/// let data = Palette(vec![Blue, Green,]); +/// let source_json = r#"["Blue", "Yellow", "Green"]"#; +/// let data_json = r#"["Blue","Green"]"#; +/// // Ensure serialization and deserialization produce the expected results +/// assert_eq!(data_json, serde_json::to_string(&data).unwrap()); +/// assert_eq!(data, serde_json::from_str(source_json).unwrap()); +/// # } +/// ``` + +#[derive(Copy, Clone, Debug, Default)] +pub struct VecSkipError<T>(PhantomData<T>); + +/// Deserialize a boolean from a number +/// +/// Deserialize a number (of `u8`) and turn it into a boolean. +/// The adapter supports a [`Strict`](crate::formats::Strict) and [`Flexible`](crate::formats::Flexible) format. +/// In `Strict` mode, the number must be `0` or `1`. +/// All other values produce an error. +/// In `Flexible` mode, the number any non-zero value is converted to `true`. +/// +/// During serialization only `0` or `1` are ever emitted. +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, BoolFromInt}; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Data(#[serde_as(as = "BoolFromInt")] bool); +/// +/// let data = Data(true); +/// let j = json!(1); +/// // Ensure serialization and deserialization produce the expected results +/// assert_eq!(j, serde_json::to_value(&data).unwrap()); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +/// +/// // false maps to 0 +/// let data = Data(false); +/// let j = json!(0); +/// assert_eq!(j, serde_json::to_value(&data).unwrap()); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +// +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Flexible(#[serde_as(as = "BoolFromInt<serde_with::formats::Flexible>")] bool); +/// +/// // Flexible turns any non-zero number into true +/// let data = Flexible(true); +/// let j = json!(100); +/// assert_eq!(data, serde_json::from_value(j).unwrap()); +/// # } +/// ``` +#[derive(Copy, Clone, Debug, Default)] +pub struct BoolFromInt<S: formats::Strictness = formats::Strict>(PhantomData<S>); diff --git a/third_party/rust/serde_with/src/rust.rs b/third_party/rust/serde_with/src/rust.rs new file mode 100644 index 0000000000..cb64f0da9f --- /dev/null +++ b/third_party/rust/serde_with/src/rust.rs @@ -0,0 +1,1943 @@ +//! De/Serialization for Rust's builtin and std types + +use crate::{utils, Separator}; +#[cfg(doc)] +use alloc::collections::BTreeMap; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; +use core::{ + cmp::Eq, + fmt::{self, Display}, + hash::Hash, + iter::FromIterator, + marker::PhantomData, + str::FromStr, +}; +use serde::{ + de::{Deserialize, DeserializeOwned, Deserializer, Error, MapAccess, SeqAccess, Visitor}, + ser::{Serialize, Serializer}, +}; +#[cfg(doc)] +use std::collections::HashMap; + +/// De/Serialize using [`Display`] and [`FromStr`] implementation +/// +/// This allows deserializing a string as a number. +/// It can be very useful for serialization formats like JSON, which do not support integer +/// numbers and have to resort to strings to represent them. +/// +/// If you control the type you want to de/serialize, you can instead use the two derive macros, [`SerializeDisplay`] and [`DeserializeFromStr`]. +/// They properly implement the traits [`Serialize`] and [`Deserialize`] such that user of the type no longer have to use the with-attribute. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed via [`DisplayFromStr`] and using the [`serde_as`] macro. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, DisplayFromStr}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct A { +/// #[serde_as(as = "DisplayFromStr")] +/// value: mime::Mime, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// ```rust +/// # use serde::{Deserialize, Serialize}; +/// # +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::display_fromstr")] +/// mime: mime::Mime, +/// #[serde(with = "serde_with::rust::display_fromstr")] +/// number: u32, +/// } +/// +/// let v: A = serde_json::from_str(r#"{ +/// "mime": "text/plain", +/// "number": "159" +/// }"#).unwrap(); +/// assert_eq!(mime::TEXT_PLAIN, v.mime); +/// assert_eq!(159, v.number); +/// +/// let x = A { +/// mime: mime::STAR_STAR, +/// number: 777, +/// }; +/// assert_eq!( +/// r#"{"mime":"*/*","number":"777"}"#, +/// serde_json::to_string(&x).unwrap() +/// ); +/// ``` +/// +/// [`DeserializeFromStr`]: serde_with_macros::DeserializeFromStr +/// [`DisplayFromStr`]: crate::DisplayFromStr +/// [`serde_as`]: crate::guide::serde_as +/// [`SerializeDisplay`]: serde_with_macros::SerializeDisplay +pub mod display_fromstr { + use super::*; + + /// Deserialize T using [`FromStr`] + pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: FromStr, + T::Err: Display, + { + struct Helper<S>(PhantomData<S>); + + impl<'de, S> Visitor<'de> for Helper<S> + where + S: FromStr, + <S as FromStr>::Err: Display, + { + type Value = S; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "a string") + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: Error, + { + value.parse::<Self::Value>().map_err(Error::custom) + } + } + + deserializer.deserialize_str(Helper(PhantomData)) + } + + /// Serialize T using [Display] + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Display, + S: Serializer, + { + serializer.collect_str(&value) + } +} + +/// De/Serialize sequences using [`FromIterator`] and [`IntoIterator`] implementation for it and [`Display`] and [`FromStr`] implementation for each element +/// +/// This allows to serialize and deserialize collections with elements which can be represented as strings. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed via [`DisplayFromStr`] and using the [`serde_as`] macro. +/// Instead of +/// +/// ```rust,ignore +/// #[serde(with = "serde_with::rust::seq_display_fromstr")] +/// addresses: BTreeSet<Ipv4Addr>, +/// ``` +/// you can write: +/// ```rust,ignore +/// #[serde_as(as = "BTreeSet<DisplayFromStr>")] +/// addresses: BTreeSet<Ipv4Addr>, +/// ``` +/// +/// This works for any container type, so also for `Vec`: +/// ```rust,ignore +/// #[serde_as(as = "Vec<DisplayFromStr>")] +/// bs: Vec<bool>, +/// ``` +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # +/// use std::collections::BTreeSet; +/// use std::net::Ipv4Addr; +/// +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::seq_display_fromstr")] +/// addresses: BTreeSet<Ipv4Addr>, +/// #[serde(with = "serde_with::rust::seq_display_fromstr")] +/// bs: Vec<bool>, +/// } +/// +/// let v: A = serde_json::from_str(r#"{ +/// "addresses": ["192.168.2.1", "192.168.2.2", "192.168.1.1", "192.168.2.2"], +/// "bs": ["true", "false"] +/// }"#).unwrap(); +/// assert_eq!(v.addresses.len(), 3); +/// assert!(v.addresses.contains(&Ipv4Addr::new(192, 168, 2, 1))); +/// assert!(v.addresses.contains(&Ipv4Addr::new(192, 168, 2, 2))); +/// assert!(!v.addresses.contains(&Ipv4Addr::new(192, 168, 1, 2))); +/// assert_eq!(v.bs.len(), 2); +/// assert!(v.bs[0]); +/// assert!(!v.bs[1]); +/// +/// let x = A { +/// addresses: vec![ +/// Ipv4Addr::new(127, 53, 0, 1), +/// Ipv4Addr::new(127, 53, 1, 1), +/// Ipv4Addr::new(127, 53, 0, 2) +/// ].into_iter().collect(), +/// bs: vec![false, true], +/// }; +/// assert_eq!( +/// r#"{"addresses":["127.53.0.1","127.53.0.2","127.53.1.1"],"bs":["false","true"]}"#, +/// serde_json::to_string(&x).unwrap() +/// ); +/// ``` +/// +/// [`DisplayFromStr`]: crate::DisplayFromStr +/// [`serde_as`]: crate::guide::serde_as +pub mod seq_display_fromstr { + use super::*; + + /// Deserialize collection T using [FromIterator] and [FromStr] for each element + pub fn deserialize<'de, D, T, I>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: FromIterator<I> + Sized, + I: FromStr, + I::Err: Display, + { + struct Helper<S>(PhantomData<S>); + + impl<'de, S> Visitor<'de> for Helper<S> + where + S: FromStr, + <S as FromStr>::Err: Display, + { + type Value = Vec<S>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "a sequence") + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + utils::SeqIter::new(seq) + .map(|res| { + res.and_then(|value: &str| value.parse::<S>().map_err(Error::custom)) + }) + .collect() + } + } + + deserializer + .deserialize_seq(Helper(PhantomData)) + .map(T::from_iter) + } + + /// Serialize collection T using [IntoIterator] and [Display] for each element + pub fn serialize<S, T, I>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + for<'a> &'a T: IntoIterator<Item = &'a I>, + I: Display, + { + struct SerializeString<'a, I>(&'a I); + + impl<'a, I> Serialize for SerializeString<'a, I> + where + I: Display, + { + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_str(self.0) + } + } + + serializer.collect_seq(value.into_iter().map(SerializeString)) + } +} + +/// De/Serialize a delimited collection using [`Display`] and [`FromStr`] implementation +/// +/// You can define an arbitrary separator, by specifying a type which implements [`Separator`]. +/// Some common ones, like space and comma are already predefined and you can find them [here][Separator]. +/// +/// An empty string deserializes as an empty collection. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can also be expressed using the [`serde_as`] macro. +/// The usage is slightly different. +/// `StringWithSeparator` takes a second type, which needs to implement [`Display`]+[`FromStr`] and constitutes the inner type of the collection. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, SpaceSeparator, StringWithSeparator}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct A { +/// #[serde_as(as = "StringWithSeparator::<SpaceSeparator, String>")] +/// tags: Vec<String>, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # +/// use serde_with::{CommaSeparator, SpaceSeparator}; +/// use std::collections::BTreeSet; +/// +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::StringWithSeparator::<SpaceSeparator>")] +/// tags: Vec<String>, +/// #[serde(with = "serde_with::rust::StringWithSeparator::<CommaSeparator>")] +/// more_tags: BTreeSet<String>, +/// } +/// +/// let v: A = serde_json::from_str(r##"{ +/// "tags": "#hello #world", +/// "more_tags": "foo,bar,bar" +/// }"##).unwrap(); +/// assert_eq!(vec!["#hello", "#world"], v.tags); +/// assert_eq!(2, v.more_tags.len()); +/// +/// let x = A { +/// tags: vec!["1".to_string(), "2".to_string(), "3".to_string()], +/// more_tags: BTreeSet::new(), +/// }; +/// assert_eq!( +/// r#"{"tags":"1 2 3","more_tags":""}"#, +/// serde_json::to_string(&x).unwrap() +/// ); +/// ``` +/// +/// [`serde_as`]: crate::guide::serde_as +#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)] +pub struct StringWithSeparator<Sep, T = ()>(PhantomData<(Sep, T)>); + +impl<Sep> StringWithSeparator<Sep> +where + Sep: Separator, +{ + /// Serialize collection into a string with separator symbol + pub fn serialize<S, T, V>(values: T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + T: IntoIterator<Item = V>, + V: Display, + { + let mut s = String::new(); + for v in values { + s.push_str(&*v.to_string()); + s.push_str(Sep::separator()); + } + serializer.serialize_str(if !s.is_empty() { + // remove trailing separator if present + &s[..s.len() - Sep::separator().len()] + } else { + &s[..] + }) + } + + /// Deserialize a collection from a string with separator symbol + pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: FromIterator<V>, + V: FromStr, + V::Err: Display, + { + let s = String::deserialize(deserializer)?; + if s.is_empty() { + Ok(None.into_iter().collect()) + } else { + s.split(Sep::separator()) + .map(FromStr::from_str) + .collect::<Result<_, _>>() + .map_err(Error::custom) + } + } +} + +/// Makes a distinction between a missing, unset, or existing value +/// +/// Some serialization formats make a distinction between missing fields, fields with a `null` +/// value, and existing values. One such format is JSON. By default it is not easily possible to +/// differentiate between a missing value and a field which is `null`, as they deserialize to the +/// same value. This helper changes it, by using an `Option<Option<T>>` to deserialize into. +/// +/// * `None`: Represents a missing value. +/// * `Some(None)`: Represents a `null` value. +/// * `Some(Some(value))`: Represents an existing value. +/// +/// # Examples +/// +/// ```rust +/// # use serde::{Deserialize, Serialize}; +/// # +/// # #[derive(Debug, PartialEq, Eq)] +/// #[derive(Deserialize, Serialize)] +/// struct Doc { +/// #[serde( +/// default, // <- important for deserialization +/// skip_serializing_if = "Option::is_none", // <- important for serialization +/// with = "::serde_with::rust::double_option", +/// )] +/// a: Option<Option<u8>>, +/// } +/// // Missing Value +/// let s = r#"{}"#; +/// assert_eq!(Doc { a: None }, serde_json::from_str(s).unwrap()); +/// assert_eq!(s, serde_json::to_string(&Doc { a: None }).unwrap()); +/// +/// // Unset Value +/// let s = r#"{"a":null}"#; +/// assert_eq!(Doc { a: Some(None) }, serde_json::from_str(s).unwrap()); +/// assert_eq!(s, serde_json::to_string(&Doc { a: Some(None) }).unwrap()); +/// +/// // Existing Value +/// let s = r#"{"a":5}"#; +/// assert_eq!(Doc { a: Some(Some(5)) }, serde_json::from_str(s).unwrap()); +/// assert_eq!(s, serde_json::to_string(&Doc { a: Some(Some(5)) }).unwrap()); +/// ``` +#[allow(clippy::option_option)] +pub mod double_option { + use super::*; + + /// Deserialize potentially non-existing optional value + pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<Option<T>>, D::Error> + where + T: Deserialize<'de>, + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(Some) + } + + /// Serialize optional value + pub fn serialize<S, T>(values: &Option<Option<T>>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + T: Serialize, + { + match values { + None => serializer.serialize_unit(), + Some(None) => serializer.serialize_none(), + Some(Some(v)) => serializer.serialize_some(&v), + } + } +} + +/// Serialize inner value if [`Some`]`(T)`. If [`None`], serialize the unit struct `()`. +/// +/// When used in conjunction with `skip_serializing_if = "Option::is_none"` and +/// `default`, you can build an optional value by skipping if it is [`None`], or serializing its +/// inner value if [`Some`]`(T)`. +/// +/// Not all serialization formats easily support optional values. +/// While JSON uses the [`Option`] type to represent optional values and only serializes the inner +/// part of the [`Some`]`()`, other serialization formats, such as [RON][], choose to serialize the +/// [`Some`] around a value. +/// This helper helps building a truly optional value for such serializers. +/// +/// [RON]: https://github.com/ron-rs/ron +/// +/// # Example +/// +/// ```rust +/// # use serde::{Deserialize, Serialize}; +/// # +/// # #[derive(Debug, Eq, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct Doc { +/// mandatory: usize, +/// #[serde( +/// default, // <- important for deserialization +/// skip_serializing_if = "Option::is_none", // <- important for serialization +/// with = "::serde_with::rust::unwrap_or_skip", +/// )] +/// optional: Option<usize>, +/// } +/// +/// // Transparently add/remove Some() wrapper +/// # let pretty_config = ron::ser::PrettyConfig::new() +/// # .new_line("\n".into()); +/// let s = r#"( +/// mandatory: 1, +/// optional: 2, +/// )"#; +/// let v = Doc { +/// mandatory: 1, +/// optional: Some(2), +/// }; +/// assert_eq!(v, ron::de::from_str(s).unwrap()); +/// assert_eq!(s, ron::ser::to_string_pretty(&v, pretty_config).unwrap()); +/// +/// // Missing values are deserialized as `None` +/// // while `None` values are skipped during serialization. +/// # let pretty_config = ron::ser::PrettyConfig::new() +/// # .new_line("\n".into()); +/// let s = r#"( +/// mandatory: 1, +/// )"#; +/// let v = Doc { +/// mandatory: 1, +/// optional: None, +/// }; +/// assert_eq!(v, ron::de::from_str(s).unwrap()); +/// assert_eq!(s, ron::ser::to_string_pretty(&v, pretty_config).unwrap()); +/// ``` +pub mod unwrap_or_skip { + use super::*; + + /// Deserialize value wrapped in Some(T) + pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error> + where + D: Deserializer<'de>, + T: DeserializeOwned, + { + T::deserialize(deserializer).map(Some) + } + + /// Serialize value if Some(T), unit struct if None + pub fn serialize<T, S>(option: &Option<T>, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + if let Some(value) = option { + value.serialize(serializer) + } else { + ().serialize(serializer) + } + } +} + +/// Ensure no duplicate values exist in a set. +/// +/// By default serde has a last-value-wins implementation, if duplicate values for a set exist. +/// Sometimes it is desirable to know when such an event happens, as the first value is overwritten +/// and it can indicate an error in the serialized data. +/// +/// This helper returns an error if two identical values exist in a set. +/// +/// The implementation supports both the [`HashSet`] and the [`BTreeSet`] from the standard library. +/// +/// [`HashSet`]: std::collections::HashSet +/// [`BTreeSet`]: std::collections::HashSet +/// +/// # Example +/// +/// ```rust +/// # use std::{collections::HashSet, iter::FromIterator}; +/// # use serde::Deserialize; +/// # +/// # #[derive(Debug, Eq, PartialEq)] +/// #[derive(Deserialize)] +/// struct Doc { +/// #[serde(with = "::serde_with::rust::sets_duplicate_value_is_error")] +/// set: HashSet<usize>, +/// } +/// +/// // Sets are serialized normally, +/// let s = r#"{"set": [1, 2, 3, 4]}"#; +/// let v = Doc { +/// set: HashSet::from_iter(vec![1, 2, 3, 4]), +/// }; +/// assert_eq!(v, serde_json::from_str(s).unwrap()); +/// +/// // but create an error if duplicate values, like the `1`, exist. +/// let s = r#"{"set": [1, 2, 3, 4, 1]}"#; +/// let res: Result<Doc, _> = serde_json::from_str(s); +/// assert!(res.is_err()); +/// ``` +pub mod sets_duplicate_value_is_error { + use super::*; + use crate::duplicate_key_impls::PreventDuplicateInsertsSet; + + /// Deserialize a set and return an error on duplicate values + pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error> + where + T: PreventDuplicateInsertsSet<V>, + V: Deserialize<'de>, + D: Deserializer<'de>, + { + struct SeqVisitor<T, V> { + marker: PhantomData<T>, + set_item_type: PhantomData<V>, + } + + impl<'de, T, V> Visitor<'de> for SeqVisitor<T, V> + where + T: PreventDuplicateInsertsSet<V>, + V: Deserialize<'de>, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + #[inline] + fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let mut values = Self::Value::new(access.size_hint()); + + while let Some(value) = access.next_element()? { + if !values.insert(value) { + return Err(Error::custom("invalid entry: found duplicate value")); + }; + } + + Ok(values) + } + } + + let visitor = SeqVisitor { + marker: PhantomData, + set_item_type: PhantomData, + }; + deserializer.deserialize_seq(visitor) + } + + /// Serialize the set with the default serializer + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// Ensure no duplicate keys exist in a map. +/// +/// By default serde has a last-value-wins implementation, if duplicate keys for a map exist. +/// Sometimes it is desirable to know when such an event happens, as the first value is overwritten +/// and it can indicate an error in the serialized data. +/// +/// This helper returns an error if two identical keys exist in a map. +/// +/// The implementation supports both the [`HashMap`] and the [`BTreeMap`] from the standard library. +/// +/// [`HashMap`]: std::collections::HashMap +/// [`BTreeMap`]: std::collections::HashMap +/// +/// # Example +/// +/// ```rust +/// # use serde::Deserialize; +/// # use std::collections::HashMap; +/// # +/// # #[derive(Debug, Eq, PartialEq)] +/// #[derive(Deserialize)] +/// struct Doc { +/// #[serde(with = "::serde_with::rust::maps_duplicate_key_is_error")] +/// map: HashMap<usize, usize>, +/// } +/// +/// // Maps are serialized normally, +/// let s = r#"{"map": {"1": 1, "2": 2, "3": 3}}"#; +/// let mut v = Doc { +/// map: HashMap::new(), +/// }; +/// v.map.insert(1, 1); +/// v.map.insert(2, 2); +/// v.map.insert(3, 3); +/// assert_eq!(v, serde_json::from_str(s).unwrap()); +/// +/// // but create an error if duplicate keys, like the `1`, exist. +/// let s = r#"{"map": {"1": 1, "2": 2, "1": 3}}"#; +/// let res: Result<Doc, _> = serde_json::from_str(s); +/// assert!(res.is_err()); +/// ``` +pub mod maps_duplicate_key_is_error { + use super::*; + use crate::duplicate_key_impls::PreventDuplicateInsertsMap; + + /// Deserialize a map and return an error on duplicate keys + pub fn deserialize<'de, D, T, K, V>(deserializer: D) -> Result<T, D::Error> + where + T: PreventDuplicateInsertsMap<K, V>, + K: Deserialize<'de>, + V: Deserialize<'de>, + D: Deserializer<'de>, + { + struct MapVisitor<T, K, V> { + marker: PhantomData<T>, + map_key_type: PhantomData<K>, + map_value_type: PhantomData<V>, + } + + impl<'de, T, K, V> Visitor<'de> for MapVisitor<T, K, V> + where + T: PreventDuplicateInsertsMap<K, V>, + K: Deserialize<'de>, + V: Deserialize<'de>, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map") + } + + #[inline] + fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + let mut values = Self::Value::new(access.size_hint()); + + while let Some((key, value)) = access.next_entry()? { + if !values.insert(key, value) { + return Err(Error::custom("invalid entry: found duplicate key")); + }; + } + + Ok(values) + } + } + + let visitor = MapVisitor { + marker: PhantomData, + map_key_type: PhantomData, + map_value_type: PhantomData, + }; + deserializer.deserialize_map(visitor) + } + + /// Serialize the map with the default serializer + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// *DEPRECATED* Ensure that the first value is taken, if duplicate values exist +/// +/// This module implements the default behavior in serde. +#[deprecated = "This module does nothing. Remove the attribute. Serde's default behavior is to use the first value when deserializing a set."] +#[allow(deprecated)] +pub mod sets_first_value_wins { + use super::*; + use crate::duplicate_key_impls::DuplicateInsertsFirstWinsSet; + + /// Deserialize a set and keep the first of equal values + #[deprecated = "This function does nothing. Remove the attribute. Serde's default behavior is to use the first value when deserializing a set."] + pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error> + where + T: DuplicateInsertsFirstWinsSet<V>, + V: Deserialize<'de>, + D: Deserializer<'de>, + { + struct SeqVisitor<T, V> { + marker: PhantomData<T>, + set_item_type: PhantomData<V>, + } + + impl<'de, T, V> Visitor<'de> for SeqVisitor<T, V> + where + T: DuplicateInsertsFirstWinsSet<V>, + V: Deserialize<'de>, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + #[inline] + fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let mut values = Self::Value::new(access.size_hint()); + + while let Some(value) = access.next_element()? { + values.insert(value); + } + + Ok(values) + } + } + + let visitor = SeqVisitor { + marker: PhantomData, + set_item_type: PhantomData, + }; + deserializer.deserialize_seq(visitor) + } + + /// Serialize the set with the default serializer + #[deprecated = "This function does nothing. Remove the attribute. Serde's default behavior is to use the first value when deserializing a set."] + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// Ensure that the last value is taken, if duplicate values exist +/// +/// By default serde has a first-value-wins implementation, if duplicate keys for a set exist. +/// Sometimes the opposite strategy is desired. This helper implements a first-value-wins strategy. +/// +/// The implementation supports both the [`HashSet`] and the [`BTreeSet`] from the standard library. +/// +/// [`HashSet`]: std::collections::HashSet +/// [`BTreeSet`]: std::collections::HashSet +pub mod sets_last_value_wins { + use super::*; + use crate::duplicate_key_impls::DuplicateInsertsLastWinsSet; + + /// Deserialize a set and keep the last of equal values + pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error> + where + T: DuplicateInsertsLastWinsSet<V>, + V: Deserialize<'de>, + D: Deserializer<'de>, + { + struct SeqVisitor<T, V> { + marker: PhantomData<T>, + set_item_type: PhantomData<V>, + } + + impl<'de, T, V> Visitor<'de> for SeqVisitor<T, V> + where + T: DuplicateInsertsLastWinsSet<V>, + V: Deserialize<'de>, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + #[inline] + fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let mut values = Self::Value::new(access.size_hint()); + + while let Some(value) = access.next_element()? { + values.replace(value); + } + + Ok(values) + } + } + + let visitor = SeqVisitor { + marker: PhantomData, + set_item_type: PhantomData, + }; + deserializer.deserialize_seq(visitor) + } + + /// Serialize the set with the default serializer + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// Ensure that the first key is taken, if duplicate keys exist +/// +/// By default serde has a last-key-wins implementation, if duplicate keys for a map exist. +/// Sometimes the opposite strategy is desired. This helper implements a first-key-wins strategy. +/// +/// The implementation supports both the [`HashMap`] and the [`BTreeMap`] from the standard library. +/// +/// [`HashMap`]: std::collections::HashMap +/// [`BTreeMap`]: std::collections::HashMap +/// +/// # Example +/// +/// ```rust +/// # use serde::Deserialize; +/// # use std::collections::HashMap; +/// # +/// # #[derive(Debug, Eq, PartialEq)] +/// #[derive(Deserialize)] +/// struct Doc { +/// #[serde(with = "::serde_with::rust::maps_first_key_wins")] +/// map: HashMap<usize, usize>, +/// } +/// +/// // Maps are serialized normally, +/// let s = r#"{"map": {"1": 1, "2": 2, "3": 3}}"#; +/// let mut v = Doc { +/// map: HashMap::new(), +/// }; +/// v.map.insert(1, 1); +/// v.map.insert(2, 2); +/// v.map.insert(3, 3); +/// assert_eq!(v, serde_json::from_str(s).unwrap()); +/// +/// // but create an error if duplicate keys, like the `1`, exist. +/// let s = r#"{"map": {"1": 1, "2": 2, "1": 3}}"#; +/// let mut v = Doc { +/// map: HashMap::new(), +/// }; +/// v.map.insert(1, 1); +/// v.map.insert(2, 2); +/// assert_eq!(v, serde_json::from_str(s).unwrap()); +/// ``` +pub mod maps_first_key_wins { + use super::*; + use crate::duplicate_key_impls::DuplicateInsertsFirstWinsMap; + + /// Deserialize a map and return an error on duplicate keys + pub fn deserialize<'de, D, T, K, V>(deserializer: D) -> Result<T, D::Error> + where + T: DuplicateInsertsFirstWinsMap<K, V>, + K: Deserialize<'de>, + V: Deserialize<'de>, + D: Deserializer<'de>, + { + struct MapVisitor<T, K, V> { + marker: PhantomData<T>, + map_key_type: PhantomData<K>, + map_value_type: PhantomData<V>, + } + + impl<'de, T, K, V> Visitor<'de> for MapVisitor<T, K, V> + where + T: DuplicateInsertsFirstWinsMap<K, V>, + K: Deserialize<'de>, + V: Deserialize<'de>, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map") + } + + #[inline] + fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + let mut values = Self::Value::new(access.size_hint()); + + while let Some((key, value)) = access.next_entry()? { + values.insert(key, value); + } + + Ok(values) + } + } + + let visitor = MapVisitor { + marker: PhantomData, + map_key_type: PhantomData, + map_value_type: PhantomData, + }; + deserializer.deserialize_map(visitor) + } + + /// Serialize the map with the default serializer + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// De/Serialize a [`Option<String>`] type while transforming the empty string to [`None`] +/// +/// Convert an [`Option<T>`] from/to string using [`FromStr`] and [`AsRef<str>`] implementations. +/// An empty string is deserialized as [`None`] and a [`None`] vice versa. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed via [`NoneAsEmptyString`] and using the [`serde_as`] macro. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, NoneAsEmptyString}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct A { +/// #[serde_as(as = "NoneAsEmptyString")] +/// value: Option<String>, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::rust::string_empty_as_none; +/// # +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "string_empty_as_none")] +/// tags: Option<String>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ "tags": "" })).unwrap(); +/// assert_eq!(None, v.tags); +/// +/// let v: A = serde_json::from_value(json!({ "tags": "Hi" })).unwrap(); +/// assert_eq!(Some("Hi".to_string()), v.tags); +/// +/// let x = A { +/// tags: Some("This is text".to_string()), +/// }; +/// assert_eq!(json!({ "tags": "This is text" }), serde_json::to_value(&x).unwrap()); +/// +/// let x = A { +/// tags: None, +/// }; +/// assert_eq!(json!({ "tags": "" }), serde_json::to_value(&x).unwrap()); +/// ``` +/// +/// [`NoneAsEmptyString`]: crate::NoneAsEmptyString +/// [`serde_as`]: crate::guide::serde_as +pub mod string_empty_as_none { + use super::*; + + /// Deserialize an `Option<T>` from a string using `FromStr` + pub fn deserialize<'de, D, S>(deserializer: D) -> Result<Option<S>, D::Error> + where + D: Deserializer<'de>, + S: FromStr, + S::Err: Display, + { + struct OptionStringEmptyNone<S>(PhantomData<S>); + impl<'de, S> Visitor<'de> for OptionStringEmptyNone<S> + where + S: FromStr, + S::Err: Display, + { + type Value = Option<S>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("any string") + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: Error, + { + match value { + "" => Ok(None), + v => S::from_str(v).map(Some).map_err(Error::custom), + } + } + + fn visit_string<E>(self, value: String) -> Result<Self::Value, E> + where + E: Error, + { + match &*value { + "" => Ok(None), + v => S::from_str(v).map(Some).map_err(Error::custom), + } + } + + // handles the `null` case + fn visit_unit<E>(self) -> Result<Self::Value, E> + where + E: Error, + { + Ok(None) + } + } + + deserializer.deserialize_any(OptionStringEmptyNone(PhantomData)) + } + + /// Serialize a string from `Option<T>` using `AsRef<str>` or using the empty string if `None`. + pub fn serialize<T, S>(option: &Option<T>, serializer: S) -> Result<S::Ok, S::Error> + where + T: AsRef<str>, + S: Serializer, + { + if let Some(value) = option { + value.as_ref().serialize(serializer) + } else { + "".serialize(serializer) + } + } +} + +/// De/Serialize a Map into a list of tuples +/// +/// Some formats, like JSON, have limitations on the type of keys for maps. +/// In case of JSON, keys are restricted to strings. +/// Rust features more powerful keys, for example tuple, which can not be serialized to JSON. +/// +/// This helper serializes the Map into a list of tuples, which does not have the same type restrictions. +/// The module can be applied on any type implementing `IntoIterator<Item = (&'a K, &'a V)>` and `FromIterator<(K, V)>`, with `K` and `V` being the key and value types. +/// From the standard library both [`HashMap`] and [`BTreeMap`] fullfil the condition and can be used here. +/// +/// ## Converting to `serde_as` +/// +/// If the map is of type [`HashMap`] or [`BTreeMap`] the same functionality can be expressed more clearly using the [`serde_as`] macro. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::serde_as; +/// # use std::collections::{BTreeMap, HashMap}; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "Vec<(_, _)>")] +/// hashmap: HashMap<(String, u32), u32>, +/// #[serde_as(as = "Vec<(_, _)>")] +/// btreemap: BTreeMap<(String, u32), u32>, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use std::collections::BTreeMap; +/// # +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::map_as_tuple_list")] +/// s: BTreeMap<(String, u32), u32>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ +/// "s": [ +/// [["Hello", 123], 0], +/// [["World", 456], 1] +/// ] +/// })).unwrap(); +/// +/// assert_eq!(2, v.s.len()); +/// assert_eq!(1, v.s[&("World".to_string(), 456)]); +/// ``` +/// +/// The helper is generic over the hasher type of the [`HashMap`] and works with different variants, such as `FnvHashMap`. +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # +/// use fnv::FnvHashMap; +/// +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::map_as_tuple_list")] +/// s: FnvHashMap<u32, bool>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ +/// "s": [ +/// [0, false], +/// [1, true] +/// ] +/// })).unwrap(); +/// +/// assert_eq!(2, v.s.len()); +/// assert_eq!(true, v.s[&1]); +/// ``` +/// +/// [`serde_as`]: crate::guide::serde_as +pub mod map_as_tuple_list { + // Trait bounds based on this answer: https://stackoverflow.com/a/66600486/15470286 + use super::*; + + /// Serialize the map as a list of tuples + pub fn serialize<'a, T, K, V, S>(map: T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + T: IntoIterator<Item = (&'a K, &'a V)>, + T::IntoIter: ExactSizeIterator, + K: Serialize + 'a, + V: Serialize + 'a, + { + serializer.collect_seq(map) + } + + /// Deserialize a map from a list of tuples + pub fn deserialize<'de, T, K, V, D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: FromIterator<(K, V)>, + K: Deserialize<'de>, + V: Deserialize<'de>, + { + struct SeqVisitor<T, K, V>(PhantomData<(T, K, V)>); + + impl<'de, T, K, V> Visitor<'de> for SeqVisitor<T, K, V> + where + T: FromIterator<(K, V)>, + K: Deserialize<'de>, + V: Deserialize<'de>, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a list of key-value pairs") + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + utils::SeqIter::new(seq).collect() + } + } + + deserializer.deserialize_seq(SeqVisitor(PhantomData)) + } +} + +/// DEPRECATED De/Serialize a [`HashMap`] into a list of tuples +/// +/// Use the [`map_as_tuple_list`] module which is more general than this. +/// It should work with everything convertible to and from an `Iterator` including [`BTreeMap`] and [`HashMap`]. +/// +/// --- +/// +/// Some formats, like JSON, have limitations on the type of keys for maps. +/// In case of JSON, keys are restricted to strings. +/// Rust features more powerful keys, for example tuple, which can not be serialized to JSON. +/// +/// This helper serializes the [`HashMap`] into a list of tuples, which does not have the same type restrictions. +/// +/// If you need to de/serialize a [`BTreeMap`] then use [`btreemap_as_tuple_list`]. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed using the [`serde_as`] macro. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::serde_as; +/// # use std::collections::HashMap; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "Vec<(_, _)>")] +/// s: HashMap<(String, u32), u32>, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use std::collections::HashMap; +/// # +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::hashmap_as_tuple_list")] +/// s: HashMap<(String, u32), u32>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ +/// "s": [ +/// [["Hello", 123], 0], +/// [["World", 456], 1] +/// ] +/// })).unwrap(); +/// +/// assert_eq!(2, v.s.len()); +/// assert_eq!(1, v.s[&("World".to_string(), 456)]); +/// ``` +/// +/// The helper is generic over the hasher type of the [`HashMap`] and works with different variants, such as `FnvHashMap`. +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # +/// use fnv::FnvHashMap; +/// +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::hashmap_as_tuple_list")] +/// s: FnvHashMap<u32, bool>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ +/// "s": [ +/// [0, false], +/// [1, true] +/// ] +/// })).unwrap(); +/// +/// assert_eq!(2, v.s.len()); +/// assert_eq!(true, v.s[&1]); +/// ``` +/// +/// [`serde_as`]: crate::guide::serde_as +#[deprecated( + since = "1.8.0", + note = "Use the more general map_as_tuple_list module." +)] +pub mod hashmap_as_tuple_list { + #[doc(inline)] + #[deprecated( + since = "1.8.0", + note = "Use the more general map_as_tuple_list::deserialize function." + )] + pub use super::map_as_tuple_list::deserialize; + #[doc(inline)] + #[deprecated( + since = "1.8.0", + note = "Use the more general map_as_tuple_list::serialize function." + )] + pub use super::map_as_tuple_list::serialize; +} + +/// DEPRECATED De/Serialize a [`BTreeMap`] into a list of tuples +/// +/// Use the [`map_as_tuple_list`] module which is more general than this. +/// It should work with everything convertible to and from an `Iterator` including [`BTreeMap`] and [`HashMap`]. +/// +/// --- +/// +/// Some formats, like JSON, have limitations on the type of keys for maps. +/// In case of JSON, keys are restricted to strings. +/// Rust features more powerful keys, for example tuple, which can not be serialized to JSON. +/// +/// This helper serializes the [`BTreeMap`] into a list of tuples, which does not have the same type restrictions. +/// +/// If you need to de/serialize a [`HashMap`] then use [`hashmap_as_tuple_list`]. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed using the [`serde_as`] macro. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::serde_as; +/// # use std::collections::BTreeMap; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "Vec<(_, _)>")] +/// s: BTreeMap<(String, u32), u32>, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use std::collections::BTreeMap; +/// # +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde(with = "serde_with::rust::btreemap_as_tuple_list")] +/// s: BTreeMap<(String, u32), u32>, +/// } +/// +/// let v: A = serde_json::from_value(json!({ +/// "s": [ +/// [["Hello", 123], 0], +/// [["World", 456], 1] +/// ] +/// })).unwrap(); +/// +/// assert_eq!(2, v.s.len()); +/// assert_eq!(1, v.s[&("World".to_string(), 456)]); +/// ``` +/// +/// [`serde_as`]: crate::guide::serde_as +#[deprecated( + since = "1.8.0", + note = "Use the more general map_as_tuple_list module." +)] +pub mod btreemap_as_tuple_list { + #[doc(inline)] + #[deprecated( + since = "1.8.0", + note = "Use the more general map_as_tuple_list::deserialize function." + )] + pub use super::map_as_tuple_list::deserialize; + #[doc(inline)] + #[deprecated( + since = "1.8.0", + note = "Use the more general map_as_tuple_list::serialize function." + )] + pub use super::map_as_tuple_list::serialize; +} + +/// This serializes a list of tuples into a map and back +/// +/// Normally, you want to use a [`HashMap`] or a [`BTreeMap`] when deserializing a map. +/// However, sometimes this is not possible due to type contains, e.g., if the type implements neither [`Hash`] nor [`Ord`]. +/// Another use case is deserializing a map with duplicate keys. +/// +/// The implementation is generic using the [`FromIterator`] and [`IntoIterator`] traits. +/// Therefore, all of [`Vec`], [`VecDeque`](std::collections::VecDeque), and [`LinkedList`](std::collections::LinkedList) and anything which implements those are supported. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed using the [`serde_as`] macro. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::serde_as; +/// # use std::collections::BTreeMap; +/// # +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct S { +/// #[serde_as(as = "BTreeMap<_, _>")] // HashMap will also work +/// s: Vec<(i32, String)>, +/// } +/// # } +/// ``` +/// +/// # Examples +/// +/// `Wrapper` does not implement [`Hash`] nor [`Ord`], thus prohibiting the use [`HashMap`] or [`BTreeMap`]. +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # +/// #[derive(Debug, Deserialize, Serialize, Default)] +/// struct S { +/// #[serde(with = "serde_with::rust::tuple_list_as_map")] +/// s: Vec<(Wrapper<i32>, Wrapper<String>)>, +/// } +/// +/// #[derive(Clone, Debug, Serialize, Deserialize)] +/// #[serde(transparent)] +/// struct Wrapper<T>(T); +/// +/// let from = r#"{ +/// "s": { +/// "1": "Hi", +/// "2": "Cake", +/// "99": "Lie" +/// } +/// }"#; +/// let mut expected = S::default(); +/// expected.s.push((Wrapper(1), Wrapper("Hi".into()))); +/// expected.s.push((Wrapper(2), Wrapper("Cake".into()))); +/// expected.s.push((Wrapper(99), Wrapper("Lie".into()))); +/// +/// let res: S = serde_json::from_str(from).unwrap(); +/// for ((exp_k, exp_v), (res_k, res_v)) in expected.s.iter().zip(&res.s) { +/// assert_eq!(exp_k.0, res_k.0); +/// assert_eq!(exp_v.0, res_v.0); +/// } +/// assert_eq!(from, serde_json::to_string_pretty(&expected).unwrap()); +/// ``` +/// +/// In this example, the serialized format contains duplicate keys, which is not supported with [`HashMap`] or [`BTreeMap`]. +/// +/// ``` +/// # use serde::{Deserialize, Serialize}; +/// # +/// #[derive(Debug, Deserialize, Serialize, PartialEq, Default)] +/// struct S { +/// #[serde(with = "serde_with::rust::tuple_list_as_map")] +/// s: Vec<(i32, String)>, +/// } +/// +/// let from = r#"{ +/// "s": { +/// "1": "Hi", +/// "1": "Cake", +/// "1": "Lie" +/// } +/// }"#; +/// let mut expected = S::default(); +/// expected.s.push((1, "Hi".into())); +/// expected.s.push((1, "Cake".into())); +/// expected.s.push((1, "Lie".into())); +/// +/// let res: S = serde_json::from_str(from).unwrap(); +/// assert_eq!(3, res.s.len()); +/// assert_eq!(expected, res); +/// assert_eq!(from, serde_json::to_string_pretty(&expected).unwrap()); +/// ``` +/// +/// [`serde_as`]: crate::guide::serde_as +pub mod tuple_list_as_map { + use super::*; + + /// Serialize any iteration of tuples into a map. + pub fn serialize<'a, I, K, V, S>(iter: I, serializer: S) -> Result<S::Ok, S::Error> + where + I: IntoIterator<Item = &'a (K, V)>, + I::IntoIter: ExactSizeIterator, + K: Serialize + 'a, + V: Serialize + 'a, + S: Serializer, + { + // Convert &(K, V) to (&K, &V) for collect_map. + let iter = iter.into_iter().map(|(k, v)| (k, v)); + serializer.collect_map(iter) + } + + /// Deserialize a map into an iterator of tuples. + pub fn deserialize<'de, I, K, V, D>(deserializer: D) -> Result<I, D::Error> + where + I: FromIterator<(K, V)>, + K: Deserialize<'de>, + V: Deserialize<'de>, + D: Deserializer<'de>, + { + deserializer.deserialize_map(MapVisitor(PhantomData)) + } + + #[allow(clippy::type_complexity)] + struct MapVisitor<I, K, V>(PhantomData<fn() -> (I, K, V)>); + + impl<'de, I, K, V> Visitor<'de> for MapVisitor<I, K, V> + where + I: FromIterator<(K, V)>, + K: Deserialize<'de>, + V: Deserialize<'de>, + { + type Value = I; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map") + } + + fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + utils::MapIter::new(map).collect() + } + } +} + +/// Deserialize from bytes or string +/// +/// Any Rust [`String`] can be converted into bytes, i.e., `Vec<u8>`. +/// Accepting both as formats while deserializing can be helpful while interacting with language +/// which have a looser definition of string than Rust. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed via [`BytesOrString`] and using the [`serde_as`] macro. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, BytesOrString}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct A { +/// #[serde_as(as = "BytesOrString")] +/// bos: Vec<u8>, +/// } +/// # } +/// ``` +/// +/// # Example +/// ```rust +/// # use serde::{Deserialize, Serialize}; +/// # +/// #[derive(Debug, Deserialize, Serialize, PartialEq, Default)] +/// struct S { +/// #[serde(deserialize_with = "serde_with::rust::bytes_or_string::deserialize")] +/// bos: Vec<u8>, +/// } +/// +/// // Here we deserialize from a byte array ... +/// let from = r#"{ +/// "bos": [ +/// 0, +/// 1, +/// 2, +/// 3 +/// ] +/// }"#; +/// let expected = S { +/// bos: vec![0, 1, 2, 3], +/// }; +/// +/// let res: S = serde_json::from_str(from).unwrap(); +/// assert_eq!(expected, res); +/// +/// // and serialization works too. +/// assert_eq!(from, serde_json::to_string_pretty(&expected).unwrap()); +/// +/// // But we also support deserializing from a String +/// let from = r#"{ +/// "bos": "✨Works!" +/// }"#; +/// let expected = S { +/// bos: "✨Works!".as_bytes().to_vec(), +/// }; +/// +/// let res: S = serde_json::from_str(from).unwrap(); +/// assert_eq!(expected, res); +/// ``` +/// +/// [`BytesOrString`]: crate::BytesOrString +/// [`serde_as`]: crate::guide::serde_as +pub mod bytes_or_string { + use super::*; + + /// Deserialize a [`Vec<u8>`] from either bytes or string + pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error> + where + D: Deserializer<'de>, + { + deserializer.deserialize_any(BytesOrStringVisitor) + } + + struct BytesOrStringVisitor; + + impl<'de> Visitor<'de> for BytesOrStringVisitor { + type Value = Vec<u8>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a list of bytes or a string") + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> { + Ok(v.to_vec()) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> { + Ok(v) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> { + Ok(v.as_bytes().to_vec()) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> { + Ok(v.into_bytes()) + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + utils::SeqIter::new(seq).collect() + } + } +} + +/// Deserialize value and return [`Default`] on error +/// +/// The main use case is ignoring error while deserializing. +/// Instead of erroring, it simply deserializes the [`Default`] variant of the type. +/// It is not possible to find the error location, i.e., which field had a deserialization error, with this method. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed via [`DefaultOnError`] and using the [`serde_as`] macro. +/// It can be combined with other converts as shown. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, DefaultOnError, DisplayFromStr}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct A { +/// #[serde_as(as = "DefaultOnError")] +/// value: u32, +/// #[serde_as(as = "DefaultOnError<DisplayFromStr>")] +/// value2: u32, +/// } +/// # } +/// ``` +/// +/// [`DefaultOnError`]: crate::DefaultOnError +/// [`serde_as`]: crate::guide::serde_as +/// +/// # Examples +/// +/// ``` +/// # use serde::Deserialize; +/// # +/// #[derive(Deserialize)] +/// struct A { +/// #[serde(deserialize_with = "serde_with::rust::default_on_error::deserialize")] +/// value: u32, +/// } +/// +/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap(); +/// assert_eq!(123, a.value); +/// +/// // null is of invalid type +/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // String is of invalid type +/// let a: A = serde_json::from_str(r#"{"value": "123"}"#).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // Map is of invalid type +/// let a: A = serde_json::from_str(r#"{"value": {}}"#).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // Missing entries still cause errors +/// assert!(serde_json::from_str::<A>(r#"{ }"#).is_err()); +/// ``` +/// +/// Deserializing missing values can be supported by adding the `default` field attribute: +/// +/// ``` +/// # use serde::Deserialize; +/// # +/// #[derive(Deserialize)] +/// struct B { +/// #[serde(default, deserialize_with = "serde_with::rust::default_on_error::deserialize")] +/// value: u32, +/// } +/// +/// let b: B = serde_json::from_str(r#"{ }"#).unwrap(); +/// assert_eq!(0, b.value); +/// ``` +pub mod default_on_error { + use super::*; + + /// Deserialize T and return the [`Default`] value on error + pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: Deserialize<'de> + Default, + { + #[derive(Debug, serde::Deserialize)] + #[serde(untagged)] + enum GoodOrError<T> { + Good(T), + // This consumes one "item" when `T` errors while deserializing. + // This is necessary to make this work, when instead of having a direct value + // like integer or string, the deserializer sees a list or map. + Error(serde::de::IgnoredAny), + } + + Ok(match Deserialize::deserialize(deserializer) { + Ok(GoodOrError::Good(res)) => res, + _ => Default::default(), + }) + } + + /// Serialize value with the default serializer + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// Deserialize default value if encountering `null`. +/// +/// One use case are JSON APIs in which the `null` value represents some default state. +/// This adapter allows to turn the `null` directly into the [`Default`] value of the type. +/// +/// ## Converting to `serde_as` +/// +/// The same functionality can be more clearly expressed via [`DefaultOnNull`] and using the [`serde_as`] macro. +/// It can be combined with other convertes as shown. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, DefaultOnNull, DisplayFromStr}; +/// # +/// #[serde_as] +/// #[derive(Deserialize)] +/// struct A { +/// #[serde_as(as = "DefaultOnNull")] +/// value: u32, +/// #[serde_as(as = "DefaultOnNull<DisplayFromStr>")] +/// value2: u32, +/// } +/// # } +/// ``` +/// +/// [`DefaultOnNull`]: crate::DefaultOnNull +/// [`serde_as`]: crate::guide::serde_as +/// +/// # Examples +/// +/// ``` +/// # use serde::Deserialize; +/// # +/// #[derive(Deserialize)] +/// struct A { +/// #[serde(deserialize_with = "serde_with::rust::default_on_null::deserialize")] +/// value: u32, +/// } +/// +/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap(); +/// assert_eq!(123, a.value); +/// +/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap(); +/// assert_eq!(0, a.value); +/// +/// // String is invalid type +/// assert!(serde_json::from_str::<A>(r#"{"value": "123"}"#).is_err()); +/// ``` +pub mod default_on_null { + use super::*; + + /// Deserialize T and return the [`Default`] value if original value is `null` + pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + T: Deserialize<'de> + Default, + { + Ok(Option::deserialize(deserializer)?.unwrap_or_default()) + } + + /// Serialize value with the default serializer + pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + value.serialize(serializer) + } +} + +/// Deserialize any value, ignore it, and return the default value for the type being deserialized. +/// +/// This function can be used in two different ways: +/// +/// 1. It is useful for instance to create an enum with a catch-all variant that will accept any incoming data. +/// 2. [`untagged`] enum representations do not allow the `other` annotation as the fallback enum variant. +/// With this function you can emulate an `other` variant, which can deserialize any data carrying enum. +/// +/// **Note:** Using this function will prevent deserializing data-less enum variants. +/// If this is a problem depends on the data format. +/// For example, deserializing `"Bar"` as an enum in JSON would fail, since it carries no data. +/// +/// # Examples +/// +/// ## Deserializing a heterogeneous collection of XML nodes +/// +/// When [`serde-xml-rs`] deserializes an XML tag to an enum, it always maps the tag +/// name to the enum variant name, and the tag attributes and children to the enum contents. +/// This means that in order for an enum variant to accept any XML tag, it both has to use +/// `#[serde(other)]` to accept any tag name, and `#[serde(deserialize_with = "deserialize_ignore_any")]` +/// to accept any attributes and children. +/// +/// ```rust +/// # use serde::Deserialize; +/// use serde_with::rust::deserialize_ignore_any; +/// +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize)] +/// #[serde(rename_all = "lowercase")] +/// enum Item { +/// Foo(String), +/// Bar(String), +/// #[serde(other, deserialize_with = "deserialize_ignore_any")] +/// Other, +/// } +/// +/// // Deserialize this XML +/// # let items: Vec<Item> = serde_xml_rs::from_str( +/// r" +/// <foo>a</foo> +/// <bar>b</bar> +/// <foo>c</foo> +/// <unknown>d</unknown> +/// " +/// # ).unwrap(); +/// +/// // into these Items +/// # let expected = +/// vec![ +/// Item::Foo(String::from("a")), +/// Item::Bar(String::from("b")), +/// Item::Foo(String::from("c")), +/// Item::Other, +/// ] +/// # ; +/// # assert_eq!(expected, items); +/// ``` +/// +/// ## Simulating an `other` enum variant in an `untagged` enum +/// +/// ```rust +/// # use serde::Deserialize; +/// # use serde_json::json; +/// use serde_with::rust::deserialize_ignore_any; +/// +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize)] +/// #[serde(untagged)] +/// enum Item { +/// Foo{x: u8}, +/// #[serde(deserialize_with = "deserialize_ignore_any")] +/// Other, +/// } +/// +/// // Deserialize this JSON +/// # let items: Vec<Item> = serde_json::from_value( +/// json!([ +/// {"y": 1}, +/// {"x": 1}, +/// ]) +/// # ).unwrap(); +/// +/// // into these Items +/// # let expected = +/// vec![Item::Other, Item::Foo{x: 1}] +/// # ; +/// # assert_eq!(expected, items); +/// ``` +/// +/// [`serde-xml-rs`]: https://docs.rs/serde-xml-rs +/// [`untagged`]: https://serde.rs/enum-representations.html#untagged +pub fn deserialize_ignore_any<'de, D: Deserializer<'de>, T: Default>( + deserializer: D, +) -> Result<T, D::Error> { + serde::de::IgnoredAny::deserialize(deserializer).map(|_| T::default()) +} diff --git a/third_party/rust/serde_with/src/ser/const_arrays.rs b/third_party/rust/serde_with/src/ser/const_arrays.rs new file mode 100644 index 0000000000..b864f2b7e5 --- /dev/null +++ b/third_party/rust/serde_with/src/ser/const_arrays.rs @@ -0,0 +1,90 @@ +use super::*; +use alloc::{borrow::Cow, boxed::Box, collections::BTreeMap}; +use std::collections::HashMap; + +impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N] +where + As: SerializeAs<T>, +{ + fn serialize_as<S>(array: &[T; N], serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + use serde::ser::SerializeTuple; + let mut arr = serializer.serialize_tuple(N)?; + for elem in array { + arr.serialize_element(&SerializeAsWrap::<T, As>::new(elem))?; + } + arr.end() + } +} + +macro_rules! tuple_seq_as_map_impl_intern { + ($tyorig:ty, $ty:ident <K, V>) => { + #[allow(clippy::implicit_hasher)] + impl<K, KAs, V, VAs, const N: usize> SerializeAs<$tyorig> for $ty<KAs, VAs> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + { + fn serialize_as<S>(source: &$tyorig, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_map(source.iter().map(|(k, v)| { + ( + SerializeAsWrap::<K, KAs>::new(k), + SerializeAsWrap::<V, VAs>::new(v), + ) + })) + } + } + }; +} +tuple_seq_as_map_impl_intern!([(K, V); N], BTreeMap<K, V>); +tuple_seq_as_map_impl_intern!([(K, V); N], HashMap<K, V>); + +impl<const N: usize> SerializeAs<[u8; N]> for Bytes { + fn serialize_as<S>(bytes: &[u8; N], serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(bytes) + } +} + +impl<const N: usize> SerializeAs<&[u8; N]> for Bytes { + fn serialize_as<S>(bytes: &&[u8; N], serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(*bytes) + } +} + +impl<const N: usize> SerializeAs<Box<[u8; N]>> for Bytes { + fn serialize_as<S>(bytes: &Box<[u8; N]>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(&**bytes) + } +} + +impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for Bytes { + fn serialize_as<S>(bytes: &Cow<'a, [u8; N]>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(bytes.as_ref()) + } +} + +impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for BorrowCow { + fn serialize_as<S>(value: &Cow<'a, [u8; N]>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_seq(value.iter()) + } +} diff --git a/third_party/rust/serde_with/src/ser/impls.rs b/third_party/rust/serde_with/src/ser/impls.rs new file mode 100644 index 0000000000..16a8fb913c --- /dev/null +++ b/third_party/rust/serde_with/src/ser/impls.rs @@ -0,0 +1,739 @@ +use super::*; +use crate::{ + formats::Strictness, rust::StringWithSeparator, utils::duration::DurationSigned, Separator, +}; +use alloc::{ + borrow::Cow, + boxed::Box, + collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque}, + rc::{Rc, Weak as RcWeak}, + string::{String, ToString}, + sync::{Arc, Weak as ArcWeak}, + vec::Vec, +}; +use core::{ + cell::{Cell, RefCell}, + convert::TryInto, + fmt::Display, + time::Duration, +}; +#[cfg(feature = "indexmap")] +use indexmap_crate::{IndexMap, IndexSet}; +use serde::ser::Error; +use std::{ + collections::{HashMap, HashSet}, + sync::{Mutex, RwLock}, + time::SystemTime, +}; + +/////////////////////////////////////////////////////////////////////////////// +// region: Simple Wrapper types (e.g., Box, Option) + +impl<'a, T, U> SerializeAs<&'a T> for &'a U +where + U: SerializeAs<T>, + T: ?Sized, + U: ?Sized, +{ + fn serialize_as<S>(source: &&'a T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, U>::new(source).serialize(serializer) + } +} + +impl<'a, T, U> SerializeAs<&'a mut T> for &'a mut U +where + U: SerializeAs<T>, + T: ?Sized, + U: ?Sized, +{ + fn serialize_as<S>(source: &&'a mut T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, U>::new(source).serialize(serializer) + } +} + +impl<T, U> SerializeAs<Box<T>> for Box<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, U>::new(source).serialize(serializer) + } +} + +impl<T, U> SerializeAs<Option<T>> for Option<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + match *source { + Some(ref value) => serializer.serialize_some(&SerializeAsWrap::<T, U>::new(value)), + None => serializer.serialize_none(), + } + } +} + +impl<T, U> SerializeAs<Rc<T>> for Rc<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Rc<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, U>::new(source).serialize(serializer) + } +} + +impl<T, U> SerializeAs<RcWeak<T>> for RcWeak<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &RcWeak<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<Option<Rc<T>>, Option<Rc<U>>>::new(&source.upgrade()) + .serialize(serializer) + } +} + +impl<T, U> SerializeAs<Arc<T>> for Arc<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Arc<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, U>::new(source).serialize(serializer) + } +} + +impl<T, U> SerializeAs<ArcWeak<T>> for ArcWeak<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &ArcWeak<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<Option<Arc<T>>, Option<Arc<U>>>::new(&source.upgrade()) + .serialize(serializer) + } +} + +impl<T, U> SerializeAs<Cell<T>> for Cell<U> +where + U: SerializeAs<T>, + T: Copy, +{ + fn serialize_as<S>(source: &Cell<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, U>::new(&source.get()).serialize(serializer) + } +} + +impl<T, U> SerializeAs<RefCell<T>> for RefCell<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &RefCell<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + match source.try_borrow() { + Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer), + Err(_) => Err(S::Error::custom("already mutably borrowed")), + } + } +} + +impl<T, U> SerializeAs<Mutex<T>> for Mutex<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Mutex<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + match source.lock() { + Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer), + Err(_) => Err(S::Error::custom("lock poison error while serializing")), + } + } +} + +impl<T, U> SerializeAs<RwLock<T>> for RwLock<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &RwLock<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + match source.read() { + Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer), + Err(_) => Err(S::Error::custom("lock poison error while serializing")), + } + } +} + +impl<T, TAs, E, EAs> SerializeAs<Result<T, E>> for Result<TAs, EAs> +where + TAs: SerializeAs<T>, + EAs: SerializeAs<E>, +{ + fn serialize_as<S>(source: &Result<T, E>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source + .as_ref() + .map(SerializeAsWrap::<T, TAs>::new) + .map_err(SerializeAsWrap::<E, EAs>::new) + .serialize(serializer) + } +} + +// endregion +/////////////////////////////////////////////////////////////////////////////// +// region: Collection Types (e.g., Maps, Sets, Vec) + +macro_rules! seq_impl { + ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident )* >) => { + impl<T, U $(, $typaram)*> SerializeAs<$ty<T $(, $typaram)*>> for $ty<U $(, $typaram)*> + where + U: SerializeAs<T>, + $(T: ?Sized + $tbound1 $(+ $tbound2)*,)* + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(source: &$ty<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_seq(source.iter().map(|item| SerializeAsWrap::<T, U>::new(item))) + } + } + } +} + +type BoxedSlice<T> = Box<[T]>; +type Slice<T> = [T]; +seq_impl!(BinaryHeap<T>); +seq_impl!(BoxedSlice<T>); +seq_impl!(BTreeSet<T>); +seq_impl!(HashSet<T, H: Sized>); +seq_impl!(LinkedList<T>); +seq_impl!(Slice<T>); +seq_impl!(Vec<T>); +seq_impl!(VecDeque<T>); +#[cfg(feature = "indexmap")] +seq_impl!(IndexSet<T, H: Sized>); + +macro_rules! map_impl { + ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => { + impl<K, KU, V, VU $(, $typaram)*> SerializeAs<$ty<K, V $(, $typaram)*>> for $ty<KU, VU $(, $typaram)*> + where + KU: SerializeAs<K>, + VU: SerializeAs<V>, + $(K: ?Sized + $kbound1 $(+ $kbound2)*,)* + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(source: &$ty<K, V $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_map(source.iter().map(|(k, v)| (SerializeAsWrap::<K, KU>::new(k), SerializeAsWrap::<V, VU>::new(v)))) + } + } + } +} + +map_impl!(BTreeMap<K, V>); +map_impl!(HashMap<K, V, H: Sized>); +#[cfg(feature = "indexmap")] +map_impl!(IndexMap<K, V, H: Sized>); + +macro_rules! tuple_impl { + ($len:literal $($n:tt $t:ident $tas:ident)+) => { + impl<$($t, $tas,)+> SerializeAs<($($t,)+)> for ($($tas,)+) + where + $($tas: SerializeAs<$t>,)+ + { + fn serialize_as<S>(tuple: &($($t,)+), serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + use serde::ser::SerializeTuple; + let mut tup = serializer.serialize_tuple($len)?; + $( + tup.serialize_element(&SerializeAsWrap::<$t, $tas>::new(&tuple.$n))?; + )+ + tup.end() + } + } + }; +} + +tuple_impl!(1 0 T0 As0); +tuple_impl!(2 0 T0 As0 1 T1 As1); +tuple_impl!(3 0 T0 As0 1 T1 As1 2 T2 As2); +tuple_impl!(4 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3); +tuple_impl!(5 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4); +tuple_impl!(6 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5); +tuple_impl!(7 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6); +tuple_impl!(8 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7); +tuple_impl!(9 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8); +tuple_impl!(10 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9); +tuple_impl!(11 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10); +tuple_impl!(12 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11); +tuple_impl!(13 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12); +tuple_impl!(14 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13); +tuple_impl!(15 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14); +tuple_impl!(16 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14 15 T15 As15); + +macro_rules! map_as_tuple_seq { + ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V >) => { + impl<K, KAs, V, VAs> SerializeAs<$ty<K, V>> for Vec<(KAs, VAs)> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + { + fn serialize_as<S>(source: &$ty<K, V>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_seq(source.iter().map(|(k, v)| { + ( + SerializeAsWrap::<K, KAs>::new(k), + SerializeAsWrap::<V, VAs>::new(v), + ) + })) + } + } + }; +} +map_as_tuple_seq!(BTreeMap<K, V>); +// TODO HashMap with a custom hasher support would be better, but results in "unconstrained type parameter" +map_as_tuple_seq!(HashMap<K, V>); +#[cfg(feature = "indexmap")] +map_as_tuple_seq!(IndexMap<K, V>); + +// endregion +/////////////////////////////////////////////////////////////////////////////// +// region: Conversion types which cause different serialization behavior + +impl<T> SerializeAs<T> for Same +where + T: Serialize + ?Sized, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source.serialize(serializer) + } +} + +impl<T> SerializeAs<T> for DisplayFromStr +where + T: Display, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + crate::rust::display_fromstr::serialize(source, serializer) + } +} + +impl<T, U> SerializeAs<Vec<T>> for VecSkipError<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + Vec::<U>::serialize_as(source, serializer) + } +} + +impl<AsRefStr> SerializeAs<Option<AsRefStr>> for NoneAsEmptyString +where + AsRefStr: AsRef<str>, +{ + fn serialize_as<S>(source: &Option<AsRefStr>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + crate::rust::string_empty_as_none::serialize(source, serializer) + } +} + +macro_rules! tuple_seq_as_map_impl_intern { + ($tyorig:ty, $ty:ident <K, V>) => { + #[allow(clippy::implicit_hasher)] + impl<K, KAs, V, VAs> SerializeAs<$tyorig> for $ty<KAs, VAs> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + { + fn serialize_as<S>(source: &$tyorig, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_map(source.iter().map(|(k, v)| { + ( + SerializeAsWrap::<K, KAs>::new(k), + SerializeAsWrap::<V, VAs>::new(v), + ) + })) + } + } + }; +} +macro_rules! tuple_seq_as_map_impl { + ($($ty:ty $(,)?)+) => {$( + tuple_seq_as_map_impl_intern!($ty, BTreeMap<K, V>); + tuple_seq_as_map_impl_intern!($ty, HashMap<K, V>); + )+} +} + +tuple_seq_as_map_impl! { + BinaryHeap<(K, V)>, + BTreeSet<(K, V)>, + LinkedList<(K, V)>, + Option<(K, V)>, + Vec<(K, V)>, + VecDeque<(K, V)>, +} +tuple_seq_as_map_impl!(HashSet<(K, V)>); +#[cfg(feature = "indexmap")] +tuple_seq_as_map_impl!(IndexSet<(K, V)>); + +impl<T, TAs> SerializeAs<T> for DefaultOnError<TAs> +where + TAs: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + TAs::serialize_as(source, serializer) + } +} + +impl SerializeAs<Vec<u8>> for BytesOrString { + fn serialize_as<S>(source: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source.serialize(serializer) + } +} + +impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T> +where + SEPARATOR: Separator, + for<'a> &'a I: IntoIterator<Item = &'a T>, + T: ToString, +{ + fn serialize_as<S>(source: &I, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut s = String::new(); + for v in source { + s.push_str(&*v.to_string()); + s.push_str(SEPARATOR::separator()); + } + serializer.serialize_str(if !s.is_empty() { + // remove trailing separator if present + &s[..s.len() - SEPARATOR::separator().len()] + } else { + &s[..] + }) + } +} + +macro_rules! use_signed_duration { + ( + $main_trait:ident $internal_trait:ident => + { + $ty:ty => + $({ + $format:ty, $strictness:ty => + $($tbound:ident: $bound:ident $(,)?)* + })* + } + ) => { + $( + impl<$($tbound,)*> SerializeAs<$ty> for $main_trait<$format, $strictness> + where + $($tbound: $bound,)* + { + fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + $internal_trait::<$format, $strictness>::serialize_as( + &DurationSigned::from(source), + serializer, + ) + } + } + )* + }; + ( + $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt + ) => { + $( use_signed_duration!($main_trait $internal_trait => $rest); )+ + }; +} + +use_signed_duration!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration => + {u64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_signed_duration!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +use_signed_duration!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + SystemTime => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_signed_duration!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + SystemTime => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +impl<T, U> SerializeAs<T> for DefaultOnNull<U> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_some(&SerializeAsWrap::<T, U>::new(source)) + } +} + +impl SerializeAs<&[u8]> for Bytes { + fn serialize_as<S>(bytes: &&[u8], serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(bytes) + } +} + +impl SerializeAs<Vec<u8>> for Bytes { + fn serialize_as<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(bytes) + } +} + +impl SerializeAs<Box<[u8]>> for Bytes { + fn serialize_as<S>(bytes: &Box<[u8]>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(bytes) + } +} + +impl<'a> SerializeAs<Cow<'a, [u8]>> for Bytes { + fn serialize_as<S>(bytes: &Cow<'a, [u8]>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_bytes(bytes) + } +} + +impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, formats::PreferOne> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + match source.len() { + 1 => SerializeAsWrap::<T, U>::new(source.iter().next().expect("Cannot be empty")) + .serialize(serializer), + _ => SerializeAsWrap::<Vec<T>, Vec<U>>::new(source).serialize(serializer), + } + } +} + +impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, formats::PreferMany> +where + U: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<Vec<T>, Vec<U>>::new(source).serialize(serializer) + } +} + +impl<T, TAs1> SerializeAs<T> for PickFirst<(TAs1,)> +where + TAs1: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer) + } +} + +impl<T, TAs1, TAs2> SerializeAs<T> for PickFirst<(TAs1, TAs2)> +where + TAs1: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer) + } +} + +impl<T, TAs1, TAs2, TAs3> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3)> +where + TAs1: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer) + } +} + +impl<T, TAs1, TAs2, TAs3, TAs4> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3, TAs4)> +where + TAs1: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer) + } +} + +impl<T, U> SerializeAs<T> for FromInto<U> +where + T: Into<U> + Clone, + U: Serialize, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source.clone().into().serialize(serializer) + } +} + +impl<T, U> SerializeAs<T> for TryFromInto<U> +where + T: TryInto<U> + Clone, + <T as TryInto<U>>::Error: Display, + U: Serialize, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source + .clone() + .try_into() + .map_err(S::Error::custom)? + .serialize(serializer) + } +} + +impl<'a> SerializeAs<Cow<'a, str>> for BorrowCow { + fn serialize_as<S>(source: &Cow<'a, str>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_str(source) + } +} + +impl<'a> SerializeAs<Cow<'a, [u8]>> for BorrowCow { + fn serialize_as<S>(value: &Cow<'a, [u8]>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.collect_seq(value.iter()) + } +} + +impl<STRICTNESS: Strictness> SerializeAs<bool> for BoolFromInt<STRICTNESS> { + fn serialize_as<S>(source: &bool, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_u8(*source as u8) + } +} + +// endregion diff --git a/third_party/rust/serde_with/src/ser/legacy_arrays.rs b/third_party/rust/serde_with/src/ser/legacy_arrays.rs new file mode 100644 index 0000000000..2c228ee640 --- /dev/null +++ b/third_party/rust/serde_with/src/ser/legacy_arrays.rs @@ -0,0 +1,34 @@ +use super::*; +use alloc::collections::BTreeMap; +use std::collections::HashMap; + +macro_rules! array_impl { + ($($len:literal)+) => {$( + impl<T, As> SerializeAs<[T; $len]> for [As; $len] + where + As: SerializeAs<T>, + { + fn serialize_as<S>(array: &[T; $len], serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + use serde::ser::SerializeTuple; + let mut arr = serializer.serialize_tuple($len)?; + for elem in array { + arr.serialize_element(&SerializeAsWrap::<T, As>::new(elem))?; + } + arr.end() + } + } + )+}; +} + +array_impl!(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32); + +tuple_seq_as_map_impl! { + [(K, V); 0], [(K, V); 1], [(K, V); 2], [(K, V); 3], [(K, V); 4], [(K, V); 5], [(K, V); 6], + [(K, V); 7], [(K, V); 8], [(K, V); 9], [(K, V); 10], [(K, V); 11], [(K, V); 12], [(K, V); 13], + [(K, V); 14], [(K, V); 15], [(K, V); 16], [(K, V); 17], [(K, V); 18], [(K, V); 19], [(K, V); 20], + [(K, V); 21], [(K, V); 22], [(K, V); 23], [(K, V); 24], [(K, V); 25], [(K, V); 26], [(K, V); 27], + [(K, V); 28], [(K, V); 29], [(K, V); 30], [(K, V); 31], [(K, V); 32], +} diff --git a/third_party/rust/serde_with/src/ser/mod.rs b/third_party/rust/serde_with/src/ser/mod.rs new file mode 100644 index 0000000000..dda0891e89 --- /dev/null +++ b/third_party/rust/serde_with/src/ser/mod.rs @@ -0,0 +1,158 @@ +//! Module for [`SerializeAs`][] implementations +//! +//! The module contains the [`SerializeAs`][] trait and helper code. +//! Additionally, it contains implementations of [`SerializeAs`][] for types defined in the Rust Standard Library or this crate. +//! +//! You can find more details on how to implement this trait for your types in the documentation of the [`SerializeAs`][] trait and details about the usage in the [user guide][]. +//! +//! [user guide]: crate::guide + +mod const_arrays; +#[macro_use] +mod impls; + +use super::*; + +/// A **data structure** that can be serialized into any data format supported by Serde, analogue to [`Serialize`]. +/// +/// The trait is analogue to the [`serde::Serialize`][`Serialize`] trait, with the same meaning of input and output arguments. +/// It can and should the implemented using the same code structure as the [`Serialize`] trait. +/// As such, the same advice for [implementing `Serialize`][impl-serialize] applies here. +/// +/// # Differences to [`Serialize`] +/// +/// The trait is only required for container-like types or types implementing specific conversion functions. +/// Container-like types are [`Vec`], [`BTreeMap`], but also [`Option`] and [`Box`]. +/// Conversion types serialize into a different serde data type. +/// For example, [`DisplayFromStr`] uses the [`Display`] trait to serialize a String and [`DurationSeconds`] converts a [`Duration`] into either String or integer values. +/// +/// This code shows how to implement [`Serialize`] for [`Box`]: +/// +/// ```rust,ignore +/// impl<T> Serialize for Box<T> +/// where +/// T: Serialize, +/// { +/// #[inline] +/// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> +/// where +/// S: Serializer, +/// { +/// (**self).serialize(serializer) +/// } +/// } +/// ``` +/// +/// and this code shows how to do the same using [`SerializeAs`][]: +/// +/// ```rust,ignore +/// impl<T, U> SerializeAs<Box<T>> for Box<U> +/// where +/// U: SerializeAs<T>, +/// { +/// fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error> +/// where +/// S: Serializer, +/// { +/// SerializeAsWrap::<T, U>::new(source).serialize(serializer) +/// } +/// } +/// ``` +/// +/// It uses two type parameters, `T` and `U` instead of only one and performs the serialization step using the `SerializeAsWrap` type. +/// The `T` type is the on the Rust side before serialization, whereas the `U` type determines how the value will be serialized. +/// These two changes are usually enough to make a container type implement [`SerializeAs`][]. +/// +/// [`SerializeAsWrap`] is a piece of glue code which turns [`SerializeAs`] into a serde compatible datatype, by converting all calls to `serialize` into `serialize_as`. +/// This allows us to implement [`SerializeAs`] such that it can be applied recursively throughout the whole data structure. +/// This is mostly important for container types, such as `Vec` or `BTreeMap`. +/// In a `BTreeMap` this allows us to specify two different serialization behaviors, one for key and one for value, using the [`SerializeAs`] trait. +/// +/// ## Implementing a converter Type +/// +/// This shows a simplified implementation for [`DisplayFromStr`]. +/// +/// ```rust +/// # #[cfg(all(feature = "macros"))] { +/// # use serde_with::SerializeAs; +/// # use std::fmt::Display; +/// struct DisplayFromStr; +/// +/// impl<T> SerializeAs<T> for DisplayFromStr +/// where +/// T: Display, +/// { +/// fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> +/// where +/// S: serde::Serializer, +/// { +/// serializer.collect_str(&source) +/// } +/// } +/// # +/// # #[serde_with::serde_as] +/// # #[derive(serde::Serialize)] +/// # struct S (#[serde_as(as = "DisplayFromStr")] bool); +/// # +/// # assert_eq!(r#""false""#, serde_json::to_string(&S(false)).unwrap()); +/// # } +/// ``` +/// +/// [`Box`]: std::boxed::Box +/// [`BTreeMap`]: std::collections::BTreeMap +/// [`Display`]: std::fmt::Display +/// [`Duration`]: std::time::Duration +/// [`Vec`]: std::vec::Vec +/// [impl-serialize]: https://serde.rs/impl-serialize.html +pub trait SerializeAs<T: ?Sized> { + /// Serialize this value into the given Serde serializer. + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer; +} + +/// Helper type to implement [`SerializeAs`] for container-like types. +#[derive(Debug)] +pub struct SerializeAsWrap<'a, T: ?Sized, U: ?Sized> { + value: &'a T, + marker: PhantomData<U>, +} + +impl<'a, T, U> SerializeAsWrap<'a, T, U> +where + T: ?Sized, + U: ?Sized, +{ + /// Create new instance with provided value. + pub fn new(value: &'a T) -> Self { + Self { + value, + marker: PhantomData, + } + } +} + +impl<'a, T, U> Serialize for SerializeAsWrap<'a, T, U> +where + T: ?Sized, + U: ?Sized, + U: SerializeAs<T>, +{ + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + U::serialize_as(self.value, serializer) + } +} + +impl<'a, T, U> From<&'a T> for SerializeAsWrap<'a, T, U> +where + T: ?Sized, + U: ?Sized, + U: SerializeAs<T>, +{ + fn from(value: &'a T) -> Self { + Self::new(value) + } +} diff --git a/third_party/rust/serde_with/src/serde_conv.rs b/third_party/rust/serde_with/src/serde_conv.rs new file mode 100644 index 0000000000..c5659ebfda --- /dev/null +++ b/third_party/rust/serde_with/src/serde_conv.rs @@ -0,0 +1,147 @@ +/// Create new conversion adapters from functions +/// +/// The macro lets you create a new converter, which is usable for serde's with-attribute and `#[serde_as]`. +/// Its main use case is to write simple converters for types, which are not serializable. +/// Another use-case is to change the serialization behavior if the implemented `Serialize`/`Deserialize` trait is insufficient. +/// +/// The macro takes four arguments: +/// +/// 1. The name of the converter type. +/// The type can be prefixed with a visibility modifies like `pub` or `pub(crate)`. +/// By default, the type is not marked as public (`pub(self)`). +/// 2. The type `T` we want to extend with custom behavior. +/// 3. A function or macro taking a `&T` and returning a serializable type. +/// 4. A function or macro taking a deserializable type and returning a `Result<T, E>`. +/// The error type `E` must implement `Display`. +/// +/// # Example +/// +/// In this example, we write custom serialization behavior for a `Rgb` type. +/// We want to serialize it as a `[u8; 3]`. +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Serialize, Deserialize}; +/// +/// #[derive(Clone, Copy, Debug, PartialEq)] +/// struct Rgb { +/// red: u8, +/// green: u8, +/// blue: u8, +/// } +/// +/// serde_with::serde_conv!( +/// RgbAsArray, +/// Rgb, +/// |rgb: &Rgb| [rgb.red, rgb.green, rgb.blue], +/// |value: [u8; 3]| -> Result<_, std::convert::Infallible> { +/// Ok(Rgb { +/// red: value[0], +/// green: value[1], +/// blue: value[2], +/// }) +/// } +/// ); +/// +/// ////////////////////////////////////////////////// +/// +/// // We define some colors to be used later +/// +/// let green = Rgb {red: 0, green: 255, blue: 0}; +/// let orange = Rgb {red: 255, green: 128, blue: 0}; +/// let pink = Rgb {red: 255, green: 0, blue: 255}; +/// +/// ////////////////////////////////////////////////// +/// +/// // We can now use the `RgbAsArray` adapter with `serde_as`. +/// +/// #[serde_with::serde_as] +/// #[derive(Debug, PartialEq, Serialize, Deserialize)] +/// struct Colors { +/// #[serde_as(as = "RgbAsArray")] +/// one_rgb: Rgb, +/// #[serde_as(as = "Vec<RgbAsArray>")] +/// rgbs_in_vec: Vec<Rgb>, +/// } +/// +/// let data = Colors { +/// one_rgb: orange, +/// rgbs_in_vec: vec![green, pink], +/// }; +/// let json = serde_json::json!({ +/// "one_rgb": [255, 128, 0], +/// "rgbs_in_vec": [ +/// [0, 255, 0], +/// [255, 0, 255] +/// ] +/// }); +/// +/// assert_eq!(json, serde_json::to_value(&data).unwrap()); +/// assert_eq!(data, serde_json::from_value(json).unwrap()); +/// +/// ////////////////////////////////////////////////// +/// +/// // The types generated by `serde_conv` is also compatible with serde's with attribute +/// +/// #[derive(Debug, PartialEq, Serialize, Deserialize)] +/// struct ColorsWith { +/// #[serde(with = "RgbAsArray")] +/// rgb_with: Rgb, +/// } +/// +/// let data = ColorsWith { +/// rgb_with: pink, +/// }; +/// let json = serde_json::json!({ +/// "rgb_with": [255, 0, 255] +/// }); +/// +/// assert_eq!(json, serde_json::to_value(&data).unwrap()); +/// assert_eq!(data, serde_json::from_value(json).unwrap()); +/// # } +/// ``` +#[macro_export] +macro_rules! serde_conv { + ($m:ident, $t:ty, $ser:expr, $de:expr) => {$crate::serde_conv!(pub(self) $m, $t, $ser, $de);}; + ($vis:vis $m:ident, $t:ty, $ser:expr, $de:expr) => { + #[allow(non_camel_case_types)] + $vis struct $m; + + #[allow(clippy::ptr_arg)] + impl $m { + $vis fn serialize<S>(x: &$t, serializer: S) -> ::std::result::Result<S::Ok, S::Error> + where + S: $crate::serde::Serializer, + { + let y = $ser(x); + $crate::serde::Serialize::serialize(&y, serializer) + } + + $vis fn deserialize<'de, D>(deserializer: D) -> ::std::result::Result<$t, D::Error> + where + D: $crate::serde::Deserializer<'de>, + { + let y = $crate::serde::Deserialize::deserialize(deserializer)?; + $de(y).map_err($crate::serde::de::Error::custom) + } + } + + impl $crate::SerializeAs<$t> for $m { + fn serialize_as<S>(x: &$t, serializer: S) -> ::std::result::Result<S::Ok, S::Error> + where + S: $crate::serde::Serializer, + { + Self::serialize(x, serializer) + } + } + + impl<'de> $crate::DeserializeAs<'de, $t> for $m { + fn deserialize_as<D>(deserializer: D) -> ::std::result::Result<$t, D::Error> + where + D: $crate::serde::Deserializer<'de>, + { + Self::deserialize(deserializer) + } + } + }; +} diff --git a/third_party/rust/serde_with/src/time_0_3.rs b/third_party/rust/serde_with/src/time_0_3.rs new file mode 100644 index 0000000000..76dca006d2 --- /dev/null +++ b/third_party/rust/serde_with/src/time_0_3.rs @@ -0,0 +1,382 @@ +//! De/Serialization of [time v0.3][time] types +//! +//! This modules is only available if using the `time_0_3` feature of the crate. +//! +//! [time]: https://docs.rs/time/0.3/ + +use crate::{ + de::DeserializeAs, + formats::{Flexible, Format, Strict, Strictness}, + ser::SerializeAs, + utils::duration::{DurationSigned, Sign}, + DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds, + DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac, + DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds, TimestampMicroSecondsWithFrac, + TimestampMilliSeconds, TimestampMilliSecondsWithFrac, TimestampNanoSeconds, + TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac, +}; +use alloc::{format, string::String}; +use serde::{de, ser::Error as _, Deserializer, Serialize, Serializer}; +use std::{convert::TryInto, fmt, time::Duration as StdDuration}; +use time_0_3::{ + format_description::well_known::{Rfc2822, Rfc3339}, + Duration, OffsetDateTime, PrimitiveDateTime, +}; + +/// Create a [`PrimitiveDateTime`] for the Unix Epoch +fn unix_epoch_primitive() -> PrimitiveDateTime { + PrimitiveDateTime::new( + time_0_3::Date::from_ordinal_date(1970, 1).unwrap(), + time_0_3::Time::from_hms_nano(0, 0, 0, 0).unwrap(), + ) +} + +/// Convert a [`time::Duration`][time_0_3::Duration] into a [`DurationSigned`] +fn duration_into_duration_signed(dur: &Duration) -> DurationSigned { + let std_dur = StdDuration::new( + dur.whole_seconds().unsigned_abs(), + dur.subsec_nanoseconds().unsigned_abs(), + ); + + DurationSigned::with_duration( + // A duration of 0 is not positive, so check for negative value. + if dur.is_negative() { + Sign::Negative + } else { + Sign::Positive + }, + std_dur, + ) +} + +/// Convert a [`DurationSigned`] into a [`time_0_3::Duration`] +fn duration_from_duration_signed<'de, D>(sdur: DurationSigned) -> Result<Duration, D::Error> +where + D: Deserializer<'de>, +{ + let mut dur: Duration = match sdur.duration.try_into() { + Ok(dur) => dur, + Err(msg) => { + return Err(de::Error::custom(format!( + "Duration is outside of the representable range: {}", + msg + ))) + } + }; + if sdur.sign.is_negative() { + dur = -dur; + } + Ok(dur) +} + +macro_rules! use_duration_signed_ser { + ( + $main_trait:ident $internal_trait:ident => + { + $ty:ty; $converter:ident => + $({ + $format:ty, $strictness:ty => + $($tbound:ident: $bound:ident $(,)?)* + })* + } + ) => { + $( + impl<$($tbound ,)*> SerializeAs<$ty> for $main_trait<$format, $strictness> + where + $($tbound: $bound,)* + { + fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let dur: DurationSigned = $converter(source); + $internal_trait::<$format, $strictness>::serialize_as( + &dur, + serializer, + ) + } + } + )* + }; + ( + $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt + ) => { + $( use_duration_signed_ser!($main_trait $internal_trait => $rest); )+ + }; +} + +fn offset_datetime_to_duration(source: &OffsetDateTime) -> DurationSigned { + duration_into_duration_signed(&(*source - OffsetDateTime::UNIX_EPOCH)) +} + +fn primitive_datetime_to_duration(source: &PrimitiveDateTime) -> DurationSigned { + duration_into_duration_signed(&(*source - unix_epoch_primitive())) +} + +use_duration_signed_ser!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_into_duration_signed => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; offset_datetime_to_duration => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +// Duration/Timestamp WITH FRACTIONS +use_duration_signed_ser!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_into_duration_signed => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; offset_datetime_to_duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +macro_rules! use_duration_signed_de { + ( + $main_trait:ident $internal_trait:ident => + { + $ty:ty; $converter:ident => + $({ + $format:ty, $strictness:ty => + $($tbound:ident: $bound:ident)* + })* + } + ) =>{ + $( + impl<'de, $($tbound,)*> DeserializeAs<'de, $ty> for $main_trait<$format, $strictness> + where + $($tbound: $bound,)* + { + fn deserialize_as<D>(deserializer: D) -> Result<$ty, D::Error> + where + D: Deserializer<'de>, + { + let dur: DurationSigned = $internal_trait::<$format, $strictness>::deserialize_as(deserializer)?; + $converter::<D>(dur) + } + } + )* + }; + ( + $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt + ) => { + $( use_duration_signed_de!($main_trait $internal_trait => $rest); )+ + }; +} + +fn duration_to_offset_datetime<'de, D>(dur: DurationSigned) -> Result<OffsetDateTime, D::Error> +where + D: Deserializer<'de>, +{ + Ok(OffsetDateTime::UNIX_EPOCH + duration_from_duration_signed::<D>(dur)?) +} + +fn duration_to_primitive_datetime<'de, D>( + dur: DurationSigned, +) -> Result<PrimitiveDateTime, D::Error> +where + D: Deserializer<'de>, +{ + Ok(unix_epoch_primitive() + duration_from_duration_signed::<D>(dur)?) +} + +// No subsecond precision +use_duration_signed_de!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_from_duration_signed => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; duration_to_offset_datetime => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {i64, Strict =>} + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); + +// Duration/Timestamp WITH FRACTIONS +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_from_duration_signed => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; duration_to_offset_datetime => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); + +impl SerializeAs<OffsetDateTime> for Rfc2822 { + fn serialize_as<S>(datetime: &OffsetDateTime, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + datetime + .format(&Rfc2822) + .map_err(S::Error::custom)? + .serialize(serializer) + } +} + +impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc2822 { + fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error> + where + D: Deserializer<'de>, + { + struct Visitor; + impl<'de> de::Visitor<'de> for Visitor { + type Value = OffsetDateTime; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a RFC2822-formatted `OffsetDateTime`") + } + + fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> { + Self::Value::parse(value, &Rfc2822).map_err(E::custom) + } + } + + deserializer.deserialize_str(Visitor) + } +} + +impl SerializeAs<OffsetDateTime> for Rfc3339 { + fn serialize_as<S>(datetime: &OffsetDateTime, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + datetime + .format(&Rfc3339) + .map_err(S::Error::custom)? + .serialize(serializer) + } +} + +impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc3339 { + fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error> + where + D: Deserializer<'de>, + { + struct Visitor; + impl<'de> de::Visitor<'de> for Visitor { + type Value = OffsetDateTime; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a RFC3339-formatted `OffsetDateTime`") + } + + fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> { + Self::Value::parse(value, &Rfc3339).map_err(E::custom) + } + } + + deserializer.deserialize_str(Visitor) + } +} diff --git a/third_party/rust/serde_with/src/utils.rs b/third_party/rust/serde_with/src/utils.rs new file mode 100644 index 0000000000..ccf99128e4 --- /dev/null +++ b/third_party/rust/serde_with/src/utils.rs @@ -0,0 +1,120 @@ +pub(crate) mod duration; + +use alloc::string::String; +use core::marker::PhantomData; +use serde::de::{Deserialize, MapAccess, SeqAccess}; + +/// Re-Implementation of `serde::private::de::size_hint::cautious` +#[inline] +pub(crate) fn size_hint_cautious(hint: Option<usize>) -> usize { + core::cmp::min(hint.unwrap_or(0), 4096) +} + +pub(crate) const NANOS_PER_SEC: u32 = 1_000_000_000; +// pub(crate) const NANOS_PER_MILLI: u32 = 1_000_000; +// pub(crate) const NANOS_PER_MICRO: u32 = 1_000; +// pub(crate) const MILLIS_PER_SEC: u64 = 1_000; +// pub(crate) const MICROS_PER_SEC: u64 = 1_000_000; + +pub(crate) struct MapIter<'de, A, K, V> { + pub(crate) access: A, + marker: PhantomData<(&'de (), K, V)>, +} + +impl<'de, A, K, V> MapIter<'de, A, K, V> { + pub(crate) fn new(access: A) -> Self + where + A: MapAccess<'de>, + { + Self { + access, + marker: PhantomData, + } + } +} + +impl<'de, A, K, V> Iterator for MapIter<'de, A, K, V> +where + A: MapAccess<'de>, + K: Deserialize<'de>, + V: Deserialize<'de>, +{ + type Item = Result<(K, V), A::Error>; + + fn next(&mut self) -> Option<Self::Item> { + self.access.next_entry().transpose() + } + + fn size_hint(&self) -> (usize, Option<usize>) { + match self.access.size_hint() { + Some(size) => (size, Some(size)), + None => (0, None), + } + } +} + +pub(crate) struct SeqIter<'de, A, T> { + access: A, + marker: PhantomData<(&'de (), T)>, +} + +impl<'de, A, T> SeqIter<'de, A, T> { + pub(crate) fn new(access: A) -> Self + where + A: SeqAccess<'de>, + { + Self { + access, + marker: PhantomData, + } + } +} + +impl<'de, A, T> Iterator for SeqIter<'de, A, T> +where + A: SeqAccess<'de>, + T: Deserialize<'de>, +{ + type Item = Result<T, A::Error>; + + fn next(&mut self) -> Option<Self::Item> { + self.access.next_element().transpose() + } + + fn size_hint(&self) -> (usize, Option<usize>) { + match self.access.size_hint() { + Some(size) => (size, Some(size)), + None => (0, None), + } + } +} + +pub(crate) fn duration_as_secs_f64(dur: &core::time::Duration) -> f64 { + (dur.as_secs() as f64) + (dur.subsec_nanos() as f64) / (NANOS_PER_SEC as f64) +} + +pub(crate) fn duration_signed_from_secs_f64( + secs: f64, +) -> Result<self::duration::DurationSigned, String> { + const MAX_NANOS_F64: f64 = ((u64::max_value() as u128 + 1) * (NANOS_PER_SEC as u128)) as f64; + // TODO why are the seconds converted to nanoseconds first? + // Does it make sense to just truncate the value? + let mut nanos = secs * (NANOS_PER_SEC as f64); + if !nanos.is_finite() { + return Err("got non-finite value when converting float to duration".into()); + } + if nanos >= MAX_NANOS_F64 { + return Err("overflow when converting float to duration".into()); + } + let mut sign = self::duration::Sign::Positive; + if nanos < 0.0 { + nanos = -nanos; + sign = self::duration::Sign::Negative; + } + let nanos = nanos as u128; + Ok(self::duration::DurationSigned::new( + sign, + (nanos / (NANOS_PER_SEC as u128)) as u64, + (nanos % (NANOS_PER_SEC as u128)) as u32, + )) +} diff --git a/third_party/rust/serde_with/src/utils/duration.rs b/third_party/rust/serde_with/src/utils/duration.rs new file mode 100644 index 0000000000..2d5a27e87d --- /dev/null +++ b/third_party/rust/serde_with/src/utils/duration.rs @@ -0,0 +1,559 @@ +//! Internal Helper types + +use crate::{ + formats::{Flexible, Format, Strict, Strictness}, + utils, DeserializeAs, DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds, + DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac, + DurationSeconds, DurationSecondsWithFrac, SerializeAs, +}; +use alloc::{ + format, + string::{String, ToString}, + vec::Vec, +}; +use core::{fmt, ops::Neg, time::Duration}; +use serde::{ + de::{self, Unexpected, Visitor}, + ser, Deserialize, Deserializer, Serialize, Serializer, +}; +use std::time::SystemTime; + +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub(crate) enum Sign { + Positive, + Negative, +} + +impl Sign { + #[allow(dead_code)] + pub(crate) fn is_positive(&self) -> bool { + *self == Sign::Positive + } + + #[allow(dead_code)] + pub(crate) fn is_negative(&self) -> bool { + *self == Sign::Negative + } + + pub(crate) fn apply<T>(&self, value: T) -> T + where + T: Neg<Output = T>, + { + match *self { + Sign::Positive => value, + Sign::Negative => value.neg(), + } + } +} + +#[derive(Copy, Clone, Debug)] +pub(crate) struct DurationSigned { + pub(crate) sign: Sign, + pub(crate) duration: Duration, +} + +impl DurationSigned { + pub(crate) fn new(sign: Sign, secs: u64, nanosecs: u32) -> Self { + Self { + sign, + duration: Duration::new(secs, nanosecs), + } + } + + #[cfg(any(feature = "chrono", feature = "time_0_3"))] + pub(crate) fn with_duration(sign: Sign, duration: Duration) -> Self { + Self { sign, duration } + } + + pub(crate) fn to_system_time<'de, D>(self) -> Result<SystemTime, D::Error> + where + D: Deserializer<'de>, + { + match self.sign { + Sign::Positive => SystemTime::UNIX_EPOCH.checked_add(self.duration), + Sign::Negative => SystemTime::UNIX_EPOCH.checked_sub(self.duration), + } + .ok_or_else(|| { + de::Error::custom("timestamp is outside the range for std::time::SystemTime") + }) + } + + pub(crate) fn to_std_duration<'de, D>(self) -> Result<Duration, D::Error> + where + D: Deserializer<'de>, + { + match self.sign { + Sign::Positive => Ok(self.duration), + Sign::Negative => Err(de::Error::custom("std::time::Duration cannot be negative")), + } + } +} + +impl From<&Duration> for DurationSigned { + fn from(&duration: &Duration) -> Self { + Self { + sign: Sign::Positive, + duration, + } + } +} + +impl From<&SystemTime> for DurationSigned { + fn from(time: &SystemTime) -> Self { + match time.duration_since(SystemTime::UNIX_EPOCH) { + Ok(dur) => DurationSigned { + sign: Sign::Positive, + duration: dur, + }, + Err(err) => DurationSigned { + sign: Sign::Negative, + duration: err.duration(), + }, + } + } +} + +impl core::ops::Mul<u32> for DurationSigned { + type Output = DurationSigned; + + fn mul(mut self, rhs: u32) -> Self::Output { + self.duration *= rhs; + self + } +} + +impl core::ops::Div<u32> for DurationSigned { + type Output = DurationSigned; + + fn div(mut self, rhs: u32) -> Self::Output { + self.duration /= rhs; + self + } +} + +impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<u64, STRICTNESS> +where + STRICTNESS: Strictness, +{ + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + if source.sign.is_negative() { + return Err(ser::Error::custom( + "cannot serialize a negative Duration as u64", + )); + } + + let mut secs = source.duration.as_secs(); + + // Properly round the value + if source.duration.subsec_millis() >= 500 { + if source.sign.is_positive() { + secs += 1; + } else { + secs -= 1; + } + } + secs.serialize(serializer) + } +} + +impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<i64, STRICTNESS> +where + STRICTNESS: Strictness, +{ + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut secs = source.sign.apply(source.duration.as_secs() as i64); + + // Properly round the value + if source.duration.subsec_millis() >= 500 { + if source.sign.is_positive() { + secs += 1; + } else { + secs -= 1; + } + } + secs.serialize(serializer) + } +} + +impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<f64, STRICTNESS> +where + STRICTNESS: Strictness, +{ + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut secs = source.sign.apply(source.duration.as_secs() as f64); + + // Properly round the value + if source.duration.subsec_millis() >= 500 { + if source.sign.is_positive() { + secs += 1.; + } else { + secs -= 1.; + } + } + secs.serialize(serializer) + } +} + +impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<String, STRICTNESS> +where + STRICTNESS: Strictness, +{ + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut secs = source.sign.apply(source.duration.as_secs() as i64); + + // Properly round the value + if source.duration.subsec_millis() >= 500 { + if source.sign.is_positive() { + secs += 1; + } else { + secs -= 1; + } + } + secs.to_string().serialize(serializer) + } +} + +impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSecondsWithFrac<f64, STRICTNESS> +where + STRICTNESS: Strictness, +{ + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source + .sign + .apply(utils::duration_as_secs_f64(&source.duration)) + .serialize(serializer) + } +} + +impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSecondsWithFrac<String, STRICTNESS> +where + STRICTNESS: Strictness, +{ + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + source + .sign + .apply(utils::duration_as_secs_f64(&source.duration)) + .to_string() + .serialize(serializer) + } +} + +macro_rules! duration_impls { + ($($inner:ident { $($factor:literal => $outer:ident,)+ })+) => { + $($( + + impl<FORMAT, STRICTNESS> SerializeAs<DurationSigned> for $outer<FORMAT, STRICTNESS> + where + FORMAT: Format, + STRICTNESS: Strictness, + $inner<FORMAT, STRICTNESS>: SerializeAs<DurationSigned> + { + fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + $inner::<FORMAT, STRICTNESS>::serialize_as(&(*source * $factor), serializer) + } + } + + impl<'de, FORMAT, STRICTNESS> DeserializeAs<'de, DurationSigned> for $outer<FORMAT, STRICTNESS> + where + FORMAT: Format, + STRICTNESS: Strictness, + $inner<FORMAT, STRICTNESS>: DeserializeAs<'de, DurationSigned>, + { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + let dur = $inner::<FORMAT, STRICTNESS>::deserialize_as(deserializer)?; + Ok(dur / $factor) + } + } + + )+)+ }; +} +duration_impls!( + DurationSeconds { + 1000u32 => DurationMilliSeconds, + 1_000_000u32 => DurationMicroSeconds, + 1_000_000_000u32 => DurationNanoSeconds, + } + DurationSecondsWithFrac { + 1000u32 => DurationMilliSecondsWithFrac, + 1_000_000u32 => DurationMicroSecondsWithFrac, + 1_000_000_000u32 => DurationNanoSecondsWithFrac, + } +); + +struct DurationVisitorFlexible; +impl<'de> Visitor<'de> for DurationVisitorFlexible { + type Value = DurationSigned; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("an integer, a float, or a string containing a number") + } + + fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> + where + E: de::Error, + { + if value >= 0 { + Ok(DurationSigned::new(Sign::Positive, value as u64, 0)) + } else { + Ok(DurationSigned::new(Sign::Negative, (-value) as u64, 0)) + } + } + + fn visit_u64<E>(self, secs: u64) -> Result<Self::Value, E> + where + E: de::Error, + { + Ok(DurationSigned::new(Sign::Positive, secs, 0)) + } + + fn visit_f64<E>(self, secs: f64) -> Result<Self::Value, E> + where + E: de::Error, + { + utils::duration_signed_from_secs_f64(secs).map_err(de::Error::custom) + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: de::Error, + { + match parse_float_into_time_parts(value) { + Ok((sign, seconds, subseconds)) => Ok(DurationSigned::new(sign, seconds, subseconds)), + Err(ParseFloatError::InvalidValue) => { + Err(de::Error::invalid_value(Unexpected::Str(value), &self)) + } + Err(ParseFloatError::Custom(msg)) => Err(de::Error::custom(msg)), + } + } +} + +impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<u64, Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + u64::deserialize(deserializer).map(|secs: u64| DurationSigned::new(Sign::Positive, secs, 0)) + } +} + +impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<i64, Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + i64::deserialize(deserializer).map(|mut secs: i64| { + let mut sign = Sign::Positive; + if secs.is_negative() { + secs = -secs; + sign = Sign::Negative; + } + DurationSigned::new(sign, secs as u64, 0) + }) + } +} + +impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<f64, Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + let val = f64::deserialize(deserializer)?.round(); + utils::duration_signed_from_secs_f64(val).map_err(de::Error::custom) + } +} + +impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<String, Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + struct DurationDeserializationVisitor; + + impl<'de> Visitor<'de> for DurationDeserializationVisitor { + type Value = DurationSigned; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "a string containing a number") + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: de::Error, + { + let mut secs: i64 = value.parse().map_err(de::Error::custom)?; + let mut sign = Sign::Positive; + if secs.is_negative() { + secs = -secs; + sign = Sign::Negative; + } + Ok(DurationSigned::new(sign, secs as u64, 0)) + } + } + + deserializer.deserialize_str(DurationDeserializationVisitor) + } +} + +impl<'de, FORMAT> DeserializeAs<'de, DurationSigned> for DurationSeconds<FORMAT, Flexible> +where + FORMAT: Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + deserializer.deserialize_any(DurationVisitorFlexible) + } +} + +impl<'de> DeserializeAs<'de, DurationSigned> for DurationSecondsWithFrac<f64, Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + let val = f64::deserialize(deserializer)?; + utils::duration_signed_from_secs_f64(val).map_err(de::Error::custom) + } +} + +impl<'de> DeserializeAs<'de, DurationSigned> for DurationSecondsWithFrac<String, Strict> { + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + let value = String::deserialize(deserializer)?; + match parse_float_into_time_parts(&value) { + Ok((sign, seconds, subseconds)) => Ok(DurationSigned { + sign, + duration: Duration::new(seconds, subseconds), + }), + Err(ParseFloatError::InvalidValue) => Err(de::Error::invalid_value( + Unexpected::Str(&value), + &"a string containing an integer or float", + )), + Err(ParseFloatError::Custom(msg)) => Err(de::Error::custom(msg)), + } + } +} + +impl<'de, FORMAT> DeserializeAs<'de, DurationSigned> for DurationSecondsWithFrac<FORMAT, Flexible> +where + FORMAT: Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error> + where + D: Deserializer<'de>, + { + deserializer.deserialize_any(DurationVisitorFlexible) + } +} + +#[derive(Debug, Eq, PartialEq)] +pub(crate) enum ParseFloatError { + InvalidValue, + Custom(String), +} + +fn parse_float_into_time_parts(mut value: &str) -> Result<(Sign, u64, u32), ParseFloatError> { + let sign = match value.chars().next() { + // Advance by the size of the parsed char + Some('+') => { + value = &value[1..]; + Sign::Positive + } + Some('-') => { + value = &value[1..]; + Sign::Negative + } + _ => Sign::Positive, + }; + + let parts: Vec<_> = value.split('.').collect(); + match *parts.as_slice() { + [seconds] => { + if let Ok(seconds) = seconds.parse() { + Ok((sign, seconds, 0)) + } else { + Err(ParseFloatError::InvalidValue) + } + } + [seconds, subseconds] => { + if let Ok(seconds) = seconds.parse() { + let subseclen = subseconds.chars().count() as u32; + if subseclen > 9 { + return Err(ParseFloatError::Custom(format!( + "Duration and Timestamps with no more than 9 digits precision, but '{}' has more", + value + ))); + } + + if let Ok(mut subseconds) = subseconds.parse() { + // convert subseconds to nanoseconds (10^-9), require 9 places for nanoseconds + subseconds *= 10u32.pow(9 - subseclen); + Ok((sign, seconds, subseconds)) + } else { + Err(ParseFloatError::InvalidValue) + } + } else { + Err(ParseFloatError::InvalidValue) + } + } + + _ => Err(ParseFloatError::InvalidValue), + } +} + +#[test] +fn test_parse_float_into_time_parts() { + // Test normal behavior + assert_eq!( + Ok((Sign::Positive, 123, 456_000_000)), + parse_float_into_time_parts("+123.456") + ); + assert_eq!( + Ok((Sign::Negative, 123, 987_000)), + parse_float_into_time_parts("-123.000987") + ); + assert_eq!( + Ok((Sign::Positive, 18446744073709551615, 123_456_789)), + parse_float_into_time_parts("18446744073709551615.123456789") + ); + + // Test behavior around 0 + assert_eq!( + Ok((Sign::Positive, 0, 456_000_000)), + parse_float_into_time_parts("+0.456") + ); + assert_eq!( + Ok((Sign::Negative, 0, 987_000)), + parse_float_into_time_parts("-0.000987") + ); + assert_eq!( + Ok((Sign::Positive, 0, 123_456_789)), + parse_float_into_time_parts("0.123456789") + ); +} diff --git a/third_party/rust/serde_with/src/with_prefix.rs b/third_party/rust/serde_with/src/with_prefix.rs new file mode 100644 index 0000000000..b4b483c983 --- /dev/null +++ b/third_party/rust/serde_with/src/with_prefix.rs @@ -0,0 +1,612 @@ +use alloc::string::String; +use core::fmt; +use serde::{ + de::{self, DeserializeSeed, Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor}, + forward_to_deserialize_any, + ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer}, +}; + +/// Serialize with an added prefix on every field name and deserialize by +/// trimming away the prefix. +/// +/// You can set the visibility of the generated module by prefixing the module name with a module visibility. +/// `with_prefix!(pub(crate) prefix_foo "foo_");` creates a module with `pub(crate)` visibility. +/// The visibility is optional and by default `pub(self)`, i.e., private visibility is assumed. +/// +/// **Note:** Use of this macro is incompatible with applying the [`deny_unknown_fields`] attribute +/// on the container. +/// While deserializing, it will always warn about unknown fields, even though they are processed +/// by the `with_prefix` wrapper. +/// More details can be found in [this issue][issue-with_prefix-deny_unknown_fields]. +/// +/// # Example +/// +/// The [Challonge REST API] likes to use prefixes to group related fields. In +/// simplified form, their JSON may resemble the following: +/// +/// [Challonge REST API]: https://api.challonge.com/v1/documents/matches/show +/// +/// ```json +/// { +/// "player1_name": "name1", +/// "player1_votes": 1, +/// "player2_name": "name2", +/// "player2_votes": 2 +/// } +/// ``` +/// +/// In Rust, we would ideally like to model this data as a pair of `Player` +/// structs, rather than repeating the fields of `Player` for each prefix. +/// +/// ```rust +/// # #[allow(dead_code)] +/// struct Match { +/// player1: Player, +/// player2: Player, +/// } +/// +/// # #[allow(dead_code)] +/// struct Player { +/// name: String, +/// votes: u64, +/// } +/// ``` +/// +/// This `with_prefix!` macro produces an adapter that adds a prefix onto field +/// names during serialization and trims away the prefix during deserialization. +/// An implementation of the Challonge API would use `with_prefix!` like this: +/// +/// ```rust +/// use serde::{Deserialize, Serialize}; +/// use serde_with::with_prefix; +/// +/// #[derive(Serialize, Deserialize)] +/// struct Match { +/// #[serde(flatten, with = "prefix_player1")] +/// player1: Player, +/// #[serde(flatten, with = "prefix_player2")] +/// player2: Player, +/// } +/// +/// #[derive(Serialize, Deserialize)] +/// struct Player { +/// name: String, +/// votes: u64, +/// } +/// +/// with_prefix!(prefix_player1 "player1_"); +/// // You can also set the visibility of the generated prefix module, the default is private. +/// with_prefix!(pub prefix_player2 "player2_"); +/// # +/// # const EXPECTED: &str = r#"{ +/// # "player1_name": "name1", +/// # "player1_votes": 1, +/// # "player2_name": "name2", +/// # "player2_votes": 2 +/// # }"#; +/// +/// fn main() { +/// let m = Match { +/// player1: Player { +/// name: "name1".to_owned(), +/// votes: 1, +/// }, +/// player2: Player { +/// name: "name2".to_owned(), +/// votes: 2, +/// }, +/// }; +/// +/// let j = serde_json::to_string_pretty(&m).unwrap(); +/// println!("{}", j); +/// # +/// # assert_eq!(j, EXPECTED); +/// } +/// ``` +/// +/// [`deny_unknown_fields`]: https://serde.rs/container-attrs.html#deny_unknown_fields +/// [issue-with_prefix-deny_unknown_fields]: https://github.com/jonasbb/serde_with/issues/57 +#[macro_export] +macro_rules! with_prefix { + ($module:ident $prefix:expr) => {$crate::with_prefix!(pub(self) $module $prefix);}; + ($vis:vis $module:ident $prefix:expr) => { + $vis mod $module { + use $crate::serde::{Deserialize, Deserializer, Serialize, Serializer}; + use $crate::with_prefix::WithPrefix; + + #[allow(dead_code)] + pub fn serialize<T, S>(object: &T, serializer: S) -> ::std::result::Result<S::Ok, S::Error> + where + T: Serialize, + S: Serializer, + { + object.serialize(WithPrefix { + delegate: serializer, + prefix: $prefix, + }) + } + + #[allow(dead_code)] + pub fn deserialize<'de, T, D>(deserializer: D) -> ::std::result::Result<T, D::Error> + where + T: Deserialize<'de>, + D: Deserializer<'de>, + { + T::deserialize(WithPrefix { + delegate: deserializer, + prefix: $prefix, + }) + } + } + }; +} + +#[allow(missing_debug_implementations)] +pub struct WithPrefix<'a, T> { + pub delegate: T, + pub prefix: &'a str, +} + +impl<'a, T> Serialize for WithPrefix<'a, T> +where + T: Serialize, +{ + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + self.delegate.serialize(WithPrefix { + delegate: serializer, + prefix: self.prefix, + }) + } +} + +impl<'a, S> Serializer for WithPrefix<'a, S> +where + S: Serializer, +{ + type Ok = S::Ok; + type Error = S::Error; + type SerializeSeq = Impossible<Self::Ok, Self::Error>; + type SerializeTuple = Impossible<Self::Ok, Self::Error>; + type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>; + type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>; + type SerializeMap = WithPrefix<'a, S::SerializeMap>; + type SerializeStruct = WithPrefix<'a, S::SerializeMap>; + type SerializeStructVariant = Impossible<Self::Ok, Self::Error>; + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> { + self.delegate + .collect_str(&format_args!("{}{}", self.prefix, v)) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + self.delegate.serialize_none() + } + + fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error> + where + T: ?Sized + Serialize, + { + self.delegate.serialize_some(&WithPrefix { + delegate: value, + prefix: self.prefix, + }) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + ) -> Result<Self::Ok, Self::Error> { + self.serialize_str(variant) + } + + fn serialize_newtype_struct<T>( + self, + _name: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: ?Sized + Serialize, + { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_newtype_variant<T>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: ?Sized + Serialize, + { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } + + fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { + Ok(WithPrefix { + delegate: self.delegate.serialize_map(len)?, + prefix: self.prefix, + }) + } + + fn serialize_struct( + self, + _name: &'static str, + len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + self.serialize_map(Some(len)) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { + Err(ser::Error::custom("wrong type for with_prefix")) + } +} + +impl<'a, S> SerializeMap for WithPrefix<'a, S> +where + S: SerializeMap, +{ + type Ok = S::Ok; + type Error = S::Error; + + fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error> + where + T: ?Sized + Serialize, + { + self.delegate.serialize_key(&WithPrefix { + delegate: key, + prefix: self.prefix, + }) + } + + fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error> + where + T: ?Sized + Serialize, + { + self.delegate.serialize_value(value) + } + + fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error> + where + K: ?Sized + Serialize, + V: ?Sized + Serialize, + { + self.delegate.serialize_entry( + &WithPrefix { + delegate: key, + prefix: self.prefix, + }, + value, + ) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + self.delegate.end() + } +} + +impl<'a, S> SerializeStruct for WithPrefix<'a, S> +where + S: SerializeMap, +{ + type Ok = S::Ok; + type Error = S::Error; + + fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> + where + T: ?Sized + Serialize, + { + let mut prefixed_key = String::with_capacity(self.prefix.len() + key.len()); + prefixed_key.push_str(self.prefix); + prefixed_key.push_str(key); + self.delegate.serialize_entry(&prefixed_key, value) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + self.delegate.end() + } +} + +impl<'de, 'a, T> DeserializeSeed<'de> for WithPrefix<'a, T> +where + T: DeserializeSeed<'de>, +{ + type Value = T::Value; + + fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + self.delegate.deserialize(WithPrefix { + delegate: deserializer, + prefix: self.prefix, + }) + } +} + +impl<'de, 'a, D> Deserializer<'de> for WithPrefix<'a, D> +where + D: Deserializer<'de>, +{ + type Error = D::Error; + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.deserialize_map(WithPrefix { + delegate: visitor, + prefix: self.prefix, + }) + } + + fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.deserialize_any(WithPrefixOption { + first_key: None, + delegate: visitor, + prefix: self.prefix, + }) + } + + fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.deserialize_identifier(WithPrefix { + delegate: visitor, + prefix: self.prefix, + }) + } + + forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct + map struct enum ignored_any + } +} + +impl<'de, 'a, V> Visitor<'de> for WithPrefix<'a, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + self.delegate.expecting(formatter) + } + + fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + self.delegate.visit_map(WithPrefix { + delegate: map, + prefix: self.prefix, + }) + } +} + +impl<'de, 'a, A> MapAccess<'de> for WithPrefix<'a, A> +where + A: MapAccess<'de>, +{ + type Error = A::Error; + + fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error> + where + K: DeserializeSeed<'de>, + { + while let Some(s) = self.delegate.next_key::<String>()? { + if let Some(without_prefix) = s.strip_prefix(self.prefix) { + return seed + .deserialize(without_prefix.into_deserializer()) + .map(Some); + } + self.delegate.next_value::<IgnoredAny>()?; + } + Ok(None) + } + + fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error> + where + V: DeserializeSeed<'de>, + { + self.delegate.next_value_seed(seed) + } +} + +#[allow(missing_debug_implementations)] +pub struct WithPrefixOption<'a, T> { + first_key: Option<String>, + delegate: T, + prefix: &'a str, +} + +impl<'de, 'a, V> Visitor<'de> for WithPrefixOption<'a, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + self.delegate.expecting(formatter) + } + + fn visit_unit<E>(self) -> Result<Self::Value, E> + where + E: de::Error, + { + self.delegate.visit_none() + } + + fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + while let Some(s) = map.next_key::<String>()? { + if s.starts_with(self.prefix) { + return self.delegate.visit_some(WithPrefixOption { + first_key: Some(s), + delegate: map, + prefix: self.prefix, + }); + } + map.next_value::<IgnoredAny>()?; + } + self.delegate.visit_none() + } +} + +impl<'de, 'a, A> Deserializer<'de> for WithPrefixOption<'a, A> +where + A: MapAccess<'de>, +{ + type Error = A::Error; + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + visitor.visit_map(self) + } + + forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct seq tuple + tuple_struct map struct enum identifier ignored_any + } +} + +impl<'de, 'a, A> MapAccess<'de> for WithPrefixOption<'a, A> +where + A: MapAccess<'de>, +{ + type Error = A::Error; + + fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error> + where + K: DeserializeSeed<'de>, + { + if let Some(s) = self.first_key.take() { + let without_prefix = s[self.prefix.len()..].into_deserializer(); + return seed.deserialize(without_prefix).map(Some); + } + while let Some(s) = self.delegate.next_key::<String>()? { + if let Some(without_prefix) = s.strip_prefix(self.prefix) { + return seed + .deserialize(without_prefix.into_deserializer()) + .map(Some); + } + self.delegate.next_value::<IgnoredAny>()?; + } + Ok(None) + } + + fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error> + where + V: DeserializeSeed<'de>, + { + self.delegate.next_value_seed(seed) + } +} |