diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
| commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
| tree | f435a8308119effd964b339f76abb83a57c29483 /third_party/rust/serde_with/src | |
| parent | Initial commit. (diff) | |
| download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip | |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/serde_with/src')
32 files changed, 16203 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..0e52e0c4b3 --- /dev/null +++ b/third_party/rust/serde_with/src/base64.rs @@ -0,0 +1,232 @@ +//! 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::prelude::*; + +/// 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 `ALPHABET` is a type implementing [`Alphabet`]. +/// `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/ +pub struct Base64<ALPHABET: Alphabet = Standard, PADDING: formats::Format = formats::Padded>( + PhantomData<(ALPHABET, PADDING)>, +); + +impl<T, ALPHABET> SerializeAs<T> for Base64<ALPHABET, formats::Padded> +where + T: AsRef<[u8]>, + ALPHABET: Alphabet, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + use ::base64::Engine as _; + + ::base64::engine::GeneralPurpose::new( + &ALPHABET::charset(), + ::base64::engine::general_purpose::PAD, + ) + .encode(source) + .serialize(serializer) + } +} + +impl<T, ALPHABET> SerializeAs<T> for Base64<ALPHABET, formats::Unpadded> +where + T: AsRef<[u8]>, + ALPHABET: Alphabet, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + use ::base64::Engine as _; + + ::base64::engine::GeneralPurpose::new( + &ALPHABET::charset(), + ::base64::engine::general_purpose::NO_PAD, + ) + .encode(source) + .serialize(serializer) + } +} + +// Our decoders uniformly do not care about padding. +const PAD_INDIFFERENT: ::base64::engine::GeneralPurposeConfig = + ::base64::engine::GeneralPurposeConfig::new() + .with_decode_padding_mode(::base64::engine::DecodePaddingMode::Indifferent); + +impl<'de, T, ALPHABET, FORMAT> DeserializeAs<'de, T> for Base64<ALPHABET, FORMAT> +where + T: TryFrom<Vec<u8>>, + ALPHABET: Alphabet, + FORMAT: formats::Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + struct Helper<T, ALPHABET>(PhantomData<(T, ALPHABET)>); + + impl<'de, T, ALPHABET> Visitor<'de> for Helper<T, ALPHABET> + where + T: TryFrom<Vec<u8>>, + ALPHABET: Alphabet, + { + type Value = T; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a base64 encoded string") + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: DeError, + { + use ::base64::Engine as _; + + let bytes = + ::base64::engine::GeneralPurpose::new(&ALPHABET::charset(), PAD_INDIFFERENT) + .decode(value) + .map_err(DeError::custom)?; + + let length = bytes.len(); + bytes.try_into().map_err(|_e: T::Error| { + DeError::custom(format_args!( + "Can't convert a Byte Vector of length {length} to the output type." + )) + }) + } + } + + deserializer.deserialize_str(Helper::<T, ALPHABET>(PhantomData)) + } +} + +mod sealed { + pub trait Sealed {} + impl Sealed for super::Standard {} + impl Sealed for super::UrlSafe {} + impl Sealed for super::Crypt {} + impl Sealed for super::Bcrypt {} + impl Sealed for super::ImapMutf7 {} + impl Sealed for super::BinHex {} +} + +/// A base64 alphabet +pub trait Alphabet: sealed::Sealed { + /// Return a specific alphabet. + fn charset() -> ::base64::alphabet::Alphabet; +} +/// The standard character set (uses `+` and `/`). +/// +/// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3). +pub struct Standard; +impl Alphabet for Standard { + fn charset() -> ::base64::alphabet::Alphabet { + ::base64::alphabet::STANDARD + } +} + +/// The URL safe character set (uses `-` and `_`). +/// +/// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3). +pub struct UrlSafe; +impl Alphabet for UrlSafe { + fn charset() -> ::base64::alphabet::Alphabet { + ::base64::alphabet::URL_SAFE + } +} + +/// The `crypt(3)` character set (uses `./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`). +/// +/// Not standardized, but folk wisdom on the net asserts that this alphabet is what crypt uses. +pub struct Crypt; +impl Alphabet for Crypt { + fn charset() -> ::base64::alphabet::Alphabet { + ::base64::alphabet::CRYPT + } +} + +/// The bcrypt character set (uses `./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`). +pub struct Bcrypt; +impl Alphabet for Bcrypt { + fn charset() -> ::base64::alphabet::Alphabet { + ::base64::alphabet::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). +pub struct ImapMutf7; +impl Alphabet for ImapMutf7 { + fn charset() -> ::base64::alphabet::Alphabet { + ::base64::alphabet::IMAP_MUTF7 + } +} + +/// The character set used in BinHex 4.0 files. +/// +/// See [BinHex 4.0 Definition](http://files.stairways.com/other/binhex-40-specs-info.txt). +pub struct BinHex; +impl Alphabet for BinHex { + fn charset() -> ::base64::alphabet::Alphabet { + ::base64::alphabet::BIN_HEX + } +} diff --git a/third_party/rust/serde_with/src/chrono_0_4.rs b/third_party/rust/serde_with/src/chrono_0_4.rs new file mode 100644 index 0000000000..a5cf829ebe --- /dev/null +++ b/third_party/rust/serde_with/src/chrono_0_4.rs @@ -0,0 +1,655 @@ +//! De/Serialization of [chrono] types +//! +//! This modules is only available if using the `chrono_0_4` feature of the crate. +//! +//! [chrono]: https://docs.rs/chrono/ + +use crate::{ + formats::{Flexible, Format, Strict, Strictness}, + prelude::*, +}; +#[cfg(feature = "std")] +use ::chrono_0_4::Local; +use ::chrono_0_4::{DateTime, Duration, NaiveDateTime, TimeZone, Utc}; + +/// Create a [`DateTime`] for the Unix Epoch using the [`Utc`] timezone +fn unix_epoch_utc() -> DateTime<Utc> { + DateTime::<Utc>::from_utc(unix_epoch_naive(), Utc) +} + +/// Create a [`DateTime`] for the Unix Epoch using the [`Local`] timezone +#[cfg(feature = "std")] +fn unix_epoch_local() -> DateTime<Local> { + unix_epoch_utc().with_timezone(&Local) +} + +/// Create a [`NaiveDateTime`] for the Unix Epoch +fn unix_epoch_naive() -> NaiveDateTime { + NaiveDateTime::from_timestamp_opt(0, 0).unwrap() +} + +/// 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_0_4::{DateTime, Utc}; +/// # use serde::Deserialize; +/// # +/// #[derive(Debug, Deserialize)] +/// struct S { +/// #[serde(with = "serde_with::chrono_0_4::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()); +/// ``` +// Requires float operations from std +#[cfg(feature = "std")] +pub mod datetime_utc_ts_seconds_from_any { + use super::*; + + /// 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: DeError, + { + let ndt = NaiveDateTime::from_timestamp_opt(value, 0); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(DeError::custom(format_args!( + "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: DeError, + { + let ndt = NaiveDateTime::from_timestamp_opt(value as i64, 0); + if let Some(ndt) = ndt { + Ok(DateTime::<Utc>::from_utc(ndt, Utc)) + } else { + Err(DeError::custom(format_args!( + "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: DeError, + { + 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(DeError::custom(format_args!( + "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: DeError, + { + 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(DeError::custom(format_args!( + "a timestamp which can be represented in a DateTime but received '{value}'" + ))) + } + } else { + Err(DeError::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(DeError::custom(format_args!( + "DateTimes only support nanosecond precision but '{value}' has more than 9 digits." + ))); + } + + 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(DeError::custom(format_args!( + "a timestamp which can be represented in a DateTime but received '{value}'" + ))) + } + } else { + Err(DeError::invalid_value(Unexpected::Str(value), &self)) + } + } else { + Err(DeError::invalid_value(Unexpected::Str(value), &self)) + } + } + + _ => Err(DeError::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_0_4::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_0_4::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(DeError::custom(format_args!( + "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} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_into_duration_signed => + {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} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<TZ>; datetime_to_duration => + {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} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + NaiveDateTime; naive_datetime_to_duration => + {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} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_into_duration_signed => + {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} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + DateTime<TZ>; datetime_to_duration => + {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} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + NaiveDateTime; naive_datetime_to_duration => + {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)?) +} + +#[cfg(feature = "std")] +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 =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_from_duration_signed => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration; duration_from_duration_signed => + {f64, Strict =>} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<Utc>; duration_to_datetime_utc => + {i64, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<Utc>; duration_to_datetime_utc => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + DateTime<Utc>; duration_to_datetime_utc => + {f64, Strict =>} + } +); +#[cfg(feature = "std")] +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 =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + NaiveDateTime; duration_to_naive_datetime => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + NaiveDateTime; duration_to_naive_datetime => + {f64, Strict =>} + } +); + +// Duration/Timestamp WITH FRACTIONS +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_from_duration_signed => + {f64, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; duration_from_duration_signed => + {String, Strict =>} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + DateTime<Utc>; duration_to_datetime_utc => + {f64, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + DateTime<Utc>; duration_to_datetime_utc => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +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 =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + NaiveDateTime; duration_to_naive_datetime => + {String, Strict =>} + } +); diff --git a/third_party/rust/serde_with/src/content/de.rs b/third_party/rust/serde_with/src/content/de.rs new file mode 100644 index 0000000000..98e8a5301c --- /dev/null +++ b/third_party/rust/serde_with/src/content/de.rs @@ -0,0 +1,1894 @@ +//! Buffer for deserializing data. +//! +//! This is a copy and improvement of the `serde` private type: +//! <https://github.com/serde-rs/serde/blob/f85c4f2fa99c7f3b103e6e2580e75eb9313b00d0/serde/src/private/de.rs#L195> +//! 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+. +//! A value for `is_human_readable` is passed through all types, to preserve the information. +//! +//! In the future this can hopefully be replaced by a public type in `serde` itself. +//! <https://github.com/serde-rs/serde/pull/2348> + +use crate::{ + prelude::*, + utils::{size_hint_cautious, size_hint_from_bounds}, +}; + +/// Used from generated code to buffer the contents of the Deserializer when +/// deserializing untagged enums and internally tagged enums. +/// +/// Not public API. Use serde-value instead. +#[derive(Debug, Clone)] +pub(crate) enum Content<'de> { + 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), + Str(&'de str), + ByteBuf(Vec<u8>), + Bytes(&'de [u8]), + + None, + Some(Box<Content<'de>>), + + Unit, + Newtype(Box<Content<'de>>), + Seq(Vec<Content<'de>>), + Map(Vec<(Content<'de>, Content<'de>)>), +} + +impl<'de> Content<'de> { + #[cold] + fn unexpected(&self) -> Unexpected<'_> { + match *self { + Content::Bool(b) => Unexpected::Bool(b), + Content::U8(n) => Unexpected::Unsigned(n as u64), + Content::U16(n) => Unexpected::Unsigned(n as u64), + Content::U32(n) => Unexpected::Unsigned(n as u64), + Content::U64(n) => Unexpected::Unsigned(n), + Content::U128(_) => Unexpected::Other("u128"), + Content::I8(n) => Unexpected::Signed(n as i64), + Content::I16(n) => Unexpected::Signed(n as i64), + Content::I32(n) => Unexpected::Signed(n as i64), + Content::I64(n) => Unexpected::Signed(n), + Content::I128(_) => Unexpected::Other("i128"), + Content::F32(f) => Unexpected::Float(f as f64), + Content::F64(f) => Unexpected::Float(f), + Content::Char(c) => Unexpected::Char(c), + Content::String(ref s) => Unexpected::Str(s), + Content::Str(s) => Unexpected::Str(s), + Content::ByteBuf(ref b) => Unexpected::Bytes(b), + Content::Bytes(b) => Unexpected::Bytes(b), + Content::None | Content::Some(_) => Unexpected::Option, + Content::Unit => Unexpected::Unit, + Content::Newtype(_) => Unexpected::NewtypeStruct, + Content::Seq(_) => Unexpected::Seq, + Content::Map(_) => Unexpected::Map, + } + } +} + +impl<'de> Deserialize<'de> for Content<'de> { + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + // Untagged and internally tagged enums are only supported in + // self-describing formats. + let visitor = ContentVisitor { value: PhantomData }; + deserializer.deserialize_any(visitor) + } +} + +struct ContentVisitor<'de> { + value: PhantomData<Content<'de>>, +} + +impl<'de> Visitor<'de> for ContentVisitor<'de> { + type Value = Content<'de>; + + fn expecting(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.write_str("any value") + } + + fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::Bool(value)) + } + + fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::I8(value)) + } + + fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::I16(value)) + } + + fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::I32(value)) + } + + fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::I64(value)) + } + + fn visit_i128<F>(self, value: i128) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::I128(value)) + } + + fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::U8(value)) + } + + fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::U16(value)) + } + + fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::U32(value)) + } + + fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::U64(value)) + } + + fn visit_u128<F>(self, value: u128) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::U128(value)) + } + + fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::F32(value)) + } + + fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::F64(value)) + } + + fn visit_char<F>(self, value: char) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::Char(value)) + } + + fn visit_str<F>(self, value: &str) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::String(value.into())) + } + + fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::Str(value)) + } + + fn visit_string<F>(self, value: String) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::String(value)) + } + + fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::ByteBuf(value.into())) + } + + fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::Bytes(value)) + } + + fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::ByteBuf(value)) + } + + fn visit_unit<F>(self) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::Unit) + } + + fn visit_none<F>(self) -> Result<Self::Value, F> + where + F: DeError, + { + Ok(Content::None) + } + + fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(|v| Content::Some(Box::new(v))) + } + + fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + Deserialize::deserialize(deserializer).map(|v| Content::Newtype(Box::new(v))) + } + + fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> + where + V: SeqAccess<'de>, + { + let mut vec = Vec::with_capacity(size_hint_cautious(visitor.size_hint())); + while let Some(e) = visitor.next_element()? { + vec.push(e); + } + Ok(Content::Seq(vec)) + } + + fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error> + where + V: MapAccess<'de>, + { + let mut vec = Vec::with_capacity(size_hint_cautious(visitor.size_hint())); + while let Some(kv) = visitor.next_entry()? { + vec.push(kv); + } + Ok(Content::Map(vec)) + } + + fn visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error> + where + V: EnumAccess<'de>, + { + Err(DeError::custom( + "untagged and internally tagged enums do not support enum input", + )) + } +} + +pub(crate) struct ContentDeserializer<'de, E> { + is_human_readable: bool, + content: Content<'de>, + err: PhantomData<E>, +} + +impl<'de, E> ContentDeserializer<'de, E> +where + E: DeError, +{ + #[cold] + fn invalid_type(self, exp: &dyn Expected) -> E { + DeError::invalid_type(self.content.unexpected(), exp) + } + + fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match self.content { + Content::U8(v) => visitor.visit_u8(v), + Content::U16(v) => visitor.visit_u16(v), + Content::U32(v) => visitor.visit_u32(v), + Content::U64(v) => visitor.visit_u64(v), + Content::U128(v) => visitor.visit_u128(v), + Content::I8(v) => visitor.visit_i8(v), + Content::I16(v) => visitor.visit_i16(v), + Content::I32(v) => visitor.visit_i32(v), + Content::I64(v) => visitor.visit_i64(v), + Content::I128(v) => visitor.visit_i128(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match self.content { + Content::F32(v) => visitor.visit_f32(v), + Content::F64(v) => visitor.visit_f64(v), + Content::U8(v) => visitor.visit_u8(v), + Content::U16(v) => visitor.visit_u16(v), + Content::U32(v) => visitor.visit_u32(v), + Content::U64(v) => visitor.visit_u64(v), + Content::U128(v) => visitor.visit_u128(v), + Content::I8(v) => visitor.visit_i8(v), + Content::I16(v) => visitor.visit_i16(v), + Content::I32(v) => visitor.visit_i32(v), + Content::I64(v) => visitor.visit_i64(v), + Content::I128(v) => visitor.visit_i128(v), + _ => Err(self.invalid_type(&visitor)), + } + } +} + +fn visit_content_seq<'de, V, E>( + content: Vec<Content<'de>>, + visitor: V, + is_human_readable: bool, +) -> Result<V::Value, E> +where + V: Visitor<'de>, + E: DeError, +{ + let seq = content + .into_iter() + .map(|x| ContentDeserializer::new(x, is_human_readable)); + let mut seq_visitor = serde::de::value::SeqDeserializer::new(seq); + let value = visitor.visit_seq(&mut seq_visitor)?; + seq_visitor.end()?; + Ok(value) +} + +fn visit_content_map<'de, V, E>( + content: Vec<(Content<'de>, Content<'de>)>, + visitor: V, + is_human_readable: bool, +) -> Result<V::Value, E> +where + V: Visitor<'de>, + E: DeError, +{ + let map = content.into_iter().map(|(k, v)| { + ( + ContentDeserializer::new(k, is_human_readable), + ContentDeserializer::new(v, is_human_readable), + ) + }); + let mut map_visitor = serde::de::value::MapDeserializer::new(map); + let value = visitor.visit_map(&mut map_visitor)?; + map_visitor.end()?; + Ok(value) +} + +/// Used when deserializing an internally tagged enum because the content +/// will be used exactly once. +impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + + #[inline] + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Bool(v) => visitor.visit_bool(v), + Content::U8(v) => visitor.visit_u8(v), + Content::U16(v) => visitor.visit_u16(v), + Content::U32(v) => visitor.visit_u32(v), + Content::U64(v) => visitor.visit_u64(v), + Content::U128(v) => visitor.visit_u128(v), + Content::I8(v) => visitor.visit_i8(v), + Content::I16(v) => visitor.visit_i16(v), + Content::I32(v) => visitor.visit_i32(v), + Content::I64(v) => visitor.visit_i64(v), + Content::I128(v) => visitor.visit_i128(v), + Content::F32(v) => visitor.visit_f32(v), + Content::F64(v) => visitor.visit_f64(v), + Content::Char(v) => visitor.visit_char(v), + Content::String(v) => visitor.visit_string(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(v) => visitor.visit_byte_buf(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + Content::Unit => visitor.visit_unit(), + Content::None => visitor.visit_none(), + Content::Some(v) => { + visitor.visit_some(ContentDeserializer::new(*v, self.is_human_readable)) + } + Content::Newtype(v) => { + visitor.visit_newtype_struct(ContentDeserializer::new(*v, self.is_human_readable)) + } + Content::Seq(v) => visit_content_seq(v, visitor, self.is_human_readable), + Content::Map(v) => visit_content_map(v, visitor, self.is_human_readable), + } + } + + fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Bool(v) => visitor.visit_bool(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_float(visitor) + } + + fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_float(visitor) + } + + fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Char(v) => visitor.visit_char(v), + Content::String(v) => visitor.visit_string(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_string(visitor) + } + + fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::String(v) => visitor.visit_string(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(v) => visitor.visit_byte_buf(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_byte_buf(visitor) + } + + fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::String(v) => visitor.visit_string(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(v) => visitor.visit_byte_buf(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + Content::Seq(v) => visit_content_seq(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::None => visitor.visit_none(), + Content::Some(v) => { + visitor.visit_some(ContentDeserializer::new(*v, self.is_human_readable)) + } + Content::Unit => visitor.visit_unit(), + _ => visitor.visit_some(self), + } + } + + fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Unit => visitor.visit_unit(), + + // Allow deserializing newtype variant containing unit. + // + // #[derive(Deserialize)] + // #[serde(tag = "result")] + // enum Response<T> { + // Success(T), + // } + // + // We want {"result":"Success"} to deserialize into Response<()>. + Content::Map(ref v) if v.is_empty() => visitor.visit_unit(), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_unit_struct<V>( + self, + _name: &'static str, + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + // As a special case, allow deserializing untagged newtype + // variant containing unit struct. + // + // #[derive(Deserialize)] + // struct Info; + // + // #[derive(Deserialize)] + // #[serde(tag = "topic")] + // enum Message { + // Info(Info), + // } + // + // We want {"topic":"Info"} to deserialize even though + // ordinarily unit structs do not deserialize from empty map/seq. + Content::Map(ref v) if v.is_empty() => visitor.visit_unit(), + Content::Seq(ref v) if v.is_empty() => visitor.visit_unit(), + _ => self.deserialize_any(visitor), + } + } + + fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Newtype(v) => { + visitor.visit_newtype_struct(ContentDeserializer::new(*v, self.is_human_readable)) + } + _ => visitor.visit_newtype_struct(self), + } + } + + fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Seq(v) => visit_content_seq(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_seq(visitor) + } + + fn deserialize_tuple_struct<V>( + self, + _name: &'static str, + _len: usize, + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_seq(visitor) + } + + fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Map(v) => visit_content_map(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_struct<V>( + self, + _name: &'static str, + _fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::Seq(v) => visit_content_seq(v, visitor, self.is_human_readable), + Content::Map(v) => visit_content_map(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_enum<V>( + self, + _name: &str, + _variants: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + let (variant, value) = match self.content { + Content::Map(value) => { + let mut iter = value.into_iter(); + let (variant, value) = match iter.next() { + Some(v) => v, + None => { + return Err(DeError::invalid_value( + Unexpected::Map, + &"map with a single key", + )); + } + }; + // enums are encoded in json as maps with a single key:value pair + if iter.next().is_some() { + return Err(DeError::invalid_value( + Unexpected::Map, + &"map with a single key", + )); + } + (variant, Some(value)) + } + s @ Content::String(_) | s @ Content::Str(_) => (s, None), + other => { + return Err(DeError::invalid_type(other.unexpected(), &"string or map")); + } + }; + + visitor.visit_enum(EnumDeserializer::new( + variant, + value, + self.is_human_readable, + )) + } + + fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.content { + Content::String(v) => visitor.visit_string(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(v) => visitor.visit_byte_buf(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + Content::U8(v) => visitor.visit_u8(v), + Content::U64(v) => visitor.visit_u64(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + drop(self); + visitor.visit_unit() + } +} + +impl<'de, E> ContentDeserializer<'de, E> { + /// private API, don't use + pub(crate) fn new(content: Content<'de>, is_human_readable: bool) -> Self { + ContentDeserializer { + is_human_readable, + content, + err: PhantomData, + } + } +} + +struct EnumDeserializer<'de, E> +where + E: DeError, +{ + is_human_readable: bool, + variant: Content<'de>, + value: Option<Content<'de>>, + err: PhantomData<E>, +} + +impl<'de, E> EnumDeserializer<'de, E> +where + E: DeError, +{ + pub fn new( + variant: Content<'de>, + value: Option<Content<'de>>, + is_human_readable: bool, + ) -> EnumDeserializer<'de, E> { + EnumDeserializer { + is_human_readable, + variant, + value, + err: PhantomData, + } + } +} + +impl<'de, E> EnumAccess<'de> for EnumDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + type Variant = VariantDeserializer<'de, Self::Error>; + + fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E> + where + V: DeserializeSeed<'de>, + { + let visitor = VariantDeserializer { + is_human_readable: self.is_human_readable, + value: self.value, + err: PhantomData, + }; + seed.deserialize(ContentDeserializer::new( + self.variant, + self.is_human_readable, + )) + .map(|v| (v, visitor)) + } +} + +pub struct VariantDeserializer<'de, E> +where + E: DeError, +{ + is_human_readable: bool, + value: Option<Content<'de>>, + err: PhantomData<E>, +} + +impl<'de, E> VariantAccess<'de> for VariantDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + + fn unit_variant(self) -> Result<(), E> { + match self.value { + Some(value) => { + Deserialize::deserialize(ContentDeserializer::new(value, self.is_human_readable)) + } + None => Ok(()), + } + } + + fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E> + where + T: DeserializeSeed<'de>, + { + match self.value { + Some(value) => { + seed.deserialize(ContentDeserializer::new(value, self.is_human_readable)) + } + None => Err(DeError::invalid_type( + Unexpected::UnitVariant, + &"newtype variant", + )), + } + } + + fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.value { + Some(Content::Seq(v)) => Deserializer::deserialize_any( + SeqDeserializer::new(v, self.is_human_readable), + visitor, + ), + Some(other) => Err(DeError::invalid_type(other.unexpected(), &"tuple variant")), + None => Err(DeError::invalid_type( + Unexpected::UnitVariant, + &"tuple variant", + )), + } + } + + fn struct_variant<V>( + self, + _fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.value { + Some(Content::Map(v)) => Deserializer::deserialize_any( + MapDeserializer::new(v, self.is_human_readable), + visitor, + ), + Some(Content::Seq(v)) => Deserializer::deserialize_any( + SeqDeserializer::new(v, self.is_human_readable), + visitor, + ), + Some(other) => Err(DeError::invalid_type(other.unexpected(), &"struct variant")), + None => Err(DeError::invalid_type( + Unexpected::UnitVariant, + &"struct variant", + )), + } + } +} + +struct SeqDeserializer<'de, E> +where + E: DeError, +{ + is_human_readable: bool, + iter: <Vec<Content<'de>> as IntoIterator>::IntoIter, + err: PhantomData<E>, +} + +impl<'de, E> SeqDeserializer<'de, E> +where + E: DeError, +{ + fn new(vec: Vec<Content<'de>>, is_human_readable: bool) -> Self { + SeqDeserializer { + is_human_readable, + iter: vec.into_iter(), + err: PhantomData, + } + } +} + +impl<'de, E> Deserializer<'de> for SeqDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + + #[inline] + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + #[inline] + fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + let len = self.iter.len(); + if len == 0 { + visitor.visit_unit() + } else { + let ret = visitor.visit_seq(&mut self)?; + let remaining = self.iter.len(); + if remaining == 0 { + Ok(ret) + } else { + Err(DeError::invalid_length(len, &"fewer elements in array")) + } + } + } + + 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, E> SeqAccess<'de> for SeqDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + + fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.iter.next() { + Some(value) => seed + .deserialize(ContentDeserializer::new(value, self.is_human_readable)) + .map(Some), + None => Ok(None), + } + } + + fn size_hint(&self) -> Option<usize> { + size_hint_from_bounds(&self.iter) + } +} + +struct MapDeserializer<'de, E> +where + E: DeError, +{ + is_human_readable: bool, + iter: <Vec<(Content<'de>, Content<'de>)> as IntoIterator>::IntoIter, + value: Option<Content<'de>>, + err: PhantomData<E>, +} + +impl<'de, E> MapDeserializer<'de, E> +where + E: DeError, +{ + fn new(map: Vec<(Content<'de>, Content<'de>)>, is_human_readable: bool) -> Self { + MapDeserializer { + is_human_readable, + iter: map.into_iter(), + value: None, + err: PhantomData, + } + } +} + +impl<'de, E> MapAccess<'de> for MapDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + + fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.iter.next() { + Some((key, value)) => { + self.value = Some(value); + seed.deserialize(ContentDeserializer::new(key, self.is_human_readable)) + .map(Some) + } + None => Ok(None), + } + } + + fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.value.take() { + Some(value) => { + seed.deserialize(ContentDeserializer::new(value, self.is_human_readable)) + } + None => Err(DeError::custom("value is missing")), + } + } + + fn size_hint(&self) -> Option<usize> { + size_hint_from_bounds(&self.iter) + } +} + +impl<'de, E> Deserializer<'de> for MapDeserializer<'de, E> +where + E: DeError, +{ + type Error = E; + + #[inline] + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + #[inline] + 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 + } +} + +/// Not public API. +pub struct ContentRefDeserializer<'a, 'de, E> { + is_human_readable: bool, + content: &'a Content<'de>, + err: PhantomData<E>, +} + +impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + #[cold] + fn invalid_type(self, exp: &dyn Expected) -> E { + DeError::invalid_type(self.content.unexpected(), exp) + } + + fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match *self.content { + Content::U8(v) => visitor.visit_u8(v), + Content::U16(v) => visitor.visit_u16(v), + Content::U32(v) => visitor.visit_u32(v), + Content::U64(v) => visitor.visit_u64(v), + Content::U128(v) => visitor.visit_u128(v), + Content::I8(v) => visitor.visit_i8(v), + Content::I16(v) => visitor.visit_i16(v), + Content::I32(v) => visitor.visit_i32(v), + Content::I64(v) => visitor.visit_i64(v), + Content::I128(v) => visitor.visit_i128(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match *self.content { + Content::F32(v) => visitor.visit_f32(v), + Content::F64(v) => visitor.visit_f64(v), + Content::U8(v) => visitor.visit_u8(v), + Content::U16(v) => visitor.visit_u16(v), + Content::U32(v) => visitor.visit_u32(v), + Content::U64(v) => visitor.visit_u64(v), + Content::U128(v) => visitor.visit_u128(v), + Content::I8(v) => visitor.visit_i8(v), + Content::I16(v) => visitor.visit_i16(v), + Content::I32(v) => visitor.visit_i32(v), + Content::I64(v) => visitor.visit_i64(v), + Content::I128(v) => visitor.visit_i128(v), + _ => Err(self.invalid_type(&visitor)), + } + } +} + +fn visit_content_seq_ref<'a, 'de, V, E>( + content: &'a [Content<'de>], + visitor: V, + is_human_readable: bool, +) -> Result<V::Value, E> +where + V: Visitor<'de>, + E: DeError, +{ + let seq = content + .iter() + .map(|x| ContentRefDeserializer::new(x, is_human_readable)); + let mut seq_visitor = serde::de::value::SeqDeserializer::new(seq); + let value = visitor.visit_seq(&mut seq_visitor)?; + seq_visitor.end()?; + Ok(value) +} + +fn visit_content_map_ref<'a, 'de, V, E>( + content: &'a [(Content<'de>, Content<'de>)], + visitor: V, + is_human_readable: bool, +) -> Result<V::Value, E> +where + V: Visitor<'de>, + E: DeError, +{ + let map = content.iter().map(|(k, v)| { + ( + ContentRefDeserializer::new(k, is_human_readable), + ContentRefDeserializer::new(v, is_human_readable), + ) + }); + let mut map_visitor = serde::de::value::MapDeserializer::new(map); + let value = visitor.visit_map(&mut map_visitor)?; + map_visitor.end()?; + Ok(value) +} + +/// Used when deserializing an untagged enum because the content may need +/// to be used more than once. +impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + + #[inline] + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match *self.content { + Content::Bool(v) => visitor.visit_bool(v), + Content::U8(v) => visitor.visit_u8(v), + Content::U16(v) => visitor.visit_u16(v), + Content::U32(v) => visitor.visit_u32(v), + Content::U64(v) => visitor.visit_u64(v), + Content::U128(v) => visitor.visit_u128(v), + Content::I8(v) => visitor.visit_i8(v), + Content::I16(v) => visitor.visit_i16(v), + Content::I32(v) => visitor.visit_i32(v), + Content::I64(v) => visitor.visit_i64(v), + Content::I128(v) => visitor.visit_i128(v), + Content::F32(v) => visitor.visit_f32(v), + Content::F64(v) => visitor.visit_f64(v), + Content::Char(v) => visitor.visit_char(v), + Content::String(ref v) => visitor.visit_str(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(ref v) => visitor.visit_bytes(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + Content::Unit => visitor.visit_unit(), + Content::None => visitor.visit_none(), + Content::Some(ref v) => { + visitor.visit_some(ContentRefDeserializer::new(v, self.is_human_readable)) + } + Content::Newtype(ref v) => { + visitor.visit_newtype_struct(ContentRefDeserializer::new(v, self.is_human_readable)) + } + Content::Seq(ref v) => visit_content_seq_ref(v, visitor, self.is_human_readable), + Content::Map(ref v) => visit_content_map_ref(v, visitor, self.is_human_readable), + } + } + + fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::Bool(v) => visitor.visit_bool(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_integer(visitor) + } + + fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_float(visitor) + } + + fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_float(visitor) + } + + fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::Char(v) => visitor.visit_char(v), + Content::String(ref v) => visitor.visit_str(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::String(ref v) => visitor.visit_str(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(ref v) => visitor.visit_bytes(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_str(visitor) + } + + fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::String(ref v) => visitor.visit_str(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(ref v) => visitor.visit_bytes(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + Content::Seq(ref v) => visit_content_seq_ref(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_bytes(visitor) + } + + fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match *self.content { + Content::None => visitor.visit_none(), + Content::Some(ref v) => { + visitor.visit_some(ContentRefDeserializer::new(v, self.is_human_readable)) + } + Content::Unit => visitor.visit_unit(), + _ => visitor.visit_some(self), + } + } + + fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::Unit => visitor.visit_unit(), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_unit_struct<V>( + self, + _name: &'static str, + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_unit(visitor) + } + + fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E> + where + V: Visitor<'de>, + { + match *self.content { + Content::Newtype(ref v) => { + visitor.visit_newtype_struct(ContentRefDeserializer::new(v, self.is_human_readable)) + } + _ => visitor.visit_newtype_struct(self), + } + } + + fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::Seq(ref v) => visit_content_seq_ref(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_seq(visitor) + } + + fn deserialize_tuple_struct<V>( + self, + _name: &'static str, + _len: usize, + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_seq(visitor) + } + + fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::Map(ref v) => visit_content_map_ref(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_struct<V>( + self, + _name: &'static str, + _fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::Seq(ref v) => visit_content_seq_ref(v, visitor, self.is_human_readable), + Content::Map(ref v) => visit_content_map_ref(v, visitor, self.is_human_readable), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_enum<V>( + self, + _name: &str, + _variants: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + let (variant, value) = match *self.content { + Content::Map(ref value) => { + let mut iter = value.iter(); + let (variant, value) = match iter.next() { + Some(v) => v, + None => { + return Err(DeError::invalid_value( + Unexpected::Map, + &"map with a single key", + )); + } + }; + // enums are encoded in json as maps with a single key:value pair + if iter.next().is_some() { + return Err(DeError::invalid_value( + Unexpected::Map, + &"map with a single key", + )); + } + (variant, Some(value)) + } + ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None), + ref other => { + return Err(DeError::invalid_type(other.unexpected(), &"string or map")); + } + }; + + visitor.visit_enum(EnumRefDeserializer { + is_human_readable: self.is_human_readable, + variant, + value, + err: PhantomData, + }) + } + + fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match *self.content { + Content::String(ref v) => visitor.visit_str(v), + Content::Str(v) => visitor.visit_borrowed_str(v), + Content::ByteBuf(ref v) => visitor.visit_bytes(v), + Content::Bytes(v) => visitor.visit_borrowed_bytes(v), + Content::U8(v) => visitor.visit_u8(v), + Content::U64(v) => visitor.visit_u64(v), + _ => Err(self.invalid_type(&visitor)), + } + } + + fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + visitor.visit_unit() + } +} + +impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> { + /// private API, don't use + pub(crate) fn new(content: &'a Content<'de>, is_human_readable: bool) -> Self { + ContentRefDeserializer { + is_human_readable, + content, + err: PhantomData, + } + } +} + +struct EnumRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + is_human_readable: bool, + variant: &'a Content<'de>, + value: Option<&'a Content<'de>>, + err: PhantomData<E>, +} + +impl<'de, 'a, E> EnumAccess<'de> for EnumRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + type Variant = VariantRefDeserializer<'a, 'de, Self::Error>; + + fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> + where + V: DeserializeSeed<'de>, + { + let visitor = VariantRefDeserializer { + is_human_readable: self.is_human_readable, + value: self.value, + err: PhantomData, + }; + seed.deserialize(ContentRefDeserializer::new( + self.variant, + self.is_human_readable, + )) + .map(|v| (v, visitor)) + } +} + +struct VariantRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + is_human_readable: bool, + value: Option<&'a Content<'de>>, + err: PhantomData<E>, +} + +impl<'de, 'a, E> VariantAccess<'de> for VariantRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + + fn unit_variant(self) -> Result<(), E> { + match self.value { + Some(value) => { + Deserialize::deserialize(ContentRefDeserializer::new(value, self.is_human_readable)) + } + None => Ok(()), + } + } + + fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E> + where + T: DeserializeSeed<'de>, + { + match self.value { + Some(value) => { + seed.deserialize(ContentRefDeserializer::new(value, self.is_human_readable)) + } + None => Err(DeError::invalid_type( + Unexpected::UnitVariant, + &"newtype variant", + )), + } + } + + fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.value { + Some(Content::Seq(v)) => Deserializer::deserialize_any( + SeqRefDeserializer::new(v, self.is_human_readable), + visitor, + ), + Some(other) => Err(DeError::invalid_type(other.unexpected(), &"tuple variant")), + None => Err(DeError::invalid_type( + Unexpected::UnitVariant, + &"tuple variant", + )), + } + } + + fn struct_variant<V>( + self, + _fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + match self.value { + Some(Content::Map(v)) => Deserializer::deserialize_any( + MapRefDeserializer::new(v, self.is_human_readable), + visitor, + ), + Some(Content::Seq(v)) => Deserializer::deserialize_any( + SeqRefDeserializer::new(v, self.is_human_readable), + visitor, + ), + Some(other) => Err(DeError::invalid_type(other.unexpected(), &"struct variant")), + None => Err(DeError::invalid_type( + Unexpected::UnitVariant, + &"struct variant", + )), + } + } +} + +struct SeqRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + is_human_readable: bool, + iter: <&'a [Content<'de>] as IntoIterator>::IntoIter, + err: PhantomData<E>, +} + +impl<'a, 'de, E> SeqRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + fn new(slice: &'a [Content<'de>], is_human_readable: bool) -> Self { + SeqRefDeserializer { + is_human_readable, + iter: slice.iter(), + err: PhantomData, + } + } +} + +impl<'de, 'a, E> Deserializer<'de> for SeqRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + + #[inline] + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + #[inline] + fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + let len = self.iter.len(); + if len == 0 { + visitor.visit_unit() + } else { + let ret = visitor.visit_seq(&mut self)?; + let remaining = self.iter.len(); + if remaining == 0 { + Ok(ret) + } else { + Err(DeError::invalid_length(len, &"fewer elements in array")) + } + } + } + + 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, E> SeqAccess<'de> for SeqRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + + fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.iter.next() { + Some(value) => seed + .deserialize(ContentRefDeserializer::new(value, self.is_human_readable)) + .map(Some), + None => Ok(None), + } + } + + fn size_hint(&self) -> Option<usize> { + size_hint_from_bounds(&self.iter) + } +} + +struct MapRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + is_human_readable: bool, + iter: <&'a [(Content<'de>, Content<'de>)] as IntoIterator>::IntoIter, + value: Option<&'a Content<'de>>, + err: PhantomData<E>, +} + +impl<'a, 'de, E> MapRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + fn new(map: &'a [(Content<'de>, Content<'de>)], is_human_readable: bool) -> Self { + MapRefDeserializer { + is_human_readable, + iter: map.iter(), + value: None, + err: PhantomData, + } + } +} + +impl<'de, 'a, E> MapAccess<'de> for MapRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + + fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.iter.next() { + Some((key, value)) => { + self.value = Some(value); + seed.deserialize(ContentRefDeserializer::new(key, self.is_human_readable)) + .map(Some) + } + None => Ok(None), + } + } + + fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> + where + T: DeserializeSeed<'de>, + { + match self.value.take() { + Some(value) => { + seed.deserialize(ContentRefDeserializer::new(value, self.is_human_readable)) + } + None => Err(DeError::custom("value is missing")), + } + } + + fn size_hint(&self) -> Option<usize> { + size_hint_from_bounds(&self.iter) + } +} + +impl<'de, 'a, E> Deserializer<'de> for MapRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Error = E; + + #[inline] + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + #[inline] + 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, E> IntoDeserializer<'de, E> for ContentDeserializer<'de, E> +where + E: DeError, +{ + type Deserializer = Self; + + fn into_deserializer(self) -> Self { + self + } +} + +impl<'de, 'a, E> IntoDeserializer<'de, E> for ContentRefDeserializer<'a, 'de, E> +where + E: DeError, +{ + type Deserializer = Self; + + fn into_deserializer(self) -> Self { + self + } +} 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..f513cb7fff --- /dev/null +++ b/third_party/rust/serde_with/src/content/mod.rs @@ -0,0 +1,8 @@ +//! Import of the unstable private `Content` type from `serde`. +//! +//! <https://github.com/serde-rs/serde/blob/55a7cedd737278a9d75a2efd038c6f38b8c38bd6/serde/src/private/ser.rs#L338-L997> + +#![cfg(not(tarpaulin_include))] + +pub(crate) mod de; +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..c7570545a0 --- /dev/null +++ b/third_party/rust/serde_with/src/content/ser.rs @@ -0,0 +1,624 @@ +//! 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 crate::prelude::*; + +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 Content { + pub(crate) fn as_str(&self) -> Option<&str> { + match self { + Self::String(ref x) => Some(x), + Self::Bytes(x) => core::str::from_utf8(x).ok(), + _ => None, + } + } +} + +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) => { + let mut tuple = serializer.serialize_tuple(elements.len())?; + for e in elements { + tuple.serialize_element(e)?; + } + tuple.end() + } + Content::TupleStruct(n, ref fields) => { + 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) => { + 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) => { + let mut map = serializer.serialize_map(Some(entries.len()))?; + for (k, v) in entries { + map.serialize_entry(k, v)?; + } + map.end() + } + Content::Struct(n, ref fields) => { + let mut s = serializer.serialize_struct(n, fields.len())?; + for (k, v) in fields { + s.serialize_field(k, v)?; + } + s.end() + } + Content::StructVariant(n, i, v, ref fields) => { + let mut sv = serializer.serialize_struct_variant(n, i, v, fields.len())?; + for (k, 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: SerError, +{ + type Ok = Content; + type Error = E; + + type SerializeSeq = SeqSerialize<E>; + type SerializeTuple = TupleSerialize<E>; + type SerializeTupleStruct = TupleStructSerialize<E>; + type SerializeTupleVariant = TupleVariantSerialize<E>; + type SerializeMap = MapSerialize<E>; + type SerializeStruct = StructSerialize<E>; + type SerializeStructVariant = StructVariantSerialize<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(SeqSerialize { + 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(TupleSerialize { + 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(TupleStructSerialize { + 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(TupleVariantSerialize { + 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(MapSerialize { + 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(StructSerialize { + 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(StructVariantSerialize { + is_human_readable: self.is_human_readable, + name, + variant_index, + variant, + fields: Vec::with_capacity(len), + error: PhantomData, + }) + } +} + +pub(crate) struct SeqSerialize<E> { + is_human_readable: bool, + elements: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> SerializeSeq for SeqSerialize<E> +where + E: SerError, +{ + 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 TupleSerialize<E> { + is_human_readable: bool, + elements: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> SerializeTuple for TupleSerialize<E> +where + E: SerError, +{ + 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 TupleStructSerialize<E> { + is_human_readable: bool, + name: &'static str, + fields: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> SerializeTupleStruct for TupleStructSerialize<E> +where + E: SerError, +{ + 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 TupleVariantSerialize<E> { + is_human_readable: bool, + name: &'static str, + variant_index: u32, + variant: &'static str, + fields: Vec<Content>, + error: PhantomData<E>, +} + +impl<E> SerializeTupleVariant for TupleVariantSerialize<E> +where + E: SerError, +{ + 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 MapSerialize<E> { + is_human_readable: bool, + entries: Vec<(Content, Content)>, + key: Option<Content>, + error: PhantomData<E>, +} + +impl<E> SerializeMap for MapSerialize<E> +where + E: SerError, +{ + 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 StructSerialize<E> { + is_human_readable: bool, + name: &'static str, + fields: Vec<(&'static str, Content)>, + error: PhantomData<E>, +} + +impl<E> SerializeStruct for StructSerialize<E> +where + E: SerError, +{ + 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 StructVariantSerialize<E> { + is_human_readable: bool, + name: &'static str, + variant_index: u32, + variant: &'static str, + fields: Vec<(&'static str, Content)>, + error: PhantomData<E>, +} + +impl<E> SerializeStructVariant for StructVariantSerialize<E> +where + E: SerError, +{ + 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/duplicates.rs b/third_party/rust/serde_with/src/de/duplicates.rs new file mode 100644 index 0000000000..a03dfba2f5 --- /dev/null +++ b/third_party/rust/serde_with/src/de/duplicates.rs @@ -0,0 +1,223 @@ +use super::impls::{foreach_map_create, foreach_set_create}; +use crate::{ + duplicate_key_impls::{ + DuplicateInsertsFirstWinsMap, DuplicateInsertsLastWinsSet, PreventDuplicateInsertsMap, + PreventDuplicateInsertsSet, + }, + prelude::*, + MapFirstKeyWins, MapPreventDuplicates, SetLastValueWins, SetPreventDuplicates, +}; +#[cfg(feature = "indexmap_1")] +use indexmap_1::{IndexMap, IndexSet}; + +struct SetPreventDuplicatesVisitor<SET, T, TAs>(PhantomData<(SET, T, TAs)>); + +impl<'de, SET, T, TAs> Visitor<'de> for SetPreventDuplicatesVisitor<SET, T, TAs> +where + SET: PreventDuplicateInsertsSet<T>, + TAs: DeserializeAs<'de, T>, +{ + type Value = SET; + + 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::<DeserializeAsWrap<T, TAs>>()? { + if !values.insert(value.into_inner()) { + return Err(DeError::custom("invalid entry: found duplicate value")); + }; + } + + Ok(values) + } +} + +struct SetLastValueWinsVisitor<SET, T, TAs>(PhantomData<(SET, T, TAs)>); + +impl<'de, SET, T, TAs> Visitor<'de> for SetLastValueWinsVisitor<SET, T, TAs> +where + SET: DuplicateInsertsLastWinsSet<T>, + TAs: DeserializeAs<'de, T>, +{ + type Value = SET; + + 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::<DeserializeAsWrap<T, TAs>>()? { + values.replace(value.into_inner()); + } + + Ok(values) + } +} + +#[cfg(feature = "alloc")] +macro_rules! set_impl { + ( + $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)* )* >, + $with_capacity:expr, + $append:ident + ) => { + impl<'de, T, TAs $(, $typaram)*> DeserializeAs<'de, $ty<T $(, $typaram)*>> for SetPreventDuplicates<TAs> + where + TAs: 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>, + { + deserializer.deserialize_seq(SetPreventDuplicatesVisitor::<$ty<T $(, $typaram)*>, T, TAs>( + PhantomData, + )) + } + } + + impl<'de, T, TAs $(, $typaram)*> DeserializeAs<'de, $ty<T $(, $typaram)*>> for SetLastValueWins<TAs> + where + TAs: 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>, + { + deserializer + .deserialize_seq(SetLastValueWinsVisitor::<$ty<T $(, $typaram)*>, T, TAs>(PhantomData)) + } + } + } +} +foreach_set_create!(set_impl); + +struct MapPreventDuplicatesVisitor<MAP, K, KAs, V, VAs>(PhantomData<(MAP, K, KAs, V, VAs)>); + +impl<'de, MAP, K, KAs, V, VAs> Visitor<'de> for MapPreventDuplicatesVisitor<MAP, K, KAs, V, VAs> +where + MAP: PreventDuplicateInsertsMap<K, V>, + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, +{ + type Value = MAP; + + 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::<DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>>()? + { + if !values.insert(key.into_inner(), value.into_inner()) { + return Err(DeError::custom("invalid entry: found duplicate key")); + }; + } + + Ok(values) + } +} + +struct MapFirstKeyWinsVisitor<MAP, K, KAs, V, VAs>(PhantomData<(MAP, K, KAs, V, VAs)>); + +impl<'de, MAP, K, KAs, V, VAs> Visitor<'de> for MapFirstKeyWinsVisitor<MAP, K, KAs, V, VAs> +where + MAP: DuplicateInsertsFirstWinsMap<K, V>, + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, +{ + type Value = MAP; + + 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::<DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>>()? + { + values.insert(key.into_inner(), value.into_inner()); + } + + Ok(values) + } +} + +#[cfg(feature = "alloc")] +macro_rules! map_impl { + ( + $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >, + $with_capacity:expr + ) => { + impl<'de, K, V, KAs, VAs $(, $typaram)*> DeserializeAs<'de, $ty<K, V $(, $typaram)*>> + for MapPreventDuplicates<KAs, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: 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>, + { + deserializer.deserialize_map(MapPreventDuplicatesVisitor::< + $ty<K, V $(, $typaram)*>, + K, + KAs, + V, + VAs, + >(PhantomData)) + } + } + + impl<'de, K, V, KAs, VAs $(, $typaram)*> DeserializeAs<'de, $ty<K, V $(, $typaram)*>> + for MapFirstKeyWins<KAs, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: 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>, + { + deserializer.deserialize_map(MapFirstKeyWinsVisitor::<$ty<K, V $(, $typaram)*>, K, KAs, V, VAs>( + PhantomData, + )) + } + } + }; +} +foreach_map_create!(map_impl); 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..066ad57490 --- /dev/null +++ b/third_party/rust/serde_with/src/de/impls.rs @@ -0,0 +1,1937 @@ +use crate::{formats::*, prelude::*}; +#[cfg(feature = "indexmap_1")] +use indexmap_1::{IndexMap, IndexSet}; + +/////////////////////////////////////////////////////////////////////////////// +// Helper macro used internally + +#[cfg(feature = "alloc")] +type BoxedSlice<T> = Box<[T]>; + +macro_rules! foreach_map { + ($m:ident) => { + #[cfg(feature = "alloc")] + $m!(BTreeMap<K: Ord, V>); + #[cfg(feature = "std")] + $m!(HashMap<K: Eq + Hash, V, H: Sized>); + #[cfg(all(feature = "std", feature = "indexmap_1"))] + $m!(IndexMap<K: Eq + Hash, V, H: Sized>); + }; +} +pub(crate) use foreach_map; + +macro_rules! foreach_map_create { + ($m:ident) => { + #[cfg(feature = "alloc")] + $m!(BTreeMap<K: Ord, V>, + (|_size| BTreeMap::new())); + #[cfg(feature = "std")] + $m!(HashMap<K: Eq + Hash, V, S: BuildHasher + Default>, + (|size| HashMap::with_capacity_and_hasher(size, Default::default()))); + #[cfg(feature = "indexmap_1")] + $m!(IndexMap<K: Eq + Hash, V, S: BuildHasher + Default>, + (|size| IndexMap::with_capacity_and_hasher(size, Default::default()))); + } +} +pub(crate) use foreach_map_create; + +macro_rules! foreach_set { + ($m:ident) => { + #[cfg(feature = "alloc")] + $m!(BTreeSet<(K, V): Ord>); + #[cfg(feature = "std")] + $m!(HashSet<(K, V): Eq + Hash>); + #[cfg(all(feature = "std", feature = "indexmap_1"))] + $m!(IndexSet<(K, V): Eq + Hash>); + } +} +pub(crate) use foreach_set; + +macro_rules! foreach_set_create { + ($m:ident) => { + #[cfg(feature = "alloc")] + $m!(BTreeSet<T: Ord>, (|_| BTreeSet::new()), insert); + #[cfg(feature = "std")] + $m!( + HashSet<T: Eq + Hash, S: BuildHasher + Default>, + (|size| HashSet::with_capacity_and_hasher(size, S::default())), + insert + ); + #[cfg(feature = "indexmap_1")] + $m!( + IndexSet<T: Eq + Hash, S: BuildHasher + Default>, + (|size| IndexSet::with_capacity_and_hasher(size, S::default())), + insert + ); + } +} +pub(crate) use foreach_set_create; + +macro_rules! foreach_seq { + ($m:ident) => { + foreach_set!($m); + + #[cfg(feature = "alloc")] + $m!(BinaryHeap<(K, V): Ord>); + #[cfg(feature = "alloc")] + $m!(LinkedList<(K, V)>); + #[cfg(feature = "alloc")] + $m!(Vec<(K, V)>); + #[cfg(feature = "alloc")] + $m!(VecDeque<(K, V)>); + } +} +pub(crate) use foreach_seq; + +macro_rules! foreach_seq_create { + ($m:ident) => { + foreach_set_create!($m); + + #[cfg(feature = "alloc")] + $m!( + BinaryHeap<T: Ord>, + (|size| BinaryHeap::with_capacity(size)), + push + ); + #[cfg(feature = "alloc")] + $m!(BoxedSlice<T>, (|size| Vec::with_capacity(size)), push); + #[cfg(feature = "alloc")] + $m!(LinkedList<T>, (|_| LinkedList::new()), push_back); + #[cfg(feature = "alloc")] + $m!(Vec<T>, (|size| Vec::with_capacity(size)), push); + #[cfg(feature = "alloc")] + $m!( + VecDeque<T>, + (|size| VecDeque::with_capacity(size)), + push_back + ); + }; +} +pub(crate) use foreach_seq_create; + +/////////////////////////////////////////////////////////////////////////////// +// region: Simple Wrapper types (e.g., Box, Option) + +#[cfg(feature = "alloc")] +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: DeError, + { + Ok(None) + } + + #[inline] + fn visit_none<E>(self) -> Result<Self::Value, E> + where + E: DeError, + { + 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)) + } +} + +#[cfg(feature = "alloc")] +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(), + )) + } +} + +#[cfg(feature = "alloc")] +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()) + } +} + +#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))] +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(), + )) + } +} + +#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))] +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(), + )) + } +} + +#[cfg(feature = "std")] +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(), + )) + } +} + +#[cfg(feature = "std")] +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()), + }, + ) + } +} + +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>, + { + utils::array_from_iterator( + utils::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)) + } +} + +// endregion +/////////////////////////////////////////////////////////////////////////////// +// region: Collection Types (e.g., Maps, Sets, Vec) + +#[cfg(feature = "alloc")] +macro_rules! seq_impl { + ( + $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2: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 seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + let mut values = ($with_capacity)(utils::size_hint_cautious(seq.size_hint())); + + while let Some(value) = seq + .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) + } + } + }; +} +foreach_seq_create!(seq_impl); + +#[cfg(feature = "alloc")] +macro_rules! map_impl { + ( + $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2: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)*>(PhantomData<(K, V, 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 map: A) -> Result<Self::Value, A::Error> + where + A: MapAccess<'de>, + { + let mut values = ($with_capacity)(utils::size_hint_cautious(map.size_hint())); + + while let Some((key, value)) = (map.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)*> (PhantomData); + deserializer.deserialize_map(visitor) + } + } + } +} +foreach_map_create!(map_impl); + +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(DeError::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); + +#[cfg(feature = "alloc")] +macro_rules! map_as_tuple_seq_intern { + ($tyorig:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >, $ty:ident <(KAs, VAs)>) => { + 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: $kbound1 $(+ $kbound2)*,)* + { + fn deserialize_as<D>(deserializer: D) -> Result<$tyorig<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 = $tyorig<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) + } + } + }; +} +#[cfg(feature = "alloc")] +macro_rules! map_as_tuple_seq { + ($tyorig:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >) => { + map_as_tuple_seq_intern!($tyorig < K $(: $kbound1 $(+ $kbound2)*)* , V $(, $typaram : $bound1 $(+ $bound2)*)* > , Seq<(KAs, VAs)>); + #[cfg(feature = "alloc")] + map_as_tuple_seq_intern!($tyorig < K $(: $kbound1 $(+ $kbound2)*)* , V $(, $typaram : $bound1 $(+ $bound2)*)* >, Vec<(KAs, VAs)>); + } +} +foreach_map!(map_as_tuple_seq); + +#[cfg(feature = "alloc")] +macro_rules! tuple_seq_as_map_impl_intern { + ($tyorig:ident < (K, V) $(: $($bound: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, V): $($($bound +)*)*, + { + 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, V): $($($bound +)*)*, + { + 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) + } + } + } +} +#[cfg(feature = "alloc")] +macro_rules! tuple_seq_as_map_impl { + ($tyorig:ident < (K, V) $(: $($bound:ident $(+)?)+)?>) => { + tuple_seq_as_map_impl_intern!($tyorig < (K, V) $(: $($bound +)+)? >, Map<KAs, VAs>); + #[cfg(feature = "alloc")] + tuple_seq_as_map_impl_intern!($tyorig < (K, V) $(: $($bound +)+)? >, BTreeMap<KAs, VAs>); + #[cfg(feature = "std")] + tuple_seq_as_map_impl_intern!($tyorig < (K, V) $(: $($bound +)+)? >, HashMap<KAs, VAs>); + } +} +foreach_seq!(tuple_seq_as_map_impl); + +// Option does not implement FromIterator directly, so we need a different implementation +#[cfg(feature = "alloc")] +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) + } + } + }; +} +#[cfg(feature = "alloc")] +tuple_seq_as_map_option_impl!(BTreeMap); +#[cfg(feature = "std")] +tuple_seq_as_map_option_impl!(HashMap); + +macro_rules! tuple_seq_as_map_arr { + ($ty:ident <KAs, VAs>) => { + #[allow(clippy::implicit_hasher)] + impl<'de, K, KAs, V, VAs, const N: usize> DeserializeAs<'de, [(K, V); N]> for $ty<KAs, VAs> + where + KAs: DeserializeAs<'de, K>, + VAs: DeserializeAs<'de, V>, + { + fn deserialize_as<D>(deserializer: D) -> Result<[(K, V); N], 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>, + { + utils::array_from_iterator(utils::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_arr!(Map<KAs, VAs>); +#[cfg(feature = "alloc")] +tuple_seq_as_map_arr!(BTreeMap<KAs, VAs>); +#[cfg(feature = "std")] +tuple_seq_as_map_arr!(HashMap<KAs, VAs>); + +// 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>, + { + 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: DeError, + { + value.parse::<Self::Value>().map_err(DeError::custom) + } + } + + deserializer.deserialize_str(Helper(PhantomData)) + } +} + +#[cfg(feature = "alloc")] +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>, + { + enum GoodOrError<T, TAs> { + Good(T), + // Only here to consume the TAs generic + Error(PhantomData<TAs>), + } + + impl<'de, T, TAs> Deserialize<'de> for GoodOrError<T, TAs> + where + TAs: DeserializeAs<'de, T>, + { + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + let is_hr = deserializer.is_human_readable(); + let content: content::de::Content<'de> = Deserialize::deserialize(deserializer)?; + + Ok( + match <DeserializeAsWrap<T, TAs>>::deserialize( + content::de::ContentDeserializer::<D::Error>::new(content, is_hr), + ) { + Ok(elem) => GoodOrError::Good(elem.into_inner()), + Err(_) => GoodOrError::Error(PhantomData), + }, + ) + } + } + + struct SeqVisitor<T, U> { + marker: PhantomData<T>, + marker2: PhantomData<U>, + } + + impl<'de, T, TAs> Visitor<'de> for SeqVisitor<T, TAs> + where + TAs: 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, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + utils::SeqIter::new(seq) + .filter_map(|res: Result<GoodOrError<T, TAs>, A::Error>| match res { + Ok(GoodOrError::Good(value)) => Some(Ok(value)), + Ok(GoodOrError::Error(_)) => None, + Err(err) => Some(Err(err)), + }) + .collect() + } + } + + 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>, + { + 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("a string") + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: DeError, + { + match value { + "" => Ok(None), + v => S::from_str(v).map(Some).map_err(DeError::custom), + } + } + + // handles the `null` case + fn visit_unit<E>(self) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(None) + } + } + + deserializer.deserialize_any(OptionStringEmptyNone(PhantomData)) + } +} + +#[cfg(feature = "alloc")] +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>, + { + let is_hr = deserializer.is_human_readable(); + let content: content::de::Content<'de> = match Deserialize::deserialize(deserializer) { + Ok(content) => content, + Err(_) => return Ok(Default::default()), + }; + + Ok( + match <DeserializeAsWrap<T, TAs>>::deserialize(content::de::ContentDeserializer::< + D::Error, + >::new(content, is_hr)) + { + Ok(elem) => elem.into_inner(), + Err(_) => Default::default(), + }, + ) + } +} + +#[cfg(feature = "alloc")] +impl<'de> DeserializeAs<'de, Vec<u8>> for BytesOrString { + fn deserialize_as<D>(deserializer: D) -> Result<Vec<u8>, D::Error> + where + D: Deserializer<'de>, + { + 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()) + } + + #[cfg(feature = "alloc")] + 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()) + } + + #[cfg(feature = "alloc")] + 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() + } + } + deserializer.deserialize_any(BytesOrStringVisitor) + } +} + +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>, + { + struct Helper<SEPARATOR, I, T>(PhantomData<(SEPARATOR, I, T)>); + + impl<'de, SEPARATOR, I, T> Visitor<'de> for Helper<SEPARATOR, I, T> + where + SEPARATOR: Separator, + I: FromIterator<T>, + T: FromStr, + T::Err: Display, + { + type Value = I; + + 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: DeError, + { + if value.is_empty() { + Ok(None.into_iter().collect()) + } else { + value + .split(SEPARATOR::separator()) + .map(FromStr::from_str) + .collect::<Result<_, _>>() + .map_err(DeError::custom) + } + } + } + + deserializer.deserialize_str(Helper::<SEPARATOR, I, T>(PhantomData)) + } +} + +#[cfg(feature = "std")] +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); )+ + }; +} + +#[cfg(feature = "std")] +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} + } +); +#[cfg(feature = "std")] +use_signed_duration!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration; to_std_duration => + {f64, Strict =>} + {String, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); + +#[cfg(feature = "std")] +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} + } +); +#[cfg(feature = "std")] +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 +#[cfg(feature = "alloc")] +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: DeError, + { + Ok(v.to_vec()) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v.as_bytes().to_vec()) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v.into_bytes()) + } + } + + deserializer.deserialize_byte_buf(VecVisitor) + } +} + +#[cfg(feature = "alloc")] +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 +#[cfg(feature = "alloc")] +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: DeError, + { + Ok(Cow::Borrowed(v)) + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Borrowed(v.as_bytes())) + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned(v.to_vec())) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned(v.as_bytes().to_vec())) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned(v)) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: DeError, + { + 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, 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>, + { + utils::array_from_iterator(utils::SeqIter::new(seq), &self) + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: DeError, + { + v.try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self)) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: DeError, + { + v.as_bytes() + .try_into() + .map_err(|_| DeError::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: DeError, + { + v.try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self)) + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: DeError, + { + v.as_bytes() + .try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self)) + } + } + + deserializer.deserialize_bytes(ArrayVisitor::<N>) + } +} + +#[cfg(feature = "alloc")] +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: DeError, + { + Ok(Cow::Borrowed( + v.try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self))?, + )) + } + + fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Borrowed( + v.as_bytes() + .try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self))?, + )) + } + + fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned( + v.to_vec() + .try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self))?, + )) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned( + v.as_bytes() + .to_vec() + .try_into() + .map_err(|_| DeError::invalid_length(v.len(), &self))?, + )) + } + + fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> + where + E: DeError, + { + let len = v.len(); + Ok(Cow::Owned( + v.try_into() + .map_err(|_| DeError::invalid_length(len, &self))?, + )) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: DeError, + { + let len = v.len(); + Ok(Cow::Owned( + v.into_bytes() + .try_into() + .map_err(|_| DeError::invalid_length(len, &self))?, + )) + } + + fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error> + where + V: SeqAccess<'de>, + { + Ok(Cow::Owned(utils::array_from_iterator( + utils::SeqIter::new(seq), + &self, + )?)) + } + } + + deserializer.deserialize_bytes(CowVisitor) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +impl<'de, T, TAs, FORMAT> DeserializeAs<'de, Vec<T>> for OneOrMany<TAs, FORMAT> +where + TAs: DeserializeAs<'de, T>, + FORMAT: Format, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error> + where + D: Deserializer<'de>, + { + let is_hr = deserializer.is_human_readable(); + let content: content::de::Content<'de> = Deserialize::deserialize(deserializer)?; + + let one_err: D::Error = match <DeserializeAsWrap<T, TAs>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(one) => return Ok(alloc::vec![one.into_inner()]), + Err(err) => err, + }; + let many_err: D::Error = match <DeserializeAsWrap<Vec<T>, Vec<TAs>>>::deserialize( + content::de::ContentDeserializer::new(content, is_hr), + ) { + Ok(many) => return Ok(many.into_inner()), + Err(err) => err, + }; + Err(DeError::custom(format_args!( + "OneOrMany could not deserialize any variant:\n One: {}\n Many: {}", + one_err, many_err + ))) + } +} + +#[cfg(feature = "alloc")] +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()) + } +} + +#[cfg(feature = "alloc")] +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>, + { + let is_hr = deserializer.is_human_readable(); + let content: content::de::Content<'de> = Deserialize::deserialize(deserializer)?; + + let first_err: D::Error = match <DeserializeAsWrap<T, TAs1>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(first) => return Ok(first.into_inner()), + Err(err) => err, + }; + let second_err: D::Error = match <DeserializeAsWrap<T, TAs2>>::deserialize( + content::de::ContentDeserializer::new(content, is_hr), + ) { + Ok(second) => return Ok(second.into_inner()), + Err(err) => err, + }; + Err(DeError::custom(format_args!( + "PickFirst could not deserialize any variant:\n First: {}\n Second: {}", + first_err, second_err + ))) + } +} + +#[cfg(feature = "alloc")] +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>, + { + let is_hr = deserializer.is_human_readable(); + let content: content::de::Content<'de> = Deserialize::deserialize(deserializer)?; + + let first_err: D::Error = match <DeserializeAsWrap<T, TAs1>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(first) => return Ok(first.into_inner()), + Err(err) => err, + }; + let second_err: D::Error = match <DeserializeAsWrap<T, TAs2>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(second) => return Ok(second.into_inner()), + Err(err) => err, + }; + let third_err: D::Error = match <DeserializeAsWrap<T, TAs3>>::deserialize( + content::de::ContentDeserializer::new(content, is_hr), + ) { + Ok(third) => return Ok(third.into_inner()), + Err(err) => err, + }; + Err(DeError::custom(format_args!( + "PickFirst could not deserialize any variant:\n First: {}\n Second: {}\n Third: {}", + first_err, second_err, third_err, + ))) + } +} + +#[cfg(feature = "alloc")] +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>, + { + let is_hr = deserializer.is_human_readable(); + let content: content::de::Content<'de> = Deserialize::deserialize(deserializer)?; + + let first_err: D::Error = match <DeserializeAsWrap<T, TAs1>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(first) => return Ok(first.into_inner()), + Err(err) => err, + }; + let second_err: D::Error = match <DeserializeAsWrap<T, TAs2>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(second) => return Ok(second.into_inner()), + Err(err) => err, + }; + let third_err: D::Error = match <DeserializeAsWrap<T, TAs3>>::deserialize( + content::de::ContentRefDeserializer::new(&content, is_hr), + ) { + Ok(third) => return Ok(third.into_inner()), + Err(err) => err, + }; + let fourth_err: D::Error = match <DeserializeAsWrap<T, TAs4>>::deserialize( + content::de::ContentDeserializer::new(content, is_hr), + ) { + Ok(fourth) => return Ok(fourth.into_inner()), + Err(err) => err, + }; + Err(DeError::custom(format_args!( + "PickFirst could not deserialize any variant:\n First: {}\n Second: {}\n Third: {}\n Fourth: {}", + first_err, second_err, third_err, fourth_err, + ))) + } +} + +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(DeError::custom) + } +} + +#[cfg(feature = "alloc")] +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: DeError, + { + Ok(Cow::Borrowed(v)) + } + + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned(v.to_owned())) + } + + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(Cow::Owned(v)) + } + } + + deserializer.deserialize_string(CowVisitor) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +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: DeError, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(DeError::invalid_value( + Unexpected::Unsigned(unexp as u64), + &"0 or 1", + )), + } + } + + fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> + where + E: DeError, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(DeError::invalid_value( + Unexpected::Signed(unexp as i64), + &"0 or 1", + )), + } + } + + fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> + where + E: DeError, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(DeError::invalid_value( + Unexpected::Unsigned(unexp), + &"0 or 1", + )), + } + } + + fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> + where + E: DeError, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(DeError::invalid_value(Unexpected::Signed(unexp), &"0 or 1")), + } + } + + fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> + where + E: DeError, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(DeError::invalid_value( + Unexpected::Unsigned(unexp as u64), + &"0 or 1", + )), + } + } + + fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> + where + E: DeError, + { + match v { + 0 => Ok(false), + 1 => Ok(true), + unexp => Err(DeError::invalid_value( + Unexpected::Signed(unexp as i64), + &"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: DeError, + { + Ok(v != 0) + } + + fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v != 0) + } + + fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v != 0) + } + + fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v != 0) + } + + fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v != 0) + } + + fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> + where + E: DeError, + { + Ok(v != 0) + } + } + + deserializer.deserialize_u8(U8Visitor) + } +} + +// endregion 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..f9eb312498 --- /dev/null +++ b/third_party/rust/serde_with/src/de/mod.rs @@ -0,0 +1,158 @@ +//! 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 + +#[cfg(feature = "alloc")] +mod duplicates; +mod impls; + +use crate::prelude::*; + +/// 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 be 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::{serde_as, 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_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. +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, + }) + } +} + +impl<T: ?Sized> As<T> { + /// 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) + } +} 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..0c482c5ded --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs @@ -0,0 +1,127 @@ +use crate::prelude::*; +#[cfg(feature = "indexmap_1")] +use indexmap_1::{IndexMap, IndexSet}; + +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; +} + +#[cfg(feature = "std")] +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_1")] +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) + } +} + +#[cfg(feature = "std")] +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_1")] +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..5895eb6f66 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs @@ -0,0 +1,89 @@ +use crate::prelude::*; +#[cfg(feature = "indexmap_1")] +use indexmap_1::IndexMap; + +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); +} + +#[cfg(feature = "std")] +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_1")] +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_1::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..68b3fd7318 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs @@ -0,0 +1,68 @@ +use crate::prelude::*; +#[cfg(feature = "indexmap_1")] +use indexmap_1::IndexSet; + +pub trait DuplicateInsertsLastWinsSet<T> { + fn new(size_hint: Option<usize>) -> Self; + + /// Insert or replace the existing value + fn replace(&mut self, value: T); +} + +#[cfg(feature = "std")] +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_1")] +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..da3cdfc0f2 --- /dev/null +++ b/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs @@ -0,0 +1,9 @@ +mod error_on_duplicate; +mod first_value_wins; +mod last_value_wins; + +pub use self::{ + error_on_duplicate::{PreventDuplicateInsertsMap, PreventDuplicateInsertsSet}, + first_value_wins::DuplicateInsertsFirstWinsMap, + 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..bc6f1378ba --- /dev/null +++ b/third_party/rust/serde_with/src/enum_map.rs @@ -0,0 +1,921 @@ +use crate::{ + content::ser::{Content, ContentSerializer}, + prelude::*, +}; + +/// 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::{serde_as, 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_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::{serde_as, EnumMap}; +/// +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// enum EnumValue { +/// Int(i32), +/// String(String), +/// Unit, +/// } +/// +/// #[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#" +/// <?xml version="1.0" encoding="UTF-8"?> +/// <VecEnumValues> +/// <vec> +/// <Int>123</Int> +/// <String>FooBar</String> +/// <Int>456</Int> +/// <String>XXX</String> +/// <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); +/// # } +/// ``` +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> { + is_human_readable: bool, + phantom: 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 of enum values") + } + + fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> { + Vec::deserialize(SeqDeserializer { + delegate: map, + is_human_readable: self.is_human_readable, + }) + } + } + + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_map(EnumMapVisitor { + is_human_readable, + phantom: 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 is_human_readable(&self) -> bool { + self.0.is_human_readable() + } + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(SerError::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(SerError::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(SerError::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(SerError::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(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(SerError::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(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + Err(SerError::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(SerError::custom("wrong type for EnumMap")) + } +} + +/// Serialize a single element but turn the sequence into a map logic. +/// +/// It uses [`EnumAsMapElementSerializer`] 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 is_human_readable(&self) -> bool { + self.is_human_readable + } + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(SerError::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(SerError::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(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { + Err(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(SerError::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(SerError::custom("wrong type for EnumMap")) + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + Err(SerError::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> { + delegate: M, + is_human_readable: bool, +} + +impl<'de, M> Deserializer<'de> for SeqDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + 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>, + { + // We need to check if the map is done, or if there are still remaining elements. + // But we cannot ask the MapAccess directly. + // The only way is trying to deserialize, but we don't know the type yet. + // So we assume there is a value and try to deserialize it. + // If we later on find out that there is no value, we return a special error value, which we turn into `None`. + match seed.deserialize(EnumDeserializer { + delegate: &mut self.delegate, + is_human_readable: self.is_human_readable, + }) { + 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.delegate.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> { + delegate: M, + is_human_readable: bool, +} + +impl<'de, M> Deserializer<'de> for EnumDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + 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.delegate.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(DeError::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.delegate.next_value() + } + + fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error> + where + T: DeserializeSeed<'de>, + { + self.delegate.next_value_seed(seed) + } + + fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate + .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.delegate.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..6dab1618c3 --- /dev/null +++ b/third_party/rust/serde_with/src/flatten_maybe.rs @@ -0,0 +1,88 @@ +/// 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:tt) => { + fn $fn<'de, T, D>(deserializer: D) -> $crate::__private__::Result<T, D::Error> + where + T: $crate::serde::Deserialize<'de>, + D: $crate::serde::Deserializer<'de>, + { + use $crate::{ + __private__::{ + Option::{self, None, Some}, + Result::{self, Err, Ok}, + }, + 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..27228325f2 --- /dev/null +++ b/third_party/rust/serde_with/src/formats.rs @@ -0,0 +1,140 @@ +//! Specify the format and how lenient the deserialization is + +#[allow(unused_imports)] +use crate::prelude::*; + +/// 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] + 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 an i128 + i128 + /// Serialize into a u128 + u128 + + /// Serialize into a f32 + f32 + /// Serialize into a f64 + f64 + + /// Serialize into a bool + bool +); +#[cfg(feature = "alloc")] +impl_format!( + /// Serialize into a String + String +); + +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`]. +pub struct Strict; +impl Strictness for Strict {} + +/// Use a flexible deserialization behavior, see [`Strictness`]. +pub struct Flexible; +impl Strictness for Flexible {} + +/// 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 +pub struct SpaceSeparator; + +impl Separator for SpaceSeparator { + #[inline] + fn separator() -> &'static str { + " " + } +} + +/// Predefined separator using a single comma +pub struct CommaSeparator; + +impl Separator for CommaSeparator { + #[inline] + fn separator() -> &'static str { + "," + } +} + +/// Predefined separator using a single semicolon +pub struct SemicolonSeparator; + +impl Separator for SemicolonSeparator { + #[inline] + fn separator() -> &'static str { + ";" + } +} + +/// Predefined separator using a single semicolon +pub struct ColonSeparator; + +impl Separator for ColonSeparator { + #[inline] + fn separator() -> &'static str { + ":" + } +} 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..788d4c9201 --- /dev/null +++ b/third_party/rust/serde_with/src/guide.md @@ -0,0 +1,86 @@ +# `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` + +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. + +You mirror the type structure of the field you want to de/serialize. +You can specify converters for the inner types of a field, e.g., `Vec<DisplayFromStr>`. +The default de/serialization behavior can be restored by using `_` as a placeholder, e.g., `BTreeMap<_, DisplayFromStr>`. + +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, Map}; +# 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 = "Map<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. 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. + +## 3. 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. + +[`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..39b6d4e72c --- /dev/null +++ b/third_party/rust/serde_with/src/guide/feature_flags.md @@ -0,0 +1,88 @@ +# Available Feature Flags + +This crate has the following features which can be enabled. +Each entry will explain the feature in more detail. + +`serde_with` is fully `no_std` compatible. +Using it in a `no_std` environment requires using `default-features = false`, since `std` is enabled by default. + +1. [`alloc`](#alloc) +2. [`std` (default)](#std-default) +3. [`base64`](#base64) +4. [`chrono_0_4`](#chrono_0_4) +5. [`guide`](#guide) +6. [`hex`](#hex) +7. [`indexmap_1`](#indexmap_1) +8. [`json`](#json) +9. [`macros` (default)](#macros-default) +10. [`time_0_3`](#time_0_3) + +## `alloc` + +Enable support for types from the `alloc` crate when running in a `no_std` environment. + +## `std` (default) + +Enables support for various types from the std library. +This will enable `std` support in all dependencies too. +The feature enabled by default and also enables `alloc`. + +## `base64` + +The `base64` feature enables serializing data in base64 format. + +This pulls in `base64` as a dependency. +It enables the `alloc` feature. + +## `chrono_0_4` + +The `chrono_0_4` feature enables integration of `chrono_0_4` specific conversions. +This includes support for the timestamp and duration types. +More features are available in combination with `alloc` or `std`. +The legacy feature name `chrono` is still available for v1 compatability. + +This pulls in `chrono` v0.4 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. +It enables the `alloc` feature. + +## `indexmap_1` + +The `indexmap_1` feature enables implementations of `indexmap_1` specific checks. +This includes support for checking duplicate keys and duplicate values. +The legacy feature name `indexmap` is still available for v1 compatability. + +This pulls in `indexmap` as a dependency. +It enables the `alloc` feature. +Some functionality is only available when `std` is enabled too. + +## `json` + +The `json` features enables JSON conversions from the `json` module. + +This pulls in `serde_json` as a dependency. +It enables the `alloc` feature. + +## `macros` (default) + +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. +Some functionality is only available when `alloc` or `std` is enabled too. 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..2087906759 --- /dev/null +++ b/third_party/rust/serde_with/src/guide/serde_as.md @@ -0,0 +1,344 @@ +# `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. +You mirror the type structure of the field you want to de/serialize. +You can specify converters for the inner types of a field, e.g., `Vec<DisplayFromStr>`. +The default de/serialization behavior can be restored by using `_` as a placeholder, e.g., `BTreeMap<_, DisplayFromStr>`. + +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 + +In many cases using `serde_as` on a field of type `Option` should behave as expected. +This mean the field can still be missing during deserialization and will be filled with the value `None`. + +This "magic" can break in some cases. Then it becomes necessary to apply `#[serde(default)]` on the field in question. +If the field is of type `Option<T>` and the conversion type is of `Option<S>`, the default attribute is automatically applied. +These variants are detected as `Option`. +* `Option` +* `std::option::Option`, with or without leading `::` +* `core::option::Option`, with or without leading `::` + +Any renaming will interfere with the detection, such as `use std::option::Option as StdOption;`. +For more information you can inspect the documentation of the `serde_as` macro. + +```rust +# use serde::{Deserialize, Serialize}; +# use serde_with::{serde_as, DisplayFromStr}; +# +#[serde_as] +#[derive(Serialize, Deserialize)] +struct A { + #[serde_as(as = "Option<DisplayFromStr>")] + // In this situation boths `Option`s will be correctly identified and + // `#[serde(default)]` will be applied on this field. + 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..7cce186420 --- /dev/null +++ b/third_party/rust/serde_with/src/guide/serde_as_transformations.md @@ -0,0 +1,599 @@ +# 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. [Overwrite existing set values](#overwrite-existing-set-values) +20. [Pick first successful deserialization](#pick-first-successful-deserialization) +21. [Prefer the first map key when duplicates exist](#prefer-the-first-map-key-when-duplicates-exist) +22. [Prevent duplicate map keys](#prevent-duplicate-map-keys) +23. [Prevent duplicate set values](#prevent-duplicate-set-values) +24. [Struct fields as map keys](#struct-fields-as-map-keys) +25. [Timestamps as seconds since UNIX epoch](#timestamps-as-seconds-since-unix-epoch) +26. [Value into JSON String](#value-into-json-string) +27. [`Vec` of tuples to `Maps`](#vec-of-tuples-to-maps) +28. [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 = "Seq<(_, _)>")] // also works with Vec +value: HashMap<String, u32>, // also works with other maps like BTreeMap or IndexMap + +// 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 +``` + +## Overwrite existing set values + +[`SetLastValueWins`] + +serdes default behavior for sets is to take the first value, when multiple "equal" values are inserted into a set. +This changes the logic, to prefer the last value. + +## 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", +``` + +## Prefer the first map key when duplicates exist + +[`MapFirstKeyWins`] + +serdes default behavior is to take the last key and value combination, if multiple "equal" keys exist. +This changes the logic to instead prefer the first found key-value combination. + +## Prevent duplicate map keys + +[`MapPreventDuplicates`] + +Error during deserialization, when duplicate map keys are detected. + +## Prevent duplicate set values + +[`SetPreventDuplicates`] + +Error during deserialization, when duplicate set values are detected. + +## Struct fields as map keys + +[`KeyValueMap`] + +This conversion is possible for structs and maps, using the `$key$` field. +Tuples, tuple structs, and sequences are supported by turning the first value into the map key. + +Each of the `SimpleStruct`s + +```ignore +// Somewhere there is a collection: +// #[serde_as(as = "KeyValueMap<_>")] +// Vec<SimpleStruct>, + +#[derive(Serialize, Deserialize)] +struct SimpleStruct { + b: bool, + // The field named `$key$` will become the map key + #[serde(rename = "$key$")] + id: String, + i: i32, +} +``` + +will turn into a JSON snippet like this. + +```json +"id-0000": { + "b": false, + "i": 123 +}, +``` + +## 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 available 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}", +``` + +```ignore +#[serde_as(as = "JsonString<Vec<(JsonString, _)>>")] +value: BTreeMap<[u8; 2], u32>, + +// JSON +{"value":"[[\"[1,2]\",3],[\"[4,5]\",6]]"} +``` + +## `Vec` of tuples to `Maps` + +```ignore +// Rust +#[serde_as(as = "Map<_, _>")] // also works with BTreeMap and HashMap +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. +Three formats are supported, [`time::format_description::well_known::Rfc2822`], [`time::format_description::well_known::Rfc3339`], and [`time::format_description::well_known::Iso8601`]. + +```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, +#[serde_as(as = "time::format_description::well_known::Iso8601<Config>")] +iso_8601: OffsetDateTime, + +// JSON +"rfc_2822": "Fri, 21 Nov 1997 09:55:06 -0600", +"rfc_3339": "1997-11-21T09:55:06-06:00", +"iso_8061": "1997-11-21T09:55:06-06:00", +``` + +These conversions are available 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::DateTime +[`chrono::DateTime<Utc>`]: chrono::DateTime +[`chrono::Duration`]: chrono::Duration +[`chrono::NaiveDateTime`]: chrono::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 +[`KeyValueMap`]: crate::KeyValueMap +[`MapFirstKeyWins`]: crate::MapFirstKeyWins +[`MapPreventDuplicates`]: crate::MapPreventDuplicates +[`NoneAsEmptyString`]: crate::NoneAsEmptyString +[`OneOrMany`]: crate::OneOrMany +[`PickFirst`]: crate::PickFirst +[`SetLastValueWins`]: crate::SetLastValueWins +[`SetPreventDuplicates`]: crate::SetPreventDuplicates +[`time::Duration`]: time_0_3::Duration +[`time::format_description::well_known::Iso8601`]: time_0_3::format_description::well_known::Iso8601 +[`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..b104321476 --- /dev/null +++ b/third_party/rust/serde_with/src/hex.rs @@ -0,0 +1,143 @@ +//! 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::prelude::*; + +/// 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 [`formats::Lowercase`] and [`formats::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(); +/// # } +/// ``` +pub struct Hex<FORMAT: formats::Format = formats::Lowercase>(PhantomData<FORMAT>); + +impl<T> SerializeAs<T> for Hex<formats::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<formats::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: formats::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(DeError::custom)) + .and_then(|vec: Vec<u8>| { + let length = vec.len(); + vec.try_into().map_err(|_e: T::Error| { + DeError::custom(format_args!( + "Can't convert a Byte Vector of length {length} to the output type." + )) + }) + }) + } +} 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..5a192e1b33 --- /dev/null +++ b/third_party/rust/serde_with/src/json.rs @@ -0,0 +1,121 @@ +//! De/Serialization of JSON +//! +//! This modules is only available when using the `json` feature of the crate. + +use crate::prelude::*; + +/// Serialize value as string containing JSON +/// +/// *Note*: This type is not necessary for normal usage of serde with JSON. +/// It is only required if the serialized format contains a string, which itself contains JSON. +/// +/// # Errors +/// +/// Serialization can fail if `T`'s implementation of `Serialize` decides to +/// fail, or if `T` contains a map with non-string keys. +/// +/// # 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() +/// ); +/// # } +/// ``` +/// +/// The `JsonString` converter takes a type argument, which allows altering the serialization behavior of the inner value, before it gets turned into a JSON string. +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_with::{serde_as, json::JsonString}; +/// # use std::collections::BTreeMap; +/// # +/// #[serde_as] +/// #[derive(Debug, Serialize, Deserialize, PartialEq)] +/// struct Struct { +/// #[serde_as(as = "JsonString<Vec<(JsonString, _)>>")] +/// value: BTreeMap<[u8; 2], u32>, +/// } +/// +/// let value = Struct { +/// value: BTreeMap::from([([1, 2], 3), ([4, 5], 6)]), +/// }; +/// assert_eq!( +/// r#"{"value":"[[\"[1,2]\",3],[\"[4,5]\",6]]"}"#, +/// serde_json::to_string(&value).unwrap() +/// ); +/// # } +/// ``` +pub struct JsonString<T = Same>(PhantomData<T>); + +impl<T, TAs> SerializeAs<T> for JsonString<TAs> +where + TAs: SerializeAs<T>, +{ + fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + serializer.serialize_str( + &serde_json::to_string(&SerializeAsWrap::<T, TAs>::new(source)) + .map_err(SerError::custom)?, + ) + } +} + +impl<'de, T, TAs> DeserializeAs<'de, T> for JsonString<TAs> +where + TAs: for<'a> DeserializeAs<'a, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error> + where + D: Deserializer<'de>, + { + struct Helper<S, SAs>(PhantomData<(S, SAs)>); + + impl<'de, S, SAs> Visitor<'de> for Helper<S, SAs> + where + SAs: for<'a> DeserializeAs<'a, S>, + { + type Value = S; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("valid json object") + } + + fn visit_str<E>(self, value: &str) -> Result<S, E> + where + E: DeError, + { + serde_json::from_str(value) + .map(DeserializeAsWrap::<S, SAs>::into_inner) + .map_err(DeError::custom) + } + } + + deserializer.deserialize_str(Helper::<T, TAs>(PhantomData)) + } +} diff --git a/third_party/rust/serde_with/src/key_value_map.rs b/third_party/rust/serde_with/src/key_value_map.rs new file mode 100644 index 0000000000..67d9232b1b --- /dev/null +++ b/third_party/rust/serde_with/src/key_value_map.rs @@ -0,0 +1,1298 @@ +use crate::{ + content::{ + de::{Content as DeContent, ContentDeserializer}, + ser::{Content as SerContent, ContentSerializer}, + }, + prelude::*, +}; + +/// Convert `Vec` elements into key-value map entries +/// +/// This maps a single struct/tuple/etc. to a map entry. +/// The map key is converted to a struct field. +/// The other values will be mapped to the map value. +/// +/// The conversion supports structs, tuple structs, tuples, maps, and sequences. +/// Structs need a field that is named `$key$` to be used as the map key. +/// This can be done with the `#[serde(rename = "$key$")]` attribute. +/// Maps similarly need a map-key that is named `$key$`. +/// For tuples, tuple structs, and sequences the first element is used as the map key. +/// +/// # Examples +/// +/// ## Struct with String key in JSON +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// use serde_with::{serde_as, KeyValueMap}; +/// +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct SimpleStruct { +/// b: bool, +/// // The field named `$key$` will become the map key +/// #[serde(rename = "$key$")] +/// id: String, +/// i: i32, +/// } +/// +/// #[serde_as] +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct KVMap( +/// #[serde_as(as = "KeyValueMap<_>")] +/// Vec<SimpleStruct>, +/// ); +/// +/// // --- +/// +/// // This will serialize this list of values +/// let values = KVMap(vec![ +/// SimpleStruct { +/// b: false, +/// id: "id-0000".to_string(), +/// i: 123, +/// }, +/// SimpleStruct { +/// b: true, +/// id: "id-0001".to_string(), +/// i: 555, +/// }, +/// SimpleStruct { +/// b: false, +/// id: "id-0002".to_string(), +/// i: 987, +/// }, +/// ]); +/// +/// // into this JSON map +/// let expected = +/// r#"{ +/// "id-0000": { +/// "b": false, +/// "i": 123 +/// }, +/// "id-0001": { +/// "b": true, +/// "i": 555 +/// }, +/// "id-0002": { +/// "b": false, +/// "i": 987 +/// } +/// }"#; +/// +/// // Both serialization and deserialization work flawlessly. +/// let serialized = serde_json::to_string_pretty(&values).unwrap(); +/// assert_eq!(expected, serialized); +/// let deserialized: KVMap = serde_json::from_str(&serialized).unwrap(); +/// assert_eq!(values, deserialized); +/// # } +/// ``` +/// +/// ## Tuple struct with complex key in YAML +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// use serde_with::{serde_as, KeyValueMap}; +/// use std::net::IpAddr; +/// # use std::str::FromStr; +/// +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct TupleStruct ( +/// // The first element in a tuple struct, tuple, or sequence becomes the map key +/// (IpAddr, u8), +/// bool, +/// ); +/// +/// #[serde_as] +/// # #[derive(Debug, Clone, PartialEq, Eq)] +/// #[derive(Serialize, Deserialize)] +/// struct KVMap( +/// #[serde_as(as = "KeyValueMap<_>")] +/// Vec<TupleStruct>, +/// ); +/// +/// // --- +/// +/// // This will serialize this list of values +/// let values = KVMap(vec![ +/// TupleStruct( +/// (IpAddr::from_str("127.0.0.1").unwrap(), 8), +/// true +/// ), +/// TupleStruct( +/// (IpAddr::from_str("::1").unwrap(), 128), +/// true +/// ), +/// TupleStruct( +/// (IpAddr::from_str("198.51.100.0").unwrap(), 24), +/// true +/// ), +/// ]); +/// +/// // into this YAML +/// let expected = +/// r#"? - 127.0.0.1 +/// - 8 +/// : - true +/// ? - ::1 +/// - 128 +/// : - true +/// ? - 198.51.100.0 +/// - 24 +/// : - true +/// "#; +/// +/// // Both serialization and deserialization work flawlessly. +/// let serialized = serde_yaml::to_string(&values).unwrap(); +/// assert_eq!(expected, serialized); +/// let deserialized: KVMap = serde_yaml::from_str(&serialized).unwrap(); +/// assert_eq!(values, deserialized); +/// # } +/// ``` +pub struct KeyValueMap<T>(PhantomData<T>); + +impl<T, TAs> SerializeAs<Vec<T>> for KeyValueMap<TAs> +where + TAs: SerializeAs<T>, +{ + fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + <Vec<TAs>>::serialize_as(source, SeqAsMapSerializer(serializer)) + } +} + +impl<'de, T, TAs> DeserializeAs<'de, Vec<T>> for KeyValueMap<TAs> +where + TAs: DeserializeAs<'de, T>, +{ + fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error> + where + D: Deserializer<'de>, + { + struct KeyValueMapVisitor<T, TAs> { + is_human_readable: bool, + phantom: PhantomData<(T, TAs)>, + } + + impl<'de, T, TAs> Visitor<'de> for KeyValueMapVisitor<T, TAs> + where + TAs: DeserializeAs<'de, T>, + { + type Value = Vec<T>; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "a map") + } + + fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> { + <Vec<TAs>>::deserialize_as(SeqDeserializer { + delegate: map, + is_human_readable: self.is_human_readable, + }) + } + } + + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_map(KeyValueMapVisitor::<T, TAs> { + is_human_readable, + phantom: PhantomData, + }) + } +} + +// TODO Replace this with a const generic string once adt_const_params is stable. +// This will allow something like this. +// The `"id"` part is the field name, which gets converted to/from the map key. +// #[serde_as(as = r#"KeyValueMap<"id", _>"#)] +// Vec<SimpleStruct>, +static MAP_KEY_IDENTIFIER: &str = "$key$"; + +/// 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 is_human_readable(&self) -> bool { + self.0.is_human_readable() + } + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + 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(SerError::custom("wrong type for KeyValueMap")) + } + + 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(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } +} + +/// Serialize a single element but turn the sequence into a map logic. +/// +/// It uses [`ElementAsKeyValueSerializer`] for the map element serialization. +/// +/// The [`Serializer`] implementation handles `serialize_struct`, `serialize_map` and `serialize_seq` functions by deferring the work to [`SerializeStruct`], [`SerializeMap`] and [`SerializeSeq`] respectively. + +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(ElementAsKeyValueSerializer { + delegate: &mut self.delegate, + is_human_readable: self.is_human_readable, + })?; + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + self.delegate.end() + } +} + +struct ElementAsKeyValueSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, +} + +impl<'a, M> Serializer for ElementAsKeyValueSerializer<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + type Error = M::Error; + + type SerializeSeq = KeyValueSeqSerializer<'a, M>; + type SerializeTuple = KeyValueTupleSerializer<'a, M>; + type SerializeTupleStruct = KeyValueTupleStructSerializer<'a, M>; + type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>; + type SerializeMap = KeyValueMapSerializer<'a, M>; + type SerializeStruct = KeyValueStructSerializer<'a, M>; + type SerializeStructVariant = Impossible<Self::Ok, Self::Error>; + + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_none(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + _value: &T, + ) -> Result<Self::Ok, Self::Error> + where + T: Serialize, + { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + 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(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { + Ok(KeyValueSeqSerializer { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + content: Vec::with_capacity(len.unwrap_or(17) - 1), + key: None, + }) + } + + fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> { + Ok(KeyValueTupleSerializer { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + content: Vec::with_capacity(len - 1), + key: None, + }) + } + + fn serialize_tuple_struct( + self, + name: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Ok(KeyValueTupleStructSerializer { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + name, + content: Vec::with_capacity(len - 1), + key: None, + }) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } + + fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { + Ok(KeyValueMapSerializer { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + content: Vec::with_capacity(len.unwrap_or(17) - 1), + next_is_magic_key: false, + key: None, + tmp: None, + }) + } + + fn serialize_struct( + self, + name: &'static str, + len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { + Ok(KeyValueStructSerializer { + delegate: self.delegate, + is_human_readable: self.is_human_readable, + name, + content: Vec::with_capacity(len - 1), + key: None, + }) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { + Err(SerError::custom("wrong type for KeyValueMap")) + } +} + +/// Serialize a sequence to a key and value pair of a map. +/// +/// This requires that the sequence has at least one element. +struct KeyValueSeqSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, + content: Vec<SerContent>, + key: Option<SerContent>, +} + +impl<'a, M> SerializeSeq for KeyValueSeqSerializer<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + type Error = M::Error; + + fn serialize_element<T: ?Sized>(&mut self, element: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + let element: SerContent = + element.serialize(ContentSerializer::new(self.is_human_readable))?; + if self.key.is_none() { + self.key = Some(element); + return Ok(()); + } + self.content.push(element); + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + if let Some(key) = self.key { + self.delegate + .serialize_entry(&key, &SerContent::Seq(self.content)) + } else { + Err(SerError::custom("TODO, missing value for `$key$` field")) + } + } +} + +/// Serialize a tuple to a key and value pair of a map. +/// +/// This requires that the tuple has at least one element. +struct KeyValueTupleSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, + content: Vec<SerContent>, + key: Option<SerContent>, +} + +impl<'a, M> SerializeTuple for KeyValueTupleSerializer<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + type Error = M::Error; + + fn serialize_element<T: ?Sized>(&mut self, element: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + let element: SerContent = + element.serialize(ContentSerializer::new(self.is_human_readable))?; + if self.key.is_none() { + self.key = Some(element); + return Ok(()); + } + self.content.push(element); + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + if let Some(key) = self.key { + self.delegate + .serialize_entry(&key, &SerContent::Tuple(self.content)) + } else { + Err(SerError::custom("TODO, missing value for `$key$` field")) + } + } +} + +/// Serialize a tuple struct to a key and value pair of a map. +/// +/// This requires that the tuple struct has at least one element. +struct KeyValueTupleStructSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, + name: &'static str, + content: Vec<SerContent>, + key: Option<SerContent>, +} + +impl<'a, M> SerializeTupleStruct for KeyValueTupleStructSerializer<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + type Error = M::Error; + + fn serialize_field<T: ?Sized>(&mut self, field: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + let field: SerContent = field.serialize(ContentSerializer::new(self.is_human_readable))?; + if self.key.is_none() { + self.key = Some(field); + return Ok(()); + } + self.content.push(field); + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + if let Some(key) = self.key { + self.delegate + .serialize_entry(&key, &SerContent::TupleStruct(self.name, self.content)) + } else { + Err(SerError::custom("TODO, missing value for `$key$` field")) + } + } +} + +/// Serialize a map to a key and value pair of a map. +/// +/// This requires that the map has one element which serializes using the magic `$key$` key. +struct KeyValueMapSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, + content: Vec<(SerContent, SerContent)>, + next_is_magic_key: bool, + key: Option<SerContent>, + tmp: Option<SerContent>, +} + +impl<'a, M> SerializeMap for KeyValueMapSerializer<'a, M> +where + M: SerializeMap, +{ + type Ok = (); + type Error = M::Error; + + fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + let key: SerContent = key.serialize(ContentSerializer::new(self.is_human_readable))?; + if key.as_str() == Some(MAP_KEY_IDENTIFIER) { + self.next_is_magic_key = true; + return Ok(()); + } + self.tmp = Some(key); + Ok(()) + } + + fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> + where + T: Serialize, + { + let value: SerContent = value.serialize(ContentSerializer::new(self.is_human_readable))?; + + if self.next_is_magic_key { + self.next_is_magic_key = false; + self.key = Some(value); + return Ok(()); + } + self.content.push(( + self.tmp + .take() + .expect("serialize_value called before serialize_key"), + value, + )); + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + if let Some(key) = self.key { + self.delegate + .serialize_entry(&key, &SerContent::Map(self.content)) + } else { + Err(SerError::custom("TODO, missing value for `$key$` field")) + } + } +} + +/// Serialize a struct to a key and value pair of a map. +/// +/// This requires that the struct has one field named `$key$`. +struct KeyValueStructSerializer<'a, M> { + delegate: &'a mut M, + is_human_readable: bool, + name: &'static str, + content: Vec<(&'static str, SerContent)>, + key: Option<SerContent>, +} + +impl<'a, M> SerializeStruct for KeyValueStructSerializer<'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: SerContent = value.serialize(ContentSerializer::new(self.is_human_readable))?; + + if key == MAP_KEY_IDENTIFIER { + self.key = Some(value); + return Ok(()); + } + self.content.push((key, value)); + Ok(()) + } + + fn end(self) -> Result<Self::Ok, Self::Error> { + if let Some(key) = self.key { + self.delegate + .serialize_entry(&key, &SerContent::Struct(self.name, self.content)) + } else { + Err(SerError::custom("TODO, missing value for `key` field")) + } + } +} + +// 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> { + delegate: M, + is_human_readable: bool, +} + +impl<'de, M> Deserializer<'de> for SeqDeserializer<M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + 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>, + { + let key_value: Option<DeContent<'de>> = self.delegate.next_key()?; + if let Some(key_value) = key_value { + seed.deserialize(MapKeyDeserializer { + delegate: &mut self.delegate, + is_human_readable: self.is_human_readable, + key_value, + }) + .map(Some) + } else { + Ok(None) + } + } + + fn size_hint(&self) -> Option<usize> { + self.delegate.size_hint() + } +} + +struct MapKeyDeserializer<'de, M> { + delegate: M, + is_human_readable: bool, + key_value: DeContent<'de>, +} + +impl<'de, M> Deserializer<'de> for MapKeyDeserializer<'de, M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn is_human_readable(&self) -> bool { + self.is_human_readable + } + + fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.deserialize_map(visitor) + } + + fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.next_value_seed(KeyValueSeqDeserialize { + delegate: visitor, + first: Some(self.key_value), + }) + } + + fn deserialize_tuple<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.next_value_seed(KeyValueTupleDeserialize { + delegate: visitor, + len, + first: Some(self.key_value), + }) + } + + fn deserialize_tuple_struct<V>( + mut self, + name: &'static str, + len: usize, + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate + .next_value_seed(KeyValueTupleStructDeserialize { + delegate: visitor, + name, + len, + first: Some(self.key_value), + }) + } + + fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.next_value_seed(KeyValueMapDeserialize { + delegate: visitor, + first: Some(self.key_value), + }) + } + + fn deserialize_struct<V>( + mut self, + name: &'static str, + fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Self::Error> + where + V: Visitor<'de>, + { + self.delegate.next_value_seed(KeyValueStructDeserialize { + delegate: visitor, + name, + fields, + first: Some(self.key_value), + }) + } + + 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 + enum identifier ignored_any + } +} + +struct KeyValueSeqDeserialize<'de, V> { + delegate: V, + first: Option<DeContent<'de>>, +} + +impl<'de, V> DeserializeSeed<'de> for KeyValueSeqDeserialize<'de, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_seq(VisitorWrapper { + delegate: self.delegate, + is_human_readable, + first: self.first.take(), + }) + } +} + +struct KeyValueTupleDeserialize<'de, V> { + delegate: V, + len: usize, + first: Option<DeContent<'de>>, +} + +impl<'de, V> DeserializeSeed<'de> for KeyValueTupleDeserialize<'de, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_tuple( + self.len, + VisitorWrapper { + delegate: self.delegate, + is_human_readable, + first: self.first.take(), + }, + ) + } +} + +struct KeyValueTupleStructDeserialize<'de, V> { + delegate: V, + name: &'static str, + len: usize, + first: Option<DeContent<'de>>, +} + +impl<'de, V> DeserializeSeed<'de> for KeyValueTupleStructDeserialize<'de, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_tuple_struct( + self.name, + self.len, + VisitorWrapper { + delegate: self.delegate, + is_human_readable, + first: self.first.take(), + }, + ) + } +} + +struct KeyValueMapDeserialize<'de, V> { + delegate: V, + first: Option<DeContent<'de>>, +} + +impl<'de, V> DeserializeSeed<'de> for KeyValueMapDeserialize<'de, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_map(VisitorWrapper { + delegate: self.delegate, + is_human_readable, + first: self.first.take(), + }) + } +} + +struct KeyValueStructDeserialize<'de, V> { + delegate: V, + name: &'static str, + fields: &'static [&'static str], + first: Option<DeContent<'de>>, +} + +impl<'de, V> DeserializeSeed<'de> for KeyValueStructDeserialize<'de, V> +where + V: Visitor<'de>, +{ + type Value = V::Value; + + fn deserialize<D>(mut self, deserializer: D) -> Result<Self::Value, D::Error> + where + D: Deserializer<'de>, + { + let is_human_readable = deserializer.is_human_readable(); + deserializer.deserialize_struct( + self.name, + self.fields, + VisitorWrapper { + delegate: self.delegate, + is_human_readable, + first: self.first.take(), + }, + ) + } +} + +struct VisitorWrapper<'de, V> { + delegate: V, + is_human_readable: bool, + first: Option<DeContent<'de>>, +} + +impl<'de, V> Visitor<'de> for VisitorWrapper<'de, 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(MapAccessWrapper { + delegate: map, + is_human_readable: self.is_human_readable, + first: self.first, + }) + } + + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> + where + A: SeqAccess<'de>, + { + self.delegate.visit_seq(SeqAccessWrapper { + delegate: seq, + is_human_readable: self.is_human_readable, + first: self.first, + }) + } +} + +struct MapAccessWrapper<'de, M> { + delegate: M, + is_human_readable: bool, + first: Option<DeContent<'de>>, +} + +impl<'de, M> MapAccess<'de> for MapAccessWrapper<'de, M> +where + M: MapAccess<'de>, +{ + type Error = M::Error; + + fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error> + where + K: DeserializeSeed<'de>, + { + if self.first.is_some() { + seed.deserialize(serde::de::value::StringDeserializer::new( + MAP_KEY_IDENTIFIER.to_string(), + )) + .map(Some) + } else { + self.delegate.next_key_seed(seed) + } + } + + fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error> + where + V: DeserializeSeed<'de>, + { + if let Some(first) = self.first.take() { + seed.deserialize(ContentDeserializer::new(first, self.is_human_readable)) + } else { + self.delegate.next_value_seed(seed) + } + } +} + +struct SeqAccessWrapper<'de, M> { + delegate: M, + is_human_readable: bool, + first: Option<DeContent<'de>>, +} + +impl<'de, S> SeqAccess<'de> for SeqAccessWrapper<'de, S> +where + S: SeqAccess<'de>, +{ + type Error = S::Error; + + fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error> + where + K: DeserializeSeed<'de>, + { + if let Some(first) = self.first.take() { + seed.deserialize(ContentDeserializer::new(first, self.is_human_readable)) + .map(Some) + } else { + self.delegate.next_element_seed(seed) + } + } +} 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..3add59975a --- /dev/null +++ b/third_party/rust/serde_with/src/lib.rs @@ -0,0 +1,2339 @@ +#![warn( + clippy::semicolon_if_nothing_returned, + // New clippy lints, not yet stable + // clippy::std_instead_of_core, + // clippy::std_instead_of_alloc, + // clippy::alloc_instead_of_core, + missing_docs, + rust_2018_idioms, + rustdoc::missing_crate_level_docs, + 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_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/3.0.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, + // https://github.com/rust-lang/rust-clippy/issues/9101 + clippy::explicit_auto_deref +)] +#![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://www.rustexplorer.com/b/py7ida) +//! +//! --- +//! +//! 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`] 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::StringWithSeparator::<CommaSeparator, T>`][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 +//! +//! ```bash +//! # Add the current version to your Cargo.toml +//! cargo add serde_with +//! ``` +//! +//! 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 placed *before* the `#[derive]`. +//! +//! The `as` is analogous to the `with` attribute of serde. +//! You mirror the type structure of the field you want to de/serialize. +//! You can specify converters for the inner types of a field, e.g., `Vec<DisplayFromStr>`. +//! The default de/serialization behavior can be restored by using `_` as a placeholder, e.g., `BTreeMap<_, DisplayFromStr>`. +//! +//! ## `DisplayFromStr` +//! +//! [](https://www.rustexplorer.com/b/py7ida) +//! ```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. +//! +//! On top of it, `[u8; N]` (aka, bytes) can use the specialized `"Bytes"` for efficiency much like the `serde_bytes` crate. +//! +//! [](https://www.rustexplorer.com/b/um0xyi) +//! ```rust +//! # #[cfg(feature = "macros")] +//! # use serde::{Deserialize, Serialize}; +//! # #[cfg(feature = "macros")] +//! # use serde_with::{serde_as, Bytes}; +//! # #[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]>, +//! +//! #[serde_as(as = "Bytes")] +//! bytes: [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]), +//! bytes: [0x42; 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 placed *before* the `#[derive]`. +//! +//! [](https://www.rustexplorer.com/b/xr1tm0) +//! ```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, Map}, +//! # }; +//! use std::time::Duration; +//! +//! # #[cfg(all(feature = "macros", feature = "hex"))] +//! #[serde_as] +//! # #[derive(Debug, Eq, PartialEq)] +//! #[derive(Deserialize, Serialize)] +//! enum Foo { +//! Durations( +//! // Serialize them into a list of number as seconds +//! #[serde_as(as = "Vec<DurationSeconds>")] +//! Vec<Duration>, +//! ), +//! Bytes { +//! // 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 = "Map<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)] +//! ) +//! # ; +//! // into this JSON +//! # let json = r#" +//! { +//! "Durations": [5, 3600, 0] +//! } +//! # "#; +//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap()); +//! # assert_eq!(foo, serde_json::from_str(&json).unwrap()); +//! +//! // and serializes +//! # let foo = +//! Foo::Bytes { +//! bytes: vec![ +//! (1, vec![0, 1, 2]), +//! (-100, vec![100, 200, 255]), +//! (1, vec![0, 111, 222]), +//! ], +//! } +//! # ; +//! // into this JSON +//! # let json = r#" +//! { +//! "Bytes": { +//! "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/3.0.0/serde_with/struct.DisplayFromStr.html +//! [`with_prefix!`]: https://docs.rs/serde_with/3.0.0/serde_with/macro.with_prefix.html +//! [feature flags]: https://docs.rs/serde_with/3.0.0/serde_with/guide/feature_flags/index.html +//! [skip_serializing_none]: https://docs.rs/serde_with/3.0.0/serde_with/attr.skip_serializing_none.html +//! [StringWithSeparator]: https://docs.rs/serde_with/3.0.0/serde_with/struct.StringWithSeparator.html +//! [user guide]: https://docs.rs/serde_with/3.0.0/serde_with/guide/index.html +//! [with-annotation]: https://serde.rs/field-attrs.html#with +//! [as-annotation]: https://docs.rs/serde_with/3.0.0/serde_with/guide/serde_as/index.html + +#[cfg(feature = "alloc")] +extern crate alloc; +#[doc(hidden)] +pub extern crate core; +#[doc(hidden)] +pub extern crate serde; +#[cfg(feature = "std")] +extern crate std; + +#[cfg(feature = "base64")] +#[cfg_attr(docsrs, doc(cfg(feature = "base64")))] +pub mod base64; +#[cfg(feature = "chrono_0_4")] +#[cfg_attr(docsrs, doc(cfg(feature = "chrono_0_4")))] +pub mod chrono_0_4; +/// Legacy export of the [`chrono_0_4`] module. +#[cfg(feature = "chrono")] +#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))] +pub mod chrono { + pub use chrono_0_4::*; +} +#[cfg(feature = "alloc")] +mod content; +pub mod de; +#[cfg(feature = "alloc")] +mod duplicate_key_impls; +#[cfg(feature = "alloc")] +mod enum_map; +#[cfg(feature = "std")] +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; +#[cfg(feature = "alloc")] +mod key_value_map; +pub mod rust; +pub mod ser; +#[cfg(feature = "std")] +mod serde_conv; +#[cfg(feature = "time_0_3")] +#[cfg_attr(docsrs, doc(cfg(feature = "time_0_3")))] +pub mod time_0_3; +mod utils; +#[cfg(feature = "std")] +#[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; + } +} + +pub(crate) mod prelude { + #![allow(unused_imports)] + + pub(crate) use crate::utils::duration::{DurationSigned, Sign}; + pub use crate::{de::*, ser::*, *}; + #[cfg(all(feature = "alloc", target_has_atomic = "ptr"))] + pub use alloc::sync::{Arc, Weak as ArcWeak}; + #[cfg(feature = "alloc")] + pub use alloc::{ + borrow::{Cow, ToOwned}, + boxed::Box, + collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque}, + rc::{Rc, Weak as RcWeak}, + string::{String, ToString}, + vec::Vec, + }; + pub use core::{ + cell::{Cell, RefCell}, + convert::{TryFrom, TryInto}, + fmt::{self, Display}, + hash::{BuildHasher, Hash}, + marker::PhantomData, + option::Option, + result::Result, + str::FromStr, + time::Duration, + }; + pub use serde::{ + de::{ + Deserialize, DeserializeOwned, DeserializeSeed, Deserializer, EnumAccess, + Error as DeError, Expected, IgnoredAny, IntoDeserializer, MapAccess, SeqAccess, + Unexpected, VariantAccess, Visitor, + }, + forward_to_deserialize_any, + ser::{ + Error as SerError, Impossible, Serialize, SerializeMap, SerializeSeq, SerializeStruct, + SerializeStructVariant, SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, + Serializer, + }, + }; + #[cfg(feature = "std")] + pub use std::{ + collections::{HashMap, HashSet}, + sync::{Mutex, RwLock}, + time::SystemTime, + }; +} + +/// This module is not part of the public API +/// +/// Do not rely on any exports. +#[doc(hidden)] +pub mod __private__ { + pub use crate::prelude::*; +} + +#[cfg(feature = "alloc")] +#[doc(inline)] +pub use crate::enum_map::EnumMap; +#[cfg(feature = "alloc")] +#[doc(inline)] +pub use crate::key_value_map::KeyValueMap; +#[doc(inline)] +pub use crate::{de::DeserializeAs, ser::SerializeAs}; +use core::marker::PhantomData; +// 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::*; + +/// 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 +/// # #[cfg(feature = "alloc")] { +/// # 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 +/// # #[cfg(feature = "alloc")] { +/// # 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/3.0.0/serde_with/attr.serde_as.html +pub struct As<T: ?Sized>(PhantomData<T>); + +/// 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. +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 [`serde::Serialize`] and [`serde::Deserialize`] such that user of the type no longer have to use the `serde_as` system. +/// +/// # 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 +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. +/// +/// # 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 +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. +/// +/// # 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); +/// # } +/// ``` +#[cfg(feature = "alloc")] +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. +/// +/// # 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); +/// # } +/// ``` +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 +#[cfg(feature = "alloc")] +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_0_4`-[feature flag]. +/// This type also supports [`time::Duration`][::time_0_3::Duration] with the `time_0_3`-[feature flag]. +/// +/// This table lists the available `FORMAT`s for the different duration types. +/// The `FORMAT` specifier defaults to `u64`/`f64`. +/// +/// | 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_0_4` 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_0_4"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DurationSeconds}; +/// # use chrono_0_4::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_0_4::Duration +/// [feature flag]: https://docs.rs/serde_with/3.0.0/serde_with/guide/feature_flags/index.html +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]. +/// +/// This table lists the available `FORMAT`s for the different duration types. +/// The `FORMAT` specifier defaults to `u64`/`f64`. +/// +/// | 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_0_4` 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_0_4"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, DurationSecondsWithFrac}; +/// # use chrono_0_4::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_0_4::Duration +/// [feature flag]: https://docs.rs/serde_with/3.0.0/serde_with/guide/feature_flags/index.html +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`]. +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`]. +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`]. +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`]. +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`]. +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`]. +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`] with the `chrono_0_4`-[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]. +/// +/// This table lists the available `FORMAT`s for the different timestamp types. +/// The `FORMAT` specifier defaults to `i64` or `f64`. +/// +/// | 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, 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>`] and [`chrono::DateTime<Local>`] 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_0_4"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TimestampSeconds}; +/// # use chrono_0_4::{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 +/// [`chrono::DateTime<Local>`]: ::chrono_0_4::DateTime +/// [`chrono::DateTime<Utc>`]: ::chrono_0_4::DateTime +/// [feature flag]: https://docs.rs/serde_with/3.0.0/serde_with/guide/feature_flags/index.html +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`] 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]. +/// +/// This table lists the available `FORMAT`s for the different timestamp types. +/// The `FORMAT` specifier defaults to `i64` or `f64`. +/// +/// | 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>`] and [`chrono::DateTime<Local>`] are also supported when using the `chrono_0_4` feature. +/// Like [`SystemTime`], it is a signed timestamp, thus can be de/serialized as an `i64`. +/// +/// ```rust +/// # #[cfg(all(feature = "macros", feature = "chrono_0_4"))] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, TimestampSecondsWithFrac}; +/// # use chrono_0_4::{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 +/// [`chrono::DateTime`]: ::chrono_0_4::DateTime +/// [`chrono::DateTime<Local>`]: ::chrono_0_4::DateTime +/// [`chrono::DateTime<Utc>`]: ::chrono_0_4::DateTime +/// [NaiveDateTime]: ::chrono_0_4::NaiveDateTime +/// [feature flag]: https://docs.rs/serde_with/3.0.0/serde_with/guide/feature_flags/index.html +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`]. +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`]. +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`]. +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`]. +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`]. +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`]. +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()); +/// # } +/// ``` +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()); +/// # } +/// ``` +#[cfg(feature = "alloc")] +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()); +/// # } +/// ``` +#[cfg(feature = "alloc")] +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()); +/// # } +/// ``` +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()); +/// # } +/// ``` +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(_))); +/// # } +/// ``` +#[cfg(feature = "alloc")] +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()); +/// # } +/// ``` +#[cfg(feature = "alloc")] +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()); +/// # } +/// ``` +pub struct BoolFromInt<S: formats::Strictness = formats::Strict>(PhantomData<S>); + +/// De/Serialize a delimited collection using [`Display`] and [`FromStr`] implementation +/// +/// `StringWithSeparator` takes a second type, which needs to implement [`Display`]+[`FromStr`] and constitutes the inner type of the collection. +/// 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. +/// +/// # Examples +/// +/// ``` +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # +/// # use serde_with::{serde_as, StringWithSeparator}; +/// use serde_with::formats::{CommaSeparator, SpaceSeparator}; +/// use std::collections::BTreeSet; +/// +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "StringWithSeparator::<SpaceSeparator, String>")] +/// tags: Vec<String>, +/// #[serde_as(as = "StringWithSeparator::<CommaSeparator, String>")] +/// 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() +/// ); +/// # } +/// ``` +/// +/// [`Display`]: core::fmt::Display +/// [`FromStr`]: core::str::FromStr +/// [`Separator`]: crate::formats::Separator +/// [`serde_as`]: crate::guide::serde_as +pub struct StringWithSeparator<Sep, T>(PhantomData<(Sep, T)>); + +/// This serializes a list of tuples into a map +/// +/// Normally, you want to use a [`HashMap`] or a [`BTreeMap`] when deserializing a map. +/// However, sometimes this is not possible due to type constraints, e.g., if the type implements neither [`Hash`] nor [`Ord`]. +/// Another use case is deserializing a map with duplicate keys. +/// +/// # Examples +/// +/// `Wrapper` does not implement [`Hash`] nor [`Ord`], thus prohibiting the use [`HashMap`] or [`BTreeMap`]. +/// The JSON also contains a duplicate key. +/// +/// [`BTreeMap`]: std::collections::BTreeMap +/// [`HashMap`]: std::collections::HashMap +/// [`Vec`]: std::vec::Vec +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, Map}; +/// # +/// #[serde_as] +/// #[derive(Debug, Deserialize, Serialize, Default)] +/// struct S { +/// #[serde_as(as = "Map<_, _>")] +/// s: Vec<(Wrapper<i32>, String)>, +/// } +/// +/// #[derive(Clone, Debug, Serialize, Deserialize)] +/// #[serde(transparent)] +/// struct Wrapper<T>(T); +/// +/// let data = S { +/// s: vec![ +/// (Wrapper(1), "a".to_string()), +/// (Wrapper(2), "b".to_string()), +/// (Wrapper(3), "c".to_string()), +/// (Wrapper(2), "d".to_string()), +/// ], +/// }; +/// +/// let json = r#"{ +/// "s": { +/// "1": "a", +/// "2": "b", +/// "3": "c", +/// "2": "d" +/// } +/// }"#; +/// assert_eq!(json, serde_json::to_string_pretty(&data).unwrap()); +/// # } +/// ``` +pub struct Map<K, V>(PhantomData<(K, V)>); + +/// De/Serialize a Map into a list of tuples +/// +/// Some formats, like JSON, have limitations on the types of keys for maps. +/// In case of JSON, keys are restricted to strings. +/// Rust features more powerful keys, for example tuples, which can not be serialized to JSON. +/// +/// This helper serializes the Map into a list of tuples, which do not have the same type restrictions. +/// +/// # Examples +/// +/// ```rust +/// # #[cfg(feature = "macros")] { +/// # use serde::{Deserialize, Serialize}; +/// # use serde_json::json; +/// # use serde_with::{serde_as, Seq}; +/// # use std::collections::BTreeMap; +/// # +/// #[serde_as] +/// # #[derive(Debug, PartialEq)] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "Seq<(_, _)>")] +/// s: BTreeMap<(String, u32), u32>, +/// } +/// +/// // This converts the Rust type +/// let data = A { +/// s: BTreeMap::from([ +/// (("Hello".to_string(), 123), 0), +/// (("World".to_string(), 456), 1), +/// ]), +/// }; +/// +/// // into this JSON +/// let value = json!({ +/// "s": [ +/// [["Hello", 123], 0], +/// [["World", 456], 1] +/// ] +/// }); +/// +/// assert_eq!(value, serde_json::to_value(&data).unwrap()); +/// assert_eq!(data, serde_json::from_value(value).unwrap()); +/// # } +/// ``` +pub struct Seq<V>(PhantomData<V>); + +/// 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 +/// # #[cfg(feature = "macros")] { +/// # use serde::Deserialize; +/// # use std::collections::HashMap; +/// # use serde_with::{serde_as, MapPreventDuplicates}; +/// # +/// #[serde_as] +/// # #[derive(Debug, Eq, PartialEq)] +/// #[derive(Deserialize)] +/// struct Doc { +/// #[serde_as(as = "MapPreventDuplicates<_, _>")] +/// 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()); +/// # } +/// ``` +#[cfg(feature = "alloc")] +pub struct MapPreventDuplicates<K, V>(PhantomData<(K, V)>); + +/// 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 +#[cfg(feature = "alloc")] +pub struct MapFirstKeyWins<K, V>(PhantomData<(K, V)>); + +/// 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 +/// # #[cfg(feature = "macros")] { +/// # use std::collections::HashSet; +/// # use serde::Deserialize; +/// # use serde_with::{serde_as, SetPreventDuplicates}; +/// # +/// #[serde_as] +/// # #[derive(Debug, Eq, PartialEq)] +/// #[derive(Deserialize)] +/// struct Doc { +/// #[serde_as(as = "SetPreventDuplicates<_>")] +/// 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()); +/// # } +/// ``` +#[cfg(feature = "alloc")] +pub struct SetPreventDuplicates<T>(PhantomData<T>); + +/// 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 +#[cfg(feature = "alloc")] +pub struct SetLastValueWins<T>(PhantomData<T>); 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..acfca714b8 --- /dev/null +++ b/third_party/rust/serde_with/src/rust.rs @@ -0,0 +1,712 @@ +//! De/Serialization for Rust's builtin and std types + +use crate::prelude::*; + +/// 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. +/// +/// Note: This cannot be made compatible to `serde_as`, since skipping of values is only available on the field level. +/// A hypothetical `DoubleOption<T>` with a `SerializeAs` implementation would allow writing something like this. +/// This cannot work, since there is no way to tell the `Vec` to skip the inner `DoubleOption` if it is `None`. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// # struct Foobar { +/// #[serde_as(as = "Vec<DoubleOption<_>>")] +/// data: Vec<Option<Option<i32>>>, +/// # } +/// # } +/// ``` +/// +/// # 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. +/// +/// # Converting to serde_as +/// +/// The same functionality can be more clearly expressed using the `serde_as` macro and [`SetPreventDuplicates`]. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`]. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "SetPreventDuplicates<_, _>")] +/// s: HashSet<usize>, +/// } +/// # } +/// ``` +/// +/// [`HashSet`]: std::collections::HashSet +/// [`BTreeSet`]: std::collections::HashSet +/// +/// # Example +/// +/// ```rust +/// # use std::collections::HashSet; +/// # 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()); +/// ``` +#[cfg(feature = "alloc")] +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(DeError::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. +/// +/// # Converting to serde_as +/// +/// The same functionality can be more clearly expressed using the `serde_as` macro and [`MapPreventDuplicates`]. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`]. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "MapPreventDuplicates<_, _>")] +/// s: HashMap<usize, usize>, +/// } +/// # } +/// ``` +/// +/// [`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()); +/// ``` +#[cfg(feature = "alloc")] +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(DeError::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) + } +} + +/// 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. +/// +/// # Converting to serde_as +/// +/// The same functionality can be more clearly expressed using the `serde_as` macro and [`SetLastValueWins`]. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`]. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "SetLastValueWins<_, _>")] +/// s: HashSet<usize>, +/// } +/// # } +/// ``` +/// +/// [`HashSet`]: std::collections::HashSet +/// [`BTreeSet`]: std::collections::HashSet +#[cfg(feature = "alloc")] +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 +/// +/// # Converting to serde_as +/// +/// The same functionality can be more clearly expressed using the `serde_as` macro and [`MapFirstKeyWins`]. +/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`]. +/// +/// ```rust +/// # #[cfg(FALSE)] { +/// #[serde_as] +/// #[derive(Deserialize, Serialize)] +/// struct A { +/// #[serde_as(as = "MapFirstKeyWins<_, _>")] +/// s: HashMap<usize, usize>, +/// } +/// # } +/// ``` +/// +/// # 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()); +/// ``` +#[cfg(feature = "alloc")] +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) + } +} + +/// 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/duplicates.rs b/third_party/rust/serde_with/src/ser/duplicates.rs new file mode 100644 index 0000000000..d70f48dfd0 --- /dev/null +++ b/third_party/rust/serde_with/src/ser/duplicates.rs @@ -0,0 +1,70 @@ +use super::impls::{foreach_map, foreach_set}; +use crate::{ + prelude::*, MapFirstKeyWins, MapPreventDuplicates, SetLastValueWins, SetPreventDuplicates, +}; +#[cfg(feature = "indexmap_1")] +use indexmap_1::{IndexMap, IndexSet}; + +macro_rules! set_duplicate_handling { + ($tyorig:ident < T $(, $typaram:ident : $bound:ident)* >) => { + impl<T, TAs $(, $typaram)*> SerializeAs<$tyorig<T $(, $typaram)*>> for SetPreventDuplicates<TAs> + where + TAs: SerializeAs<T>, + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(value: &$tyorig<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + <$tyorig<TAs $(, $typaram)*>>::serialize_as(value, serializer) + } + } + + impl<T, TAs $(, $typaram)*> SerializeAs<$tyorig<T $(, $typaram)*>> for SetLastValueWins<TAs> + where + TAs: SerializeAs<T>, + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(value: &$tyorig<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + <$tyorig<TAs $(, $typaram)*>>::serialize_as(value, serializer) + } + } + } +} +foreach_set!(set_duplicate_handling); + +macro_rules! map_duplicate_handling { + ($tyorig:ident < K, V $(, $typaram:ident : $bound:ident)* >) => { + impl<K, KAs, V, VAs $(, $typaram)*> SerializeAs<$tyorig<K, V $(, $typaram)*>> for MapPreventDuplicates<KAs, VAs> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(value: &$tyorig<K, V $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + <$tyorig<KAs, VAs $(, $typaram)*>>::serialize_as(value, serializer) + } + } + + impl<K, KAs, V, VAs $(, $typaram)*> SerializeAs<$tyorig<K, V $(, $typaram)*>> for MapFirstKeyWins<KAs, VAs> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(value: &$tyorig<K, V $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + <$tyorig<KAs, VAs $(, $typaram)*>>::serialize_as(value, serializer) + } + } + } +} +foreach_map!(map_duplicate_handling); 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..0075a8b853 --- /dev/null +++ b/third_party/rust/serde_with/src/ser/impls.rs @@ -0,0 +1,919 @@ +use crate::{formats, formats::Strictness, prelude::*}; +#[cfg(feature = "indexmap_1")] +use indexmap_1::{IndexMap, IndexSet}; + +/////////////////////////////////////////////////////////////////////////////// +// Helper macro used internally + +#[cfg(feature = "alloc")] +type BoxedSlice<T> = Box<[T]>; +type Slice<T> = [T]; + +macro_rules! foreach_map { + ($m:ident) => { + #[cfg(feature = "alloc")] + $m!(BTreeMap<K, V>); + #[cfg(feature = "std")] + $m!(HashMap<K, V, H: Sized>); + #[cfg(all(feature = "indexmap_1"))] + $m!(IndexMap<K, V, H: Sized>); + }; +} +pub(crate) use foreach_map; + +macro_rules! foreach_set { + ($m:ident, $T:tt) => { + #[cfg(feature = "alloc")] + $m!(BTreeSet<$T>); + #[cfg(feature = "std")] + $m!(HashSet<$T, H: Sized>); + #[cfg(all(feature = "indexmap_1"))] + $m!(IndexSet<$T, H: Sized>); + }; + ($m:ident) => { + foreach_set!($m, T); + }; +} +pub(crate) use foreach_set; + +macro_rules! foreach_seq { + ($m:ident, $T:tt) => { + foreach_set!($m, $T); + + $m!(Slice<$T>); + + #[cfg(feature = "alloc")] + $m!(BinaryHeap<$T>); + #[cfg(feature = "alloc")] + $m!(BoxedSlice<$T>); + #[cfg(feature = "alloc")] + $m!(LinkedList<$T>); + #[cfg(feature = "alloc")] + $m!(Vec<$T>); + #[cfg(feature = "alloc")] + $m!(VecDeque<$T>); + }; + ($m:ident) => { + foreach_seq!($m, T); + }; +} +pub(crate) use foreach_seq; + +/////////////////////////////////////////////////////////////////////////////// +// 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) + } +} + +#[cfg(feature = "alloc")] +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(), + } + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))] +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) + } +} + +#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))] +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")), + } + } +} + +#[cfg(feature = "std")] +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")), + } + } +} + +#[cfg(feature = "std")] +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) + } +} + +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, + { + let mut arr = serializer.serialize_tuple(N)?; + for elem in array { + arr.serialize_element(&SerializeAsWrap::<T, As>::new(elem))?; + } + arr.end() + } +} + +// 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))) + } + } + } +} +foreach_seq!(seq_impl); + +#[cfg(feature = "alloc")] +macro_rules! map_impl { + ($ty:ident < K, 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>, + $($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)))) + } + } + } +} +foreach_map!(map_impl); + +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); + +#[cfg(feature = "alloc")] +macro_rules! map_as_tuple_seq_intern { + ($tyorig:ident < K, V $(, $typaram:ident : $bound:ident)* >, $ty:ident <(K, V)>) => { + impl<K, KAs, V, VAs $(, $typaram)*> SerializeAs<$tyorig<K, V $(, $typaram)*>> for $ty<(KAs, VAs)> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(source: &$tyorig<K, V $(, $typaram)*>, 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), + ) + })) + } + } + }; +} +#[cfg(feature = "alloc")] +macro_rules! map_as_tuple_seq { + ($tyorig:ident < K, V $(, $typaram:ident : $bound:ident)* >) => { + map_as_tuple_seq_intern!($tyorig<K, V $(, $typaram: $bound)* >, Seq<(K, V)>); + #[cfg(feature = "alloc")] + map_as_tuple_seq_intern!($tyorig<K, V $(, $typaram: $bound)* >, Vec<(K, V)>); + } +} +foreach_map!(map_as_tuple_seq); + +macro_rules! tuple_seq_as_map_impl_intern { + ($tyorig:ident < (K, V) $(, $typaram:ident : $bound:ident)* >, $ty:ident <K, V>) => { + #[allow(clippy::implicit_hasher)] + impl<K, KAs, V, VAs $(, $typaram)*> SerializeAs<$tyorig<(K, V) $(, $typaram)*>> for $ty<KAs, VAs> + where + KAs: SerializeAs<K>, + VAs: SerializeAs<V>, + $($typaram: ?Sized + $bound,)* + { + fn serialize_as<S>(source: &$tyorig<(K, V) $(, $typaram)*>, 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 { + ($tyorig:ident < (K, V) $(, $typaram:ident : $bound:ident)* >) => { + tuple_seq_as_map_impl_intern!($tyorig<(K, V) $(, $typaram: $bound)* >, Map<K, V>); + #[cfg(feature = "alloc")] + tuple_seq_as_map_impl_intern!($tyorig<(K, V) $(, $typaram: $bound)* >, BTreeMap<K, V>); + #[cfg(feature = "std")] + tuple_seq_as_map_impl_intern!($tyorig<(K, V) $(, $typaram: $bound)* >, HashMap<K, V>); + } +} +foreach_seq!(tuple_seq_as_map_impl, (K, V)); +tuple_seq_as_map_impl!(Option<(K, V)>); + +macro_rules! tuple_seq_as_map_arr { + ($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_arr!([(K, V); N], Map<K, V>); +#[cfg(feature = "alloc")] +tuple_seq_as_map_arr!([(K, V); N], BTreeMap<K, V>); +#[cfg(feature = "std")] +tuple_seq_as_map_arr!([(K, V); N], HashMap<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, + { + serializer.collect_str(source) + } +} + +#[cfg(feature = "alloc")] +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<T> SerializeAs<Option<T>> for NoneAsEmptyString +where + T: Display, +{ + fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + if let Some(value) = source { + serializer.collect_str(value) + } else { + serializer.serialize_str("") + } + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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: formats::Separator, + for<'x> &'x I: IntoIterator<Item = &'x T>, + T: Display, + // This set of bounds is enough to make the function compile but has inference issues + // making it unusable at the moment. + // https://github.com/rust-lang/rust/issues/89196#issuecomment-932024770 + // for<'x> &'x I: IntoIterator, + // for<'x> <&'x I as IntoIterator>::Item: Display, +{ + fn serialize_as<S>(source: &I, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + pub(crate) struct DisplayWithSeparator<'a, I, SEPARATOR>(&'a I, PhantomData<SEPARATOR>); + + impl<'a, I, SEPARATOR> DisplayWithSeparator<'a, I, SEPARATOR> { + pub(crate) fn new(iter: &'a I) -> Self { + Self(iter, PhantomData) + } + } + + impl<'a, I, SEPARATOR> Display for DisplayWithSeparator<'a, I, SEPARATOR> + where + SEPARATOR: formats::Separator, + &'a I: IntoIterator, + <&'a I as IntoIterator>::Item: Display, + { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut iter = self.0.into_iter(); + + if let Some(first) = iter.next() { + first.fmt(f)?; + } + for elem in iter { + f.write_str(SEPARATOR::separator())?; + elem.fmt(f)?; + } + + Ok(()) + } + } + + serializer.collect_str(&DisplayWithSeparator::<I, SEPARATOR>::new(source)) + } +} + +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} + } +); +#[cfg(feature = "alloc")] +use_signed_duration!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Duration => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +use_signed_duration!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "alloc")] +use_signed_duration!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Duration => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); + +#[cfg(feature = "std")] +use_signed_duration!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + SystemTime => + {i64, STRICTNESS => STRICTNESS: Strictness} + {f64, STRICTNESS => STRICTNESS: Strictness} + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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<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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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()) + } +} + +#[cfg(feature = "alloc")] +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), + } + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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()) + } +} + +#[cfg(feature = "alloc")] +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()) + } +} + +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/mod.rs b/third_party/rust/serde_with/src/ser/mod.rs new file mode 100644 index 0000000000..657f8ad8eb --- /dev/null +++ b/third_party/rust/serde_with/src/ser/mod.rs @@ -0,0 +1,173 @@ +//! 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 + +#[cfg(feature = "alloc")] +mod duplicates; +mod impls; + +use crate::prelude::*; + +/// 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 be 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::{serde_as, 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_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. +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) + } +} + +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) + } +} 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..ebf4c81ac5 --- /dev/null +++ b/third_party/rust/serde_with/src/serde_conv.rs @@ -0,0 +1,150 @@ +/// 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}; +/// # use serde_with::serde_as; +/// +/// #[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_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; + + const _:() = { + #[allow(clippy::ptr_arg)] + impl $m { + $vis fn serialize<S>(x: &$t, serializer: S) -> $crate::__private__::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) -> $crate::__private__::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) -> $crate::__private__::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) -> $crate::__private__::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..823959fd0b --- /dev/null +++ b/third_party/rust/serde_with/src/time_0_3.rs @@ -0,0 +1,625 @@ +//! 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::{ + formats::{Flexible, Format, Strict, Strictness}, + prelude::*, +}; +#[cfg(feature = "std")] +use ::time_0_3::format_description::well_known::{ + iso8601::EncodedConfig, Iso8601, Rfc2822, Rfc3339, +}; +use ::time_0_3::{Duration as Time03Duration, 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: &Time03Duration) -> DurationSigned { + let std_dur = Duration::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<Time03Duration, D::Error> +where + D: Deserializer<'de>, +{ + let mut dur: Time03Duration = match sdur.duration.try_into() { + Ok(dur) => dur, + Err(msg) => { + return Err(DeError::custom(format_args!( + "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, + => { + Time03Duration; duration_into_duration_signed => + {i64, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Time03Duration; duration_into_duration_signed => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +use_duration_signed_ser!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Time03Duration; duration_into_duration_signed => + {f64, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; offset_datetime_to_duration => + {i64, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; offset_datetime_to_duration => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; offset_datetime_to_duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + } +); +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {i64, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +use_duration_signed_ser!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + } +); + +// Duration/Timestamp WITH FRACTIONS +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Time03Duration; duration_into_duration_signed => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +use_duration_signed_ser!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Time03Duration; duration_into_duration_signed => + {f64, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; offset_datetime_to_duration => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; offset_datetime_to_duration => + {f64, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {String, STRICTNESS => STRICTNESS: Strictness} + } +); +#[cfg(feature = "std")] +use_duration_signed_ser!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; primitive_datetime_to_duration => + {f64, 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, + => { + Time03Duration; duration_from_duration_signed => + {i64, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Time03Duration; duration_from_duration_signed => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + DurationSeconds DurationSeconds, + DurationMilliSeconds DurationMilliSeconds, + DurationMicroSeconds DurationMicroSeconds, + DurationNanoSeconds DurationNanoSeconds, + => { + Time03Duration; duration_from_duration_signed => + {f64, Strict =>} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; duration_to_offset_datetime => + {i64, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; duration_to_offset_datetime => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + OffsetDateTime; duration_to_offset_datetime => + {f64, Strict =>} + } +); +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {i64, Strict =>} + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + TimestampSeconds DurationSeconds, + TimestampMilliSeconds DurationMilliSeconds, + TimestampMicroSeconds DurationMicroSeconds, + TimestampNanoSeconds DurationNanoSeconds, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {f64, Strict =>} + } +); + +// Duration/Timestamp WITH FRACTIONS +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Time03Duration; duration_from_duration_signed => + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Time03Duration; duration_from_duration_signed => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + DurationSecondsWithFrac DurationSecondsWithFrac, + DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac, + DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac, + DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + Time03Duration; duration_from_duration_signed => + {f64, Strict =>} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; duration_to_offset_datetime => + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; duration_to_offset_datetime => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + OffsetDateTime; duration_to_offset_datetime => + {f64, Strict =>} + } +); +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {FORMAT, Flexible => FORMAT: Format} + } +); +#[cfg(feature = "alloc")] +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {String, Strict =>} + } +); +#[cfg(feature = "std")] +use_duration_signed_de!( + TimestampSecondsWithFrac DurationSecondsWithFrac, + TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac, + TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac, + TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac, + => { + PrimitiveDateTime; duration_to_primitive_datetime => + {f64, Strict =>} + } +); + +#[cfg(feature = "std")] +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) + } +} + +#[cfg(feature = "std")] +impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc2822 { + fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error> + where + D: Deserializer<'de>, + { + struct Helper; + impl<'de> Visitor<'de> for Helper { + type Value = OffsetDateTime; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a RFC2822-formatted `OffsetDateTime`") + } + + fn visit_str<E: DeError>(self, value: &str) -> Result<Self::Value, E> { + Self::Value::parse(value, &Rfc2822).map_err(E::custom) + } + } + + deserializer.deserialize_str(Helper) + } +} + +#[cfg(feature = "std")] +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) + } +} + +#[cfg(feature = "std")] +impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc3339 { + fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error> + where + D: Deserializer<'de>, + { + struct Helper; + impl<'de> Visitor<'de> for Helper { + type Value = OffsetDateTime; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a RFC3339-formatted `OffsetDateTime`") + } + + fn visit_str<E: DeError>(self, value: &str) -> Result<Self::Value, E> { + Self::Value::parse(value, &Rfc3339).map_err(E::custom) + } + } + + deserializer.deserialize_str(Helper) + } +} + +#[cfg(feature = "std")] +impl<const CONFIG: EncodedConfig> SerializeAs<OffsetDateTime> for Iso8601<CONFIG> { + fn serialize_as<S>(datetime: &OffsetDateTime, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + datetime + .format(&Iso8601::<CONFIG>) + .map_err(S::Error::custom)? + .serialize(serializer) + } +} + +#[cfg(feature = "std")] +impl<'de, const CONFIG: EncodedConfig> DeserializeAs<'de, OffsetDateTime> for Iso8601<CONFIG> { + fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error> + where + D: Deserializer<'de>, + { + struct Helper<const CONFIG: EncodedConfig>; + impl<'de, const CONFIG: EncodedConfig> Visitor<'de> for Helper<CONFIG> { + type Value = OffsetDateTime; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a ISO8601-formatted `OffsetDateTime`") + } + + fn visit_str<E: DeError>(self, value: &str) -> Result<Self::Value, E> { + Self::Value::parse(value, &Iso8601::<CONFIG>).map_err(E::custom) + } + } + + deserializer.deserialize_str(Helper::<CONFIG>) + } +} 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..5bd48daf3b --- /dev/null +++ b/third_party/rust/serde_with/src/utils.rs @@ -0,0 +1,194 @@ +pub(crate) mod duration; + +use crate::prelude::*; + +/// Re-Implementation of `serde::private::de::size_hint::cautious` +#[cfg(feature = "alloc")] +#[inline] +pub(crate) fn size_hint_cautious(hint: Option<usize>) -> usize { + core::cmp::min(hint.unwrap_or(0), 4096) +} + +/// Re-Implementation of `serde::private::de::size_hint::from_bounds` +#[cfg(feature = "alloc")] +#[inline] +pub fn size_hint_from_bounds<I>(iter: &I) -> Option<usize> +where + I: Iterator, +{ + fn _size_hint_from_bounds(bounds: (usize, Option<usize>)) -> Option<usize> { + match bounds { + (lower, Some(upper)) if lower == upper => Some(upper), + _ => None, + } + } + _size_hint_from_bounds(iter.size_hint()) +} + +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: &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<DurationSigned, &'static str> { + 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"); + } + if nanos >= MAX_NANOS_F64 { + return Err("overflow when converting float to duration"); + } + 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, + )) +} + +/// Collect an array of a fixed size from an iterator. +/// +/// # 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> +pub(crate) 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: DeError, +{ + use core::mem::MaybeUninit; + + 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 + + // Clippy is broken and has a false positive here + // https://github.com/rust-lang/rust-clippy/issues/10551 + #[allow(clippy::uninit_assumed_init)] + 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(DeError::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) }) +} 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..832ea85984 --- /dev/null +++ b/third_party/rust/serde_with/src/utils/duration.rs @@ -0,0 +1,565 @@ +//! Internal Helper types + +use crate::{ + formats::{Flexible, Format, Strict, Strictness}, + prelude::*, +}; + +#[derive(Copy, Clone, PartialEq, Eq)] +#[cfg_attr(test, derive(Debug))] +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: core::ops::Neg<Output = T>, + { + match *self { + Sign::Positive => value, + Sign::Negative => value.neg(), + } + } +} + +#[derive(Copy, Clone)] +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_0_4", feature = "time_0_3"))] + pub(crate) fn with_duration(sign: Sign, duration: Duration) -> Self { + Self { sign, duration } + } + + #[cfg(feature = "std")] + 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(|| DeError::custom("timestamp is outside the range for std::time::SystemTime")) + } + + #[cfg(feature = "std")] + 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(DeError::custom("std::time::Duration cannot be negative")), + } + } +} + +impl From<&Duration> for DurationSigned { + fn from(&duration: &Duration) -> Self { + Self { + sign: Sign::Positive, + duration, + } + } +} + +#[cfg(feature = "std")] +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(SerError::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) + } +} + +#[cfg(feature = "alloc")] +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) + } +} + +#[cfg(feature = "alloc")] +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: DeError, + { + 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: DeError, + { + Ok(DurationSigned::new(Sign::Positive, secs, 0)) + } + + fn visit_f64<E>(self, secs: f64) -> Result<Self::Value, E> + where + E: DeError, + { + utils::duration_signed_from_secs_f64(secs).map_err(DeError::custom) + } + + fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> + where + E: DeError, + { + match parse_float_into_time_parts(value) { + Ok((sign, seconds, subseconds)) => Ok(DurationSigned::new(sign, seconds, subseconds)), + Err(ParseFloatError::InvalidValue) => { + Err(DeError::invalid_value(Unexpected::Str(value), &self)) + } + Err(ParseFloatError::Custom(msg)) => Err(DeError::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) + }) + } +} + +// round() only works on std +#[cfg(feature = "std")] +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(DeError::custom) + } +} + +#[cfg(feature = "alloc")] +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: DeError, + { + let mut secs: i64 = value.parse().map_err(DeError::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(DeError::custom) + } +} + +#[cfg(feature = "alloc")] +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(DeError::invalid_value( + Unexpected::Str(&value), + &"a string containing an integer or float", + )), + Err(ParseFloatError::Custom(msg)) => Err(DeError::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) + } +} + +#[cfg_attr(test, derive(Debug, PartialEq))] +pub(crate) enum ParseFloatError { + InvalidValue, + #[cfg(not(feature = "alloc"))] + Custom(&'static str), + #[cfg(feature = "alloc")] + 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 partslen = value.split('.').count(); + let mut parts = value.split('.'); + match partslen { + 1 => { + let seconds = parts.next().expect("Float contains exactly one part"); + if let Ok(seconds) = seconds.parse() { + Ok((sign, seconds, 0)) + } else { + Err(ParseFloatError::InvalidValue) + } + } + 2 => { + let seconds = parts.next().expect("Float contains exactly one part"); + if let Ok(seconds) = seconds.parse() { + let subseconds = parts.next().expect("Float contains exactly one part"); + let subseclen = subseconds.chars().count() as u32; + if subseclen > 9 { + #[cfg(feature = "alloc")] + return Err(ParseFloatError::Custom(alloc::format!( + "Duration and Timestamps with no more than 9 digits precision, but '{value}' has more" + ))); + #[cfg(not(feature = "alloc"))] + return Err(ParseFloatError::Custom( + "Duration and Timestamps with no more than 9 digits precision", + )); + } + + 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..f5a5d41fc3 --- /dev/null +++ b/third_party/rust/serde_with/src/with_prefix.rs @@ -0,0 +1,604 @@ +use crate::prelude::*; + +/// 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) -> $crate::__private__::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) -> $crate::__private__::Result<T, D::Error> + where + T: Deserialize<'de>, + D: Deserializer<'de>, + { + T::deserialize(WithPrefix { + delegate: deserializer, + prefix: $prefix, + }) + } + } + }; +} + +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(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { + Err(SerError::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(SerError::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(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { + Err(SerError::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(SerError::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(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { + Err(SerError::custom("wrong type for with_prefix")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { + Err(SerError::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(SerError::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(SerError::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) + } +} + +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: DeError, + { + 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) + } +} |