summaryrefslogtreecommitdiffstats
path: root/third_party/rust/serde_with
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
commit43a97878ce14b72f0981164f87f2e35e14151312 (patch)
tree620249daf56c0258faa40cbdcf9cfba06de2a846 /third_party/rust/serde_with
parentInitial commit. (diff)
downloadfirefox-upstream.tar.xz
firefox-upstream.zip
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/serde_with')
-rw-r--r--third_party/rust/serde_with/.cargo-checksum.json1
-rw-r--r--third_party/rust/serde_with/CHANGELOG.md682
-rw-r--r--third_party/rust/serde_with/Cargo.toml214
-rw-r--r--third_party/rust/serde_with/LICENSE-APACHE201
-rw-r--r--third_party/rust/serde_with/LICENSE-MIT25
-rw-r--r--third_party/rust/serde_with/README.md188
-rw-r--r--third_party/rust/serde_with/src/base64.rs205
-rw-r--r--third_party/rust/serde_with/src/chrono.rs516
-rw-r--r--third_party/rust/serde_with/src/content/mod.rs5
-rw-r--r--third_party/rust/serde_with/src/content/ser.rs623
-rw-r--r--third_party/rust/serde_with/src/de/const_arrays.rs338
-rw-r--r--third_party/rust/serde_with/src/de/impls.rs1508
-rw-r--r--third_party/rust/serde_with/src/de/legacy_arrays.rs85
-rw-r--r--third_party/rust/serde_with/src/de/mod.rs143
-rw-r--r--third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs127
-rw-r--r--third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs136
-rw-r--r--third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs69
-rw-r--r--third_party/rust/serde_with/src/duplicate_key_impls/mod.rs10
-rw-r--r--third_party/rust/serde_with/src/enum_map.rs888
-rw-r--r--third_party/rust/serde_with/src/flatten_maybe.rs86
-rw-r--r--third_party/rust/serde_with/src/formats.rs96
-rw-r--r--third_party/rust/serde_with/src/guide.md144
-rw-r--r--third_party/rust/serde_with/src/guide/feature_flags.md62
-rw-r--r--third_party/rust/serde_with/src/guide/serde_as.md332
-rw-r--r--third_party/rust/serde_with/src/guide/serde_as_transformations.md518
-rw-r--r--third_party/rust/serde_with/src/hex.rs155
-rw-r--r--third_party/rust/serde_with/src/json.rs150
-rw-r--r--third_party/rust/serde_with/src/lib.rs2034
-rw-r--r--third_party/rust/serde_with/src/rust.rs1943
-rw-r--r--third_party/rust/serde_with/src/ser/const_arrays.rs90
-rw-r--r--third_party/rust/serde_with/src/ser/impls.rs739
-rw-r--r--third_party/rust/serde_with/src/ser/legacy_arrays.rs34
-rw-r--r--third_party/rust/serde_with/src/ser/mod.rs158
-rw-r--r--third_party/rust/serde_with/src/serde_conv.rs147
-rw-r--r--third_party/rust/serde_with/src/time_0_3.rs382
-rw-r--r--third_party/rust/serde_with/src/utils.rs120
-rw-r--r--third_party/rust/serde_with/src/utils/duration.rs559
-rw-r--r--third_party/rust/serde_with/src/with_prefix.rs612
-rw-r--r--third_party/rust/serde_with/tests/base64.rs144
-rw-r--r--third_party/rust/serde_with/tests/chrono.rs740
-rw-r--r--third_party/rust/serde_with/tests/derives/deserialize_fromstr.rs96
-rw-r--r--third_party/rust/serde_with/tests/derives/lib.rs15
-rw-r--r--third_party/rust/serde_with/tests/derives/serialize_display.rs39
-rw-r--r--third_party/rust/serde_with/tests/hex.rs93
-rw-r--r--third_party/rust/serde_with/tests/indexmap.rs285
-rw-r--r--third_party/rust/serde_with/tests/json.rs41
-rw-r--r--third_party/rust/serde_with/tests/rust.rs676
-rw-r--r--third_party/rust/serde_with/tests/serde_as/collections.rs44
-rw-r--r--third_party/rust/serde_with/tests/serde_as/default_on.rs130
-rw-r--r--third_party/rust/serde_with/tests/serde_as/enum_map.rs459
-rw-r--r--third_party/rust/serde_with/tests/serde_as/frominto.rs187
-rw-r--r--third_party/rust/serde_with/tests/serde_as/lib.rs1129
-rw-r--r--third_party/rust/serde_with/tests/serde_as/map_tuple_list.rs272
-rw-r--r--third_party/rust/serde_with/tests/serde_as/pickfirst.rs134
-rw-r--r--third_party/rust/serde_with/tests/serde_as/serde_as_macro.rs191
-rw-r--r--third_party/rust/serde_with/tests/serde_as/serde_conv.rs52
-rw-r--r--third_party/rust/serde_with/tests/serde_as/time.rs521
-rw-r--r--third_party/rust/serde_with/tests/time_0_3.rs229
-rw-r--r--third_party/rust/serde_with/tests/utils.rs79
-rw-r--r--third_party/rust/serde_with/tests/version_numbers.rs80
-rw-r--r--third_party/rust/serde_with/tests/with_prefix.rs164
61 files changed, 20125 insertions, 0 deletions
diff --git a/third_party/rust/serde_with/.cargo-checksum.json b/third_party/rust/serde_with/.cargo-checksum.json
new file mode 100644
index 0000000000..ac5b75ca75
--- /dev/null
+++ b/third_party/rust/serde_with/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"d3291ed2505ed562246982c982393be13428c33320fb4fe978c4a16553e32b86","Cargo.toml":"0c01c0832dc504b98d4df90e2c3b460ae4099d53272c3b262725a71c7a5d8569","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7576269ea71f767b99297934c0b2367532690f8c4badc695edf8e04ab6a1e545","README.md":"b85503ad4bc4d7d932583e404bb04f376c3630364719462a7fcd6daf6c1193d1","src/base64.rs":"1d8b125a7bab23fe974aa429b938344a0263156448aa0a3e70486fbf7e84cae3","src/chrono.rs":"a7d3d9afd13befd72418f845ca371018b321a5da844d09be2ed808b3040b36a4","src/content/mod.rs":"f8900091c0cffacc6946a98a98d7c9fb16ff13a6d0335777bd60d0f9832a3988","src/content/ser.rs":"631702fbd1671e1ebc44b3515b0da7094fc8dbafa5390b5a8e34f0d635274d68","src/de/const_arrays.rs":"161debd41e388bcbdadb035d48a05e23ed0aa950749d7d690120240a8a78bf6f","src/de/impls.rs":"86f8c377d1dff802eaa42761c2b9da88c2880cbb50a82f0b18d0e73fa3c1076d","src/de/legacy_arrays.rs":"7271d976b16ec102f1e3ffb0852eb60d34000133b3612d96782ae94f57a0273b","src/de/mod.rs":"4b8c1a248f84ba479be542bca023064c9d96d183084cb769d0d01227139dc5c3","src/duplicate_key_impls/error_on_duplicate.rs":"df63ea30c1d2965cc83c4d8e24b6b9e4ec93648835f586dce1a7a3c94cc1e098","src/duplicate_key_impls/first_value_wins.rs":"f1f84931df16f4ed5f4e5570ea2bdeb8af20957e2c3a160cb0137f3a9aad1bbb","src/duplicate_key_impls/last_value_wins.rs":"0ebf6ff1a80ba5a9d507f97b6482fa7721f66c81acb6982564bb293a241efd87","src/duplicate_key_impls/mod.rs":"0c6867f48ca5b9aea3260d8aadab23e30c0f98fc7a685c3a91ffac8c9cbaf817","src/enum_map.rs":"00b7e52f4cedb52c5aecf3aeb8fe65752a4cacee6108c64165c1a526afbf6606","src/flatten_maybe.rs":"32ab7f2e9c87357eda8834d1ca98e5cd7f3a257b2d80e5b16551fb26ae1f9eb6","src/formats.rs":"b56e83c35a385b4e54b91e5a6ca6dbea0121c08026d3269da632e1db730bc0d7","src/guide.md":"9e2af8ca56d3d9d76eaa1651f4397e0da1f9d8743a8d3412134c16823242dca8","src/guide/feature_flags.md":"f5a22a34371905027891e191141aad604252bea414fc9834727392c6d32679eb","src/guide/serde_as.md":"0323ecbeb8bd75e34dc1c0977f801c3a35dd420880faf57331a3f8df18e83d7e","src/guide/serde_as_transformations.md":"26aa40b1452aeb27851b9fa575db26515d63afe32efd6ac5542474b9575d4853","src/hex.rs":"9fc4bae4a435fab2cfc1bb39b5dcda1d335f69448d8e6f373e352ab5c4d0568a","src/json.rs":"db9604f55569b3290a519353aa746ba9f5080dd364671697f54e6faeaa4d8c40","src/lib.rs":"bd12fcd39baf7488163bbb4c6dfcec68ec22bfd946d317ace71b9d6e50611e58","src/rust.rs":"7b2847f91f4780c84a9e098031aea2cd1b544d35040147c9e42074e6723f981c","src/ser/const_arrays.rs":"48d6231a6396cfda634d69ae9672321fda7626049d8705e9006438e0dce8c789","src/ser/impls.rs":"5b532c310e5f3b6c987711b43a6645bf7ca5a524a2304464cc2c109cbf8ca276","src/ser/legacy_arrays.rs":"54ee16c90b18cb76657d51dbb7fd85a90c04798bdfd27593d63e5c3f8cfb9b14","src/ser/mod.rs":"864718e6256104278cbcaec4caa6db3822f3747b830f53815eafec613b3e6f4a","src/serde_conv.rs":"000bc7ed387afc6824819f1da4dca6dcaf98f466aa0130897a795ae36e1a2730","src/time_0_3.rs":"24f1edc87f6da0014a990656b80bdb2b1d4833ecf5d7de768ffb2eb3db85a9ed","src/utils.rs":"d0f770493294c3951516929becf4681eeaaec8340673c2a46b8f5503d778bd45","src/utils/duration.rs":"696fe02d2a6f988d1d428821d40404ecd00b8faad4f2ad45c1a930cb98b53c76","src/with_prefix.rs":"2877a7861715b4a809048e99c48523fc7901c8a8e936c1b145d067bfc2109b87","tests/base64.rs":"e944a600ab728108e974d5e7697c4adc0c0e2907f0b0390f2e14342abe431e41","tests/chrono.rs":"90810d1c47b9e1c0ac7d032fe28599aeee182bfa1ad350a690908900ab5e20a2","tests/derives/deserialize_fromstr.rs":"b23b236247b619eecc25053f64e527f44fd066d602027f4b1518b333110362e9","tests/derives/lib.rs":"abb2046d6798889dcef2cf40157f3182851ae87436d0f981adecd76051d74b5a","tests/derives/serialize_display.rs":"9ae9ad6c632202639e6e7ddeeaa6c5613593a9c2cc5275e175eb866ba727fb31","tests/hex.rs":"3d3198efed7d328962695e359eb5fc688531fb9c2befa270401109d04167d0ff","tests/indexmap.rs":"855a7cf19622f53c201ba3e459ecc3c0edff325d07de50ac0a61c16767166e17","tests/json.rs":"97a093eff339aba9a14eb4ee406ff9d22cf88b5be55b87f48c3a7772a3ccfd51","tests/rust.rs":"b904fb96b3a1e8d3e8fd4923f7b467bbf2eae550875d6878ddde87da12a06f0a","tests/serde_as/collections.rs":"e09c62f6ad84aa2493bfc20817edbe6216b35614e2b92f510536252a11041e7c","tests/serde_as/default_on.rs":"c2e7aad6f4c309305dc925b7c95e3cb2c10bf462fb5577448606416913400a56","tests/serde_as/enum_map.rs":"48589f746440cf05f902674e591c0636f54f03db569d8b4baecb8e24d0a3993c","tests/serde_as/frominto.rs":"c7feb6d10a85c54a46ca619f7b7751c2d4a2ac2a936dfec64b8050267152cd96","tests/serde_as/lib.rs":"8aded29ac5fa60811bf050905237c7231fb1fcaeeabdd9470c01ddeb1bd4ebb5","tests/serde_as/map_tuple_list.rs":"655de06a6df00075c68f4084c9b2524bd4503a5ca8b2102cfa43d48df53ccc53","tests/serde_as/pickfirst.rs":"6f0d32f57e1fc31b73952f5ba523794de8667633530418bcc5d821d28556e54c","tests/serde_as/serde_as_macro.rs":"b0799238f56fe3f0d1a697a9bf4474cda8c5498e7ed5323848e6becaf141a98c","tests/serde_as/serde_conv.rs":"1d3546d46390e631fe380e8cf56a8ed45020958b82eb6396d33062e133237173","tests/serde_as/time.rs":"69cdd8db5432a0eafa2da08ca633872c160ce23302ae03dc2f397191b9de9477","tests/time_0_3.rs":"969e4ddb58b164cdb3d22e0b7e030b526e009e145064e7c871437d6bb3a13c40","tests/utils.rs":"f540ced55ae803fa98404812078ecc2c6aca10e9052f39a1b812bbde9dff5df5","tests/version_numbers.rs":"f274da4dad87fbeba4b30e3485c7a6d3f2dcf5b778a7acaf3caea9393d10c8b0","tests/with_prefix.rs":"cff484c442a3504342f793da451ce9c9d3aa4180781aebc965971bae34783ecc"},"package":"678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff"} \ No newline at end of file
diff --git a/third_party/rust/serde_with/CHANGELOG.md b/third_party/rust/serde_with/CHANGELOG.md
new file mode 100644
index 0000000000..ca42d74bf1
--- /dev/null
+++ b/third_party/rust/serde_with/CHANGELOG.md
@@ -0,0 +1,682 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.14.0] - 2022-05-29
+
+### Added
+
+* Add support for `time` crate v0.3 #450
+
+ `time::Duration` can now be serialized with the `DurationSeconds` and related converters.
+
+ ```rust
+ // Rust
+ #[serde_as(as = "serde_with::DurationSeconds<u64>")]
+ value: Duration,
+
+ // JSON
+ "value": 86400,
+ ```
+
+ `time::OffsetDateTime` and `time::PrimitiveDateTime` can now be serialized with the `TimestampSeconds` and related converters.
+
+ ```rust
+ // Rust
+ #[serde_as(as = "serde_with::TimestampMicroSecondsWithFrac<String>")]
+ value: time::PrimitiveDateTime,
+
+ // JSON
+ "value": "1000000",
+ ```
+
+ `time::OffsetDateTime` can be serialized in string format in different well-known formats.
+ Two formats are supported, `time::format_description::well_known::Rfc2822` and `time::format_description::well_known::Rfc3339`.
+
+ ```rust
+ // Rust
+ #[serde_as(as = "time::format_description::well_known::Rfc2822")]
+ rfc_2822: OffsetDateTime,
+ #[serde_as(as = "Vec<time::format_description::well_known::Rfc3339>")]
+ rfc_3339: Vec<OffsetDateTime>,
+
+ // JSON
+ "rfc_2822": "Fri, 21 Nov 1997 09:55:06 -0600",
+ "rfc_3339": ["1997-11-21T09:55:06-06:00"],
+ ```
+
+* Deserialize `bool` from integers #456 462
+
+ 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.
+
+ ```rust
+ // Rust
+ #[serde_as(as = "BoolFromInt")] // BoolFromInt<Strict>
+ b: bool,
+
+ // JSON
+ "b": 1,
+ ```
+
+### Changed
+
+* Bump MSRV to 1.53, since the new dependency `time` requires that version.
+
+### Fixed
+
+* Make the documentation clearer by stating that the `#[serde_as]` and `#[skip_serializing_none]` attributes must always be places before `#[derive]`.
+
+## [1.13.0] - 2022-04-23
+
+### Added
+
+* Added support for `indexmap::IndexMap` and `indexmap::IndexSet` types. #431, #436
+
+ Both types are now compatible with these functions: `maps_duplicate_key_is_error`, `maps_first_key_wins`, `sets_duplicate_value_is_error`, `sets_last_value_wins`.
+ `serde_as` integration is provided by implementing both `SerializeAs` and `DeserializeAs` for both types.
+ `IndexMap`s can also be serialized as a list of types via the `serde_as(as = "Vec<(_, _)>")` annotation.
+
+ All implementations are gated behind the `indexmap` feature.
+
+ Thanks to @jgrund for providing parts of the implementation.
+
+## [1.12.1] - 2022-04-07
+
+### Fixed
+
+* Depend on a newer `serde_with_macros` version to pull in some fixes.
+ * Account for generics when deriving implementations with `SerializeDisplay` and `DeserializeFromStr` #413
+ * Provide better error messages when parsing types fails #423
+
+
+## [1.12.0] - 2022-02-07
+
+### Added
+
+* Deserialize a `Vec` and skip all elements failing to deserialize #383
+
+ `VecSkipError` acts like a `Vec`, but elements which fail to deserialize, like the `"Yellow"` are ignored.
+
+ ```rust
+ #[derive(serde::Deserialize)]
+ enum Color {
+ Red,
+ Green,
+ Blue,
+ }
+ // JSON
+ "colors": ["Blue", "Yellow", "Green"],
+ // Rust
+ #[serde_as(as = "VecSkipError<_>")]
+ colors: Vec<Color>,
+ // => vec![Blue, Green]
+ ```
+
+ Thanks to @hdhoang for creating the PR.
+
+* Transform between maps and `Vec<Enum>` #375
+
+ The new `EnumMap` type converts `Vec` of enums into a single map.
+ The key is the enum variant name, and the value is the variant value.
+
+ ```rust
+ // Rust
+ 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",
+ }
+ }
+ ```
+
+### Changed
+
+* The `Timestamp*Seconds` and `Timestamp*SecondsWithFrac` types can now be used with `chrono::NaiveDateTime`. #389
+
+## [1.11.0] - 2021-10-18
+
+### Added
+
+* Serialize bytes as base64 encoded strings.
+ The character set and padding behavior can be configured.
+
+ ```rust
+ // 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",
+ ```
+
+* The minimal supported Rust version (MSRV) is now specified in the `Cargo.toml` via the `rust-version` field. The field is supported in Rust 1.56 and has no effect on versions before.
+
+ More details: https://doc.rust-lang.org/nightly/cargo/reference/manifest.html#the-rust-version-field
+
+### Fixed
+
+* Fixed RUSTSEC-2020-0071 in the `time` v0.1 dependency, but changing the feature flags of the `chrono` dependency. This should not change anything. Crates requiring the `oldtime` feature of `chrono` can enable it separately.
+* Allow `HashSet`s with custom hashers to be deserialized when used in combination with `serde_as`. #408
+
+## [1.10.0] - 2021-09-04
+
+### Added
+
+* Add `BorrowCow` which instructs serde to borrow data during deserialization of `Cow<'_, str>`, `Cow<'_, [u8]>`, or `Cow<'_, [u8; N]>`. (#347)
+ The implementation is for [serde#2072](https://github.com/serde-rs/serde/pull/2072#pullrequestreview-735511713) and [serde#2016](https://github.com/serde-rs/serde/issues/2016), about `#[serde(borrow)]` not working for `Option<Cow<'a, str>>`.
+
+ ```rust
+ #[serde_as]
+ #[derive(Deserialize, Serialize)]
+ struct Data<'a> {
+ #[serde_as(as = "Option<[BorrowCow; 1]>")]
+ nested: Option<[Cow<'a, str>; 1]>,
+ }
+ ```
+
+ The `#[serde(borrow)]` annotation is automatically added by the `#[serde_as]` attribute.
+
+### Changed
+
+* Bump MSRV to 1.46, since the dev-dependency `bitflags` requires that version now.
+* `flattened_maybe!` no longer requires the `serde_with` crate to be available with a specific name.
+ This allows renaming the crate or using `flattened_maybe!` through a re-export without any complications.
+
+## [1.9.4] - 2021-06-18
+
+### Fixed
+
+* `with_prefix!` now supports an optional visibility modifier. (#327, #328)
+ If not specified `pub(self)` is assumed.
+
+ ```rust
+ with_prefix!(prefix_active "active_"); // => mod {...}
+ with_prefix!(pub prefix_active "active_"); // => pub mod {...}
+ with_prefix!(pub(crate) prefix_active "active_"); // => pub(crate) mod {...}
+ with_prefix!(pub(in other_mod) prefix_active "active_"); // => pub(in other_mod) mod {...}
+ ```
+
+ Thanks to @elpiel for raising and fixing the issue.
+
+## [1.9.3] - 2021-06-14
+
+### Added
+
+* The `Bytes` type now supports borrowed and Cow arrays of fixed size (requires Rust 1.51+)
+
+ ```rust
+ #[serde_as(as = "Bytes")]
+ #[serde(borrow)]
+ borrowed_array: &'a [u8; 15],
+ #[serde_as(as = "Bytes")]
+ #[serde(borrow)]
+ cow_array: Cow<'a, [u8; 15]>,
+ ```
+
+ Note: For borrowed arrays the used Deserializer needs to support Serde's 0-copy deserialization.
+
+## [1.9.2] - 2021-06-07
+
+### Fixed
+
+* Suppress clippy warnings, which can occur while using `serde_conv` (#320)
+ Thanks to @mkroening for reporting and fixing the issue.
+
+## [1.9.1] - 2021-05-15
+
+### Changed
+
+* `NoneAsEmptyString`: Deserialize using `FromStr` instead of using `for<'a> From<&'a str>` (#316)
+ This will *not* change any behavior when applied to a field of type `Option<String>` as used in the documentation.
+ Thanks to @mkroening for finding and fixing the issue.
+
+## [1.9.0] - 2021-05-09
+
+### Added
+
+* Added `FromInto` and `TryFromInto` adapters, which enable serialization by converting into a proxy type.
+
+ ```rust
+ // 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],
+ ```
+
+* New `serde_conv!` macro to create conversion types with reduced boilerplate.
+ The generated types can be used with `#[serde_as]` or serde's with-attribute.
+
+ ```rust
+ 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],
+ })
+ }
+ );
+ ```
+
+## [1.8.1] - 2021-04-19
+
+### Added
+
+* The `hex::Hex` type also works for u8-arrays on Rust 1.48.
+ Thanks to @TheAlgorythm for raising and fixing the issue.
+
+## [1.8.0] - 2021-03-30
+
+### Added
+
+* Added `PickFirst` adapter for `serde_as`. [#291]
+ It allows deserializing from multiple different forms.
+ Deserializing a number from either a number or string can be implemented like:
+
+ ```rust
+ #[serde_as(as = "PickFirst<(_, DisplayFromStr)>")]
+ value: u32,
+ ```
+
+* Implement `SerializeAs`/`DeserializeAs` for more wrapper types. [#288], [#293]
+ This now supports:
+ * `Arc`, `sync::Weak`
+ * `Rc`, `rc::Weak`
+ * `Cell`, `RefCell`
+ * `Mutex`, `RwLock`
+ * `Result`
+
+[#288]: https://github.com/jonasbb/serde_with/issues/288
+[#291]: https://github.com/jonasbb/serde_with/issues/291
+[#293]: https://github.com/jonasbb/serde_with/issues/293
+
+### Changed
+
+* Add a new `serde_with::rust::map_as_tuple_list` module as a replacement for `serde_with::rust::btreemap_as_tuple_list` and `serde_with::rust::hashmap_as_tuple_list`.
+ The new module uses `IntoIterator` and `FromIterator` as trait bound making it usable in more situations.
+ The old names continue to exist but are marked as deprecated.
+
+### Deprecated
+
+* Deprecated the module names `serde_with::rust::btreemap_as_tuple_list` and `serde_with::rust::hashmap_as_tuple_list`.
+ You can use `serde_with::rust::map_as_tuple_list` as a replacement.
+
+### Fixed
+
+* Implement `Timestamp*Seconds` and `Duration*Seconds` also for chrono types.
+ This closes [#194]. This was incompletely implemented in [#199].
+
+[#194]: https://github.com/jonasbb/serde_with/issues/194
+[#199]: https://github.com/jonasbb/serde_with/issues/199
+
+## [1.7.0] - 2021-03-24
+
+### Added
+
+* Add support for arrays of arbitrary size. ([#272])
+ This feature requires Rust 1.51+.
+
+ ```rust
+ // Rust
+ #[serde_as(as = "[[_; 64]; 33]")]
+ value: [[u8; 64]; 33],
+
+ // JSON
+ "value": [[0,0,0,0,0,...], [0,0,0,...], ...],
+ ```
+
+ Mapping of arrays was available before, but limited to arrays of length 32.
+ All conversion methods are available for the array elements.
+
+ This is similar to the existing [`serde-big-array`] crate with three important improvements:
+
+ 1. Support for the `serde_as` annotation.
+ 2. Supports non-copy elements (see [serde-big-array#6][serde-big-array-copy]).
+ 3. Supports arbitrary nestings of arrays (see [serde-big-array#7][serde-big-array-nested]).
+
+[#272]: https://github.com/jonasbb/serde_with/pull/272
+[`serde-big-array`]: https://crates.io/crates/serde-big-array
+[serde-big-array-copy]: https://github.com/est31/serde-big-array/issues/6
+[serde-big-array-nested]: https://github.com/est31/serde-big-array/issues/7
+
+* Arrays with tuple elements can now be deserialized from a map. ([#272])
+ This feature requires Rust 1.51+.
+
+ ```rust
+ // Rust
+ #[serde_as(as = "BTreeMap<_, _>")]
+ value: [(String, u16); 3],
+
+ // JSON
+ "value": {
+ "a": 1,
+ "b": 2,
+ "c": 3
+ },
+ ```
+
+* The `Bytes` type is heavily inspired by `serde_bytes` and ports it to the `serde_as` system. ([#277])
+
+ ```rust
+ #[serde_as(as = "Bytes")]
+ value: Vec<u8>,
+ ```
+
+ Compared to `serde_bytes` these improvements are available
+
+ 1. Integration with the `serde_as` annotation (see [serde-bytes#14][serde-bytes-complex]).
+ 2. Implementation for arrays of arbitrary size (Rust 1.51+) (see [serde-bytes#26][serde-bytes-arrays]).
+
+[#277]: https://github.com/jonasbb/serde_with/pull/277
+[serde-bytes-complex]: https://github.com/serde-rs/bytes/issues/14
+[serde-bytes-arrays]: https://github.com/serde-rs/bytes/issues/26
+
+* The `OneOrMany` type allows deserializing a `Vec` from either a single element or a sequence. ([#281])
+
+ ```rust
+ #[serde_as(as = "OneOrMany<_>")]
+ cities: Vec<String>,
+ ```
+
+ This allows deserializing from either `cities: "Berlin"` or `cities: ["Berlin", "Paris"]`.
+ The serialization can be configured to always emit a list with `PreferMany` or emit a single element with `PreferOne`.
+
+[#281]: https://github.com/jonasbb/serde_with/pull/281
+
+## [1.6.4] - 2021-02-16
+
+### Fixed
+
+* Fix compiling when having a struct field without the `serde_as` annotation by updating `serde_with_macros`.
+ This broke in 1.4.0 of `serde_with_macros`. [#267](https://github.com/jonasbb/serde_with/issues/267)
+
+## [1.6.3] - 2021-02-15
+
+### Changed
+
+* Bump macro crate dependency (`serde_with_macros`) to 1.4.0 to pull in those improvements.
+
+## [1.6.2] - 2021-01-30
+
+### Added
+
+* New function `serde_with::rust::deserialize_ignore_any`.
+ This function allows deserializing any data and returns the default value of the type.
+ This can be used in conjunction with `#[serde(other)]` to allow deserialization of unknown data carrying enum variants.
+
+ Thanks to @lovasoa for suggesting and implementing it.
+
+## [1.6.1] - 2021-01-24
+
+### Added
+
+* Add new types similar to `DurationSeconds` and `TimestampSeconds` but for base units of milliseconds, microseconds, and nanoseconds.
+ The `*WithFrac` variants also exist.
+* Add `SerializeAs` implementation for references.
+
+### Changed
+
+* Release `Sized` trait bound from `As`, `Same`, `SerializeAs`, and `SerializeAsWrap`.
+ Only the serialize part is relaxed.
+
+## [1.6.0] - 2020-11-22
+
+### Added
+
+* Add `DefaultOnNull` as the equivalent for `rust::default_on_null` but for the `serde_as` system.
+* Support specifying a path to the `serde_with` crate for the `serde_as` and derive macros.
+ This is useful when using crate renaming in Cargo.toml or while re-exporting the macros.
+
+ Many thanks to @tobz1000 for raising the issue and contributing fixes.
+
+### Changed
+
+* Bump minimum supported rust version to 1.40.0
+
+## [1.5.1] - 2020-10-07
+
+### Fixed
+
+* Depend on serde with the `derive` feature enabled.
+ The `derive` feature is required to deserialize untagged enums which are used in the `DefaultOnError` helpers.
+ This fixes compilation of `serde_with` in scenarios where no other crate enables the `derive` feature.
+
+## [1.5.0] - 2020-10-01
+
+### Added
+
+* The largest addition to this release is the addition of the `serde_as` de/serialization scheme.
+ It's goal is it to be a more flexible replacement to serde's with-annotation, by being more composable than before.
+ No longer is it a problem to add a custom de/serialization adapter is the type is within an `Option` or a `Vec`.
+
+ Thanks to `@markazmierczak` for the design of the trait without whom this wouldn't be possible.
+
+ More details about this new scheme can be found in the also new [user guide](https://docs.rs/serde_with/1.5.0/serde_with/guide/index.html)
+* This release also features a detailed user guide.
+ The guide focusses more on how to use this crate by providing examples.
+ For example, it includes a section about the available feature flags of this crate and how you can migrate to the shiny new `serde_as` scheme.
+* The crate now features de/serialization adaptors for the std and chrono's `Duration` types. #56 #104
+* Add a `hex` module, which allows formatting bytes (i.e. `Vec<u8>`) as a hexadecimal string.
+ The formatting supports different arguments how the formatting is happening.
+* Add two derive macros, `SerializeDisplay` and `DeserializeFromStr`, which implement the `Serialize`/`Deserialize` traits based on `Display` and `FromStr`.
+ This is in addition to the already existing methods like `DisplayFromStr`, which act locally, whereas the derive macros provide the traits expected by the rest of the ecosystem.
+
+ This is part of `serde_with_macros` v1.2.0.
+* Added some `serialize` functions to modules which previously had none.
+ This makes it easier to use the conversion when also deriving `Serialize`.
+ The functions simply pass through to the underlying `Serialize` implementation.
+ This affects `sets_duplicate_value_is_error`, `maps_duplicate_key_is_error`, `maps_first_key_wins`, `default_on_error`, and `default_on_null`.
+* Added `sets_last_value_wins` as a replacement for `sets_first_value_wins` which is deprecated now.
+ The default behavior of serde is to prefer the first value of a set so the opposite is taking the last value.
+* Added `#[serde_as]` compatible conversion methods for serializing durations and timestamps as numbers.
+ The four types `DurationSeconds`, `DurationSecondsWithFrac`, `TimestampSeconds`, `TimestampSecondsWithFrac` provide the serialization conversion with optional subsecond precision.
+ There is support for `std::time::Duration`, `chrono::Duration`, `std::time::SystemTime` and `chrono::DateTime`.
+ Timestamps are serialized as a duration since the UNIX epoch.
+ The serialization can be customized.
+ It supports multiple formats, such as `i64`, `f64`, or `String`, and the deserialization can be tweaked if it should be strict or lenient when accepting formats.
+
+### Changed
+
+* Convert the code to use 2018 edition.
+* @peterjoel improved the performance of `with_prefix!`. #101
+
+### Fixed
+
+* The `with_prefix!` macro, to add a string prefixes during serialization, now also works with unit variant enum types. #115 #116
+* The `serde_as` macro now supports serde attributes and no longer panic on unrecognized values in the attribute.
+ This is part of `serde_with_macros` v1.2.0.
+
+### Deprecated
+
+* Deprecate `sets_first_value_wins`.
+ The default behavior of serde is to take the first value, so this module is not necessary.
+
+## [1.5.0-alpha.2] - 2020-08-16
+
+### Added
+
+* Add a `hex` module, which allows formatting bytes (i.e. `Vec<u8>`) as a hexadecimal string.
+ The formatting supports different arguments how the formatting is happening.
+* Add two derive macros, `SerializeDisplay` and `DeserializeFromStr`, which implement the `Serialize`/`Deserialize` traits based on `Display` and `FromStr`.
+ This is in addition to the already existing methods like `DisplayFromStr`, which act locally, whereas the derive macros provide the traits expected by the rest of the ecosystem.
+
+ This is part of `serde_with_macros` v1.2.0-alpha.3.
+
+### Fixed
+
+* The `serde_as` macro now supports serde attributes and no longer panic on unrecognized values in the attribute.
+ This is part of `serde_with_macros` v1.2.0-alpha.2.
+
+## [1.5.0-alpha.1] - 2020-06-27
+
+### Added
+
+* The largest addition to this release is the addition of the `serde_as` de/serialization scheme.
+ It's goal is it to be a more flexible replacement to serde's with-annotation, by being more composable than before.
+ No longer is it a problem to add a custom de/serialization adapter is the type is within an `Option` or a `Vec`.
+
+ Thanks to `@markazmierczak` for the design of the trait without whom this wouldn't be possible.
+
+ More details about this new scheme can be found in the also new [user guide](https://docs.rs/serde_with/1.5.0-alpha.1/serde_with/guide/index.html)
+* This release also features a detailed user guide.
+ The guide focusses more on how to use this crate by providing examples.
+ For example, it includes a section about the available feature flags of this crate and how you can migrate to the shiny new `serde_as` scheme.
+* The crate now features de/serialization adaptors for the std and chrono's `Duration` types. #56 #104
+
+### Changed
+
+* Convert the code to use 2018 edition.
+* @peterjoel improved the performance of `with_prefix!`. #101
+
+### Fixed
+
+* The `with_prefix!` macro, to add a string prefixes during serialization, now also works with unit variant enum types. #115 #116
+
+## [1.4.0] - 2020-01-16
+
+### Added
+
+* Add a helper to deserialize a `Vec<u8>` from `String` (#35)
+* Add `default_on_error` helper, which turns errors into `Default`s of the type
+* Add `default_on_null` helper, which turns `null` values into `Default`s of the type
+
+### Changed
+
+* Bump minimal Rust version to 1.36.0
+ * Supports Rust Edition 2018
+ * version-sync depends on smallvec which requires 1.36
+* Improved CI pipeline by running `cargo audit` and `tarpaulin` in all configurations now.
+
+## [1.3.1] - 2019-04-09
+
+### Fixed
+
+* Use `serde_with_macros` with proper dependencies specified.
+
+## [1.3.0] - 2019-04-02
+
+### Added
+
+* Add `skip_serializing_none` attribute, which adds `#[serde(skip_serializing_if = "Option::is_none")]` for each Option in a struct.
+ This is helpful for APIs which have many optional fields.
+ The effect of can be negated by adding `serialize_always` on those fields, which should always be serialized.
+ Existing `skip_serializing_if` will never be modified and those fields keep their behavior.
+
+## [1.2.0] - 2019-03-04
+
+### Added
+
+* Add macro helper to support deserializing values with nested or flattened syntax #38
+* Serialize tuple list as map helper
+
+### Changed
+
+* Bumped minimal Rust version to 1.30.0
+
+## [1.1.0] - 2019-02-18
+
+### Added
+
+* Serialize HashMap/BTreeMap as list of tuples
+
+## [1.0.0] - 2019-01-17
+
+### Added
+
+* No changes in this release.
+* Bumped version number to indicate the stability of the library.
+
+## [0.2.5] - 2018-11-29
+
+### Added
+
+* Helper which deserializes an empty string as `None` and otherwise uses `FromStr` and `AsRef<str>`.
+
+## [0.2.4] - 2018-11-24
+
+### Added
+
+* De/Serialize sequences by using `Display` and `FromStr` implementations on each element. Contributed by @katyo
+
+## [0.2.3] - 2018-11-08
+
+### Added
+
+* Add missing docs and enable deny missing_docs
+* Add badges to Cargo.toml and crates.io
+
+### Changed
+
+* Improve Travis configuration
+* Various clippy improvements
+
+## [0.2.2] - 2018-08-05
+
+### Added
+
+* `unwrap_or_skip` allows to transparently serialize the inner part of a `Some(T)`
+* Add deserialization helper for sets and maps, inspired by [comment](https://github.com/serde-rs/serde/issues/553#issuecomment-299711855)
+ * Create an error if duplicate values for a set are detected
+ * Create an error if duplicate keys for a map are detected
+ * Implement a first-value wins strategy for sets/maps. This is different to serde's default
+ which implements a last value wins strategy.
+
+## [0.2.1] - 2018-06-05
+
+### Added
+
+* Double Option pattern to differentiate between missing, unset, or existing value
+* `with_prefix!` macro, which puts a prefix on every struct field
+
+## [0.2.0] - 2018-05-31
+
+### Added
+
+* Add chrono support: Deserialize timestamps from int, float, and string
+* Serialization of embedded JSON strings
+* De/Serialization using `Display` and `FromStr` implementations
+* String-based collections using `Display` and `FromStr`, allows deserializing "#foo,#bar"
+
+## [0.1.0] - 2017-08-17
+
+### Added
+
+* Reserve name on crates.io
diff --git a/third_party/rust/serde_with/Cargo.toml b/third_party/rust/serde_with/Cargo.toml
new file mode 100644
index 0000000000..eeca00edef
--- /dev/null
+++ b/third_party/rust/serde_with/Cargo.toml
@@ -0,0 +1,214 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.53"
+name = "serde_with"
+version = "1.14.0"
+authors = [
+ "Jonas Bushart",
+ "Marcin Kaźmierczak",
+]
+include = [
+ "src/**/*",
+ "tests/**/*",
+ "LICENSE-*",
+ "README.md",
+ "CHANGELOG.md",
+]
+description = "Custom de/serialization functions for Rust's serde"
+documentation = "https://docs.rs/serde_with/"
+readme = "README.md"
+keywords = [
+ "serde",
+ "utilities",
+ "serialization",
+ "deserialization",
+]
+categories = ["encoding"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/jonasbb/serde_with"
+resolver = "2"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+ "--cfg=docsrs",
+ "-Zunstable-options",
+ "--generate-link-to-definition",
+]
+
+[[test]]
+name = "base64"
+path = "tests/base64.rs"
+required-features = [
+ "base64",
+ "macros",
+]
+
+[[test]]
+name = "chrono"
+path = "tests/chrono.rs"
+required-features = [
+ "chrono",
+ "macros",
+]
+
+[[test]]
+name = "hex"
+path = "tests/hex.rs"
+required-features = [
+ "hex",
+ "macros",
+]
+
+[[test]]
+name = "indexmap"
+path = "tests/indexmap.rs"
+required-features = [
+ "indexmap",
+ "macros",
+]
+
+[[test]]
+name = "json"
+path = "tests/json.rs"
+required-features = [
+ "json",
+ "macros",
+]
+
+[[test]]
+name = "serde_as"
+path = "tests/serde_as/lib.rs"
+required-features = ["macros"]
+
+[[test]]
+name = "time_0_3"
+path = "tests/time_0_3.rs"
+required-features = [
+ "macros",
+ "time_0_3",
+]
+
+[[test]]
+name = "derives"
+path = "tests/derives/lib.rs"
+required-features = ["macros"]
+
+[dependencies.base64_crate]
+version = "0.13.0"
+optional = true
+package = "base64"
+
+[dependencies.chrono_crate]
+version = "0.4.1"
+features = [
+ "clock",
+ "serde",
+ "std",
+]
+optional = true
+default-features = false
+package = "chrono"
+
+[dependencies.doc-comment]
+version = "0.3.3"
+optional = true
+
+[dependencies.hex]
+version = "0.4.2"
+optional = true
+
+[dependencies.indexmap_crate]
+version = "1.8"
+features = ["serde-1"]
+optional = true
+package = "indexmap"
+
+[dependencies.serde]
+version = "1.0.122"
+features = ["derive"]
+
+[dependencies.serde_json]
+version = "1.0.1"
+optional = true
+
+[dependencies.serde_with_macros]
+version = "1.5.2"
+optional = true
+
+[dependencies.time_0_3]
+version = "~0.3"
+features = ["serde-well-known"]
+optional = true
+package = "time"
+
+[dev-dependencies.expect-test]
+version = "1.0.0"
+
+[dev-dependencies.fnv]
+version = "1.0.6"
+
+[dev-dependencies.glob]
+version = "0.3.0"
+
+[dev-dependencies.mime]
+version = "0.3.16"
+
+[dev-dependencies.pretty_assertions]
+version = "1.0.0"
+
+[dev-dependencies.regex]
+version = "1.3.9"
+features = ["std"]
+default-features = false
+
+[dev-dependencies.rmp-serde]
+version = "1.1.0"
+
+[dev-dependencies.ron]
+version = "0.7"
+
+[dev-dependencies.rustversion]
+version = "1.0.0"
+
+[dev-dependencies.serde-xml-rs]
+version = "0.5.0"
+
+[dev-dependencies.serde_json]
+version = "1.0.25"
+features = ["preserve_order"]
+
+[dev-dependencies.serde_test]
+version = "1.0.124"
+
+[dev-dependencies.serde_yaml]
+version = "0.8.21"
+
+[dev-dependencies.version-sync]
+version = "0.9.1"
+
+[features]
+base64 = ["base64_crate"]
+chrono = ["chrono_crate"]
+default = ["macros"]
+guide = [
+ "doc-comment",
+ "macros",
+]
+indexmap = ["indexmap_crate"]
+json = ["serde_json"]
+macros = ["serde_with_macros"]
+
+[badges.maintenance]
+status = "actively-developed"
diff --git a/third_party/rust/serde_with/LICENSE-APACHE b/third_party/rust/serde_with/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/third_party/rust/serde_with/LICENSE-APACHE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/third_party/rust/serde_with/LICENSE-MIT b/third_party/rust/serde_with/LICENSE-MIT
new file mode 100644
index 0000000000..9203baa055
--- /dev/null
+++ b/third_party/rust/serde_with/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/third_party/rust/serde_with/README.md b/third_party/rust/serde_with/README.md
new file mode 100644
index 0000000000..a765d3578d
--- /dev/null
+++ b/third_party/rust/serde_with/README.md
@@ -0,0 +1,188 @@
+# Custom de/serialization functions for Rust's [serde](https://serde.rs)
+
+[![crates.io badge](https://img.shields.io/crates/v/serde_with.svg)](https://crates.io/crates/serde_with/)
+[![Build Status](https://github.com/jonasbb/serde_with/workflows/Rust%20CI/badge.svg)](https://github.com/jonasbb/serde_with)
+[![codecov](https://codecov.io/gh/jonasbb/serde_with/branch/master/graph/badge.svg)](https://codecov.io/gh/jonasbb/serde_with)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4322/badge)](https://bestpractices.coreinfrastructure.org/projects/4322)
+[![Binder](https://img.shields.io/badge/Try%20on%20-binder-579ACA.svg?logo=data:image/png;base64,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)](https://mybinder.org/v2/gist/jonasbb/18b9aece4c17f617b1c2b3946d29eeb0/HEAD?filepath=serde-with-demo.ipynb)
+
+---
+
+This crate provides custom de/serialization helpers to use in combination with [serde's with-annotation][with-annotation] and with the improved [`serde_as`][as-annotation]-annotation.
+Some common use cases are:
+
+* De/Serializing a type using the `Display` and `FromStr` traits, e.g., for `u8`, `url::Url`, or `mime::Mime`.
+ Check [`DisplayFromStr`][] or [`serde_with::rust::display_fromstr`][display_fromstr] for details.
+* Support for arrays larger than 32 elements or using const generics.
+ With `serde_as` large arrays are supported, even if they are nested in other types.
+ `[bool; 64]`, `Option<[u8; M]>`, and `Box<[[u8; 64]; N]>` are all supported, as [this examples shows](#large-and-const-generic-arrays).
+* Skip serializing all empty `Option` types with [`#[skip_serializing_none]`][skip_serializing_none].
+* Apply a prefix to each field name of a struct, without changing the de/serialize implementations of the struct using [`with_prefix!`][].
+* Deserialize a comma separated list like `#hash,#tags,#are,#great` into a `Vec<String>`.
+ Check the documentation for [`serde_with::rust::StringWithSeparator::<CommaSeparator>`][StringWithSeparator].
+
+### Getting Help
+
+**Check out the [user guide][user guide] to find out more tips and tricks about this crate.**
+
+For further help using this crate you can [open a new discussion](https://github.com/jonasbb/serde_with/discussions/new) or ask on [users.rust-lang.org](https://users.rust-lang.org/).
+For bugs, please open a [new issue](https://github.com/jonasbb/serde_with/issues/new) on GitHub.
+
+## Use `serde_with` in your Project
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies.serde_with]
+version = "1.14.0"
+features = [ "..." ]
+```
+
+The crate contains different features for integration with other common crates.
+Check the [feature flags][] section for information about all available features.
+
+## Examples
+
+Annotate your struct or enum to enable the custom de/serializer.
+The `#[serde_as]` attribute must be place *before* the `#[derive]`.
+
+### `DisplayFromStr`
+
+```rust
+#[serde_as]
+#[derive(Deserialize, Serialize)]
+struct Foo {
+ // Serialize with Display, deserialize with FromStr
+ #[serde_as(as = "DisplayFromStr")]
+ bar: u8,
+}
+
+// This will serialize
+Foo {bar: 12}
+
+// into this JSON
+{"bar": "12"}
+```
+
+### Large and const-generic arrays
+
+serde does not support arrays with more than 32 elements or using const-generics.
+The `serde_as` attribute allows to circumvent this restriction, even for nested types and nested arrays.
+
+```rust
+#[serde_as]
+#[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]>,
+}
+
+// This allows us to serialize a struct like this
+let arrays: Arrays<100, 128> = Arrays {
+ constgeneric: [true; 100],
+ nested: Box::new([[111; 64]; 100]),
+ optional: Some([222; 128])
+};
+assert!(serde_json::to_string(&arrays).is_ok());
+```
+
+### `skip_serializing_none`
+
+This situation often occurs with JSON, but other formats also support optional fields.
+If many fields are optional, putting the annotations on the structs can become tedious.
+The `#[skip_serializing_none]` attribute must be place *before* the `#[derive]`.
+
+```rust
+#[skip_serializing_none]
+#[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>,
+}
+
+// This will serialize
+Foo {a: None, b: None, c: None, d: Some(4), e: None, f: None, g: Some(7)}
+
+// into this JSON
+{"d": 4, "g": 7}
+```
+
+### 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
+#[serde_as]
+#[derive(Deserialize, Serialize)]
+struct Foo {
+ // Serialize them into a list of number as seconds
+ #[serde_as(as = "Vec<DurationSeconds>")]
+ durations: Vec<Duration>,
+ // We can treat a Vec like a map with duplicates.
+ // JSON only allows string keys, so convert i32 to strings
+ // The bytes will be hex encoded
+ #[serde_as(as = "BTreeMap<DisplayFromStr, Hex>")]
+ bytes: Vec<(i32, Vec<u8>)>,
+}
+
+// This will serialize
+Foo {
+ durations: vec![Duration::new(5, 0), Duration::new(3600, 0), Duration::new(0, 0)],
+ bytes: vec![
+ (1, vec![0, 1, 2]),
+ (-100, vec![100, 200, 255]),
+ (1, vec![0, 111, 222]),
+ ],
+}
+
+// into this JSON
+{
+ "durations": [5, 3600, 0],
+ "bytes": {
+ "1": "000102",
+ "-100": "64c8ff",
+ "1": "006fde"
+ }
+}
+```
+
+[`DisplayFromStr`]: https://docs.rs/serde_with/1.14.0/serde_with/struct.DisplayFromStr.html
+[`with_prefix!`]: https://docs.rs/serde_with/1.14.0/serde_with/macro.with_prefix.html
+[display_fromstr]: https://docs.rs/serde_with/1.14.0/serde_with/rust/display_fromstr/index.html
+[feature flags]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html
+[skip_serializing_none]: https://docs.rs/serde_with/1.14.0/serde_with/attr.skip_serializing_none.html
+[StringWithSeparator]: https://docs.rs/serde_with/1.14.0/serde_with/rust/struct.StringWithSeparator.html
+[user guide]: https://docs.rs/serde_with/1.14.0/serde_with/guide/index.html
+[with-annotation]: https://serde.rs/field-attrs.html#with
+[as-annotation]: https://docs.rs/serde_with/1.14.0/serde_with/guide/serde_as/index.html
+
+## License
+
+Licensed under either of
+
+* Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+## Contribution
+
+For detailed contribution instructions please read [`CONTRIBUTING.md`].
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+
+[`CONTRIBUTING.md`]: https://github.com/jonasbb/serde_with/blob/master/CONTRIBUTING.md
diff --git a/third_party/rust/serde_with/src/base64.rs b/third_party/rust/serde_with/src/base64.rs
new file mode 100644
index 0000000000..e1c6490f44
--- /dev/null
+++ b/third_party/rust/serde_with/src/base64.rs
@@ -0,0 +1,205 @@
+//! De/Serialization of base64 encoded bytes
+//!
+//! This modules is only available when using the `base64` feature of the crate.
+//!
+//! Please check the documentation on the [`Base64`] type for details.
+
+use crate::{formats, DeserializeAs, SerializeAs};
+use alloc::{format, string::String, vec::Vec};
+use core::{
+ convert::{TryFrom, TryInto},
+ default::Default,
+ marker::PhantomData,
+};
+use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
+
+/// Serialize bytes with base64
+///
+/// The type serializes a sequence of bytes as a base64 string.
+/// It works on any type implementing `AsRef<[u8]>` for serialization and `TryFrom<Vec<u8>>` for deserialization.
+///
+/// The type allows customizing the character set and the padding behavior.
+/// The `CHARSET` is a type implementing [`CharacterSet`].
+/// `PADDING` specifies if serializing should emit padding.
+/// Deserialization always supports padded and unpadded formats.
+/// [`formats::Padded`] emits padding and [`formats::Unpadded`] leaves it off.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::serde_as;
+/// use serde_with::base64::{Base64, Bcrypt, BinHex, Standard};
+/// use serde_with::formats::{Padded, Unpadded};
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq, Eq)]
+/// #[derive(Serialize, Deserialize)]
+/// struct B64 {
+/// // The default is the same as Standard character set with padding
+/// #[serde_as(as = "Base64")]
+/// default: Vec<u8>,
+/// // Only change the character set, implies padding
+/// #[serde_as(as = "Base64<BinHex>")]
+/// charset_binhex: Vec<u8>,
+///
+/// #[serde_as(as = "Base64<Standard, Padded>")]
+/// explicit_padding: Vec<u8>,
+/// #[serde_as(as = "Base64<Bcrypt, Unpadded>")]
+/// no_padding: Vec<u8>,
+/// }
+///
+/// let b64 = B64 {
+/// default: b"Hello World".to_vec(),
+/// charset_binhex: b"Hello World".to_vec(),
+/// explicit_padding: b"Hello World".to_vec(),
+/// no_padding: b"Hello World".to_vec(),
+/// };
+/// let json = serde_json::json!({
+/// "default": "SGVsbG8gV29ybGQ=",
+/// "charset_binhex": "5'8VD'mI8epaD'3=",
+/// "explicit_padding": "SGVsbG8gV29ybGQ=",
+/// "no_padding": "QETqZE6eT07wZEO",
+/// });
+///
+/// // Test serialization and deserialization
+/// assert_eq!(json, serde_json::to_value(&b64).unwrap());
+/// assert_eq!(b64, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+
+// The padding might be better as `const PADDING: bool = true`
+// https://blog.rust-lang.org/inside-rust/2021/09/06/Splitting-const-generics.html#featureconst_generics_default/
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Base64<CHARSET: CharacterSet = Standard, PADDING: formats::Format = formats::Padded>(
+ PhantomData<(CHARSET, PADDING)>,
+);
+
+impl<T, CHARSET> SerializeAs<T> for Base64<CHARSET, formats::Padded>
+where
+ T: AsRef<[u8]>,
+ CHARSET: CharacterSet,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ base64_crate::encode_config(source, base64_crate::Config::new(CHARSET::charset(), true))
+ .serialize(serializer)
+ }
+}
+
+impl<T, CHARSET> SerializeAs<T> for Base64<CHARSET, formats::Unpadded>
+where
+ T: AsRef<[u8]>,
+ CHARSET: CharacterSet,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ base64_crate::encode_config(source, base64_crate::Config::new(CHARSET::charset(), false))
+ .serialize(serializer)
+ }
+}
+
+impl<'de, T, CHARSET, FORMAT> DeserializeAs<'de, T> for Base64<CHARSET, FORMAT>
+where
+ T: TryFrom<Vec<u8>>,
+ CHARSET: CharacterSet,
+ FORMAT: formats::Format,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ String::deserialize(deserializer)
+ .and_then(|s| {
+ base64_crate::decode_config(
+ &*s,
+ base64_crate::Config::new(CHARSET::charset(), false),
+ )
+ .map_err(Error::custom)
+ })
+ .and_then(|vec: Vec<u8>| {
+ let length = vec.len();
+ vec.try_into().map_err(|_e: T::Error| {
+ Error::custom(format!(
+ "Can't convert a Byte Vector of length {} to the output type.",
+ length
+ ))
+ })
+ })
+ }
+}
+
+/// A base64 character set from [this list](base64_crate::CharacterSet).
+pub trait CharacterSet {
+ /// Return a specific character set.
+ ///
+ /// Return one enum variant of the [`base64::CharacterSet`](base64_crate::CharacterSet) enum.
+ fn charset() -> base64_crate::CharacterSet;
+}
+
+/// The standard character set (uses `+` and `/`).
+///
+/// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3).
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Standard;
+impl CharacterSet for Standard {
+ fn charset() -> base64_crate::CharacterSet {
+ base64_crate::CharacterSet::Standard
+ }
+}
+
+/// The URL safe character set (uses `-` and `_`).
+///
+/// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3).
+#[derive(Copy, Clone, Debug, Default)]
+pub struct UrlSafe;
+impl CharacterSet for UrlSafe {
+ fn charset() -> base64_crate::CharacterSet {
+ base64_crate::CharacterSet::UrlSafe
+ }
+}
+
+/// The `crypt(3)` character set (uses `./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`).
+///
+/// Not standardized, but folk wisdom on the net asserts that this alphabet is what crypt uses.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Crypt;
+impl CharacterSet for Crypt {
+ fn charset() -> base64_crate::CharacterSet {
+ base64_crate::CharacterSet::Crypt
+ }
+}
+
+/// The bcrypt character set (uses `./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`).
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Bcrypt;
+impl CharacterSet for Bcrypt {
+ fn charset() -> base64_crate::CharacterSet {
+ base64_crate::CharacterSet::Bcrypt
+ }
+}
+
+/// The character set used in IMAP-modified UTF-7 (uses `+` and `,`).
+///
+/// See [RFC 3501](https://tools.ietf.org/html/rfc3501#section-5.1.3).
+#[derive(Copy, Clone, Debug, Default)]
+pub struct ImapMutf7;
+impl CharacterSet for ImapMutf7 {
+ fn charset() -> base64_crate::CharacterSet {
+ base64_crate::CharacterSet::ImapMutf7
+ }
+}
+
+/// The character set used in BinHex 4.0 files.
+///
+/// See [BinHex 4.0 Definition](http://files.stairways.com/other/binhex-40-specs-info.txt).
+#[derive(Copy, Clone, Debug, Default)]
+pub struct BinHex;
+impl CharacterSet for BinHex {
+ fn charset() -> base64_crate::CharacterSet {
+ base64_crate::CharacterSet::BinHex
+ }
+}
diff --git a/third_party/rust/serde_with/src/chrono.rs b/third_party/rust/serde_with/src/chrono.rs
new file mode 100644
index 0000000000..d39725464f
--- /dev/null
+++ b/third_party/rust/serde_with/src/chrono.rs
@@ -0,0 +1,516 @@
+//! De/Serialization of [chrono][] types
+//!
+//! This modules is only available if using the `chrono` feature of the crate.
+//!
+//! [chrono]: https://docs.rs/chrono/
+
+use crate::{
+ de::DeserializeAs,
+ formats::{Flexible, Format, Strict, Strictness},
+ ser::SerializeAs,
+ utils::duration::{DurationSigned, Sign},
+ DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds,
+ DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac,
+ DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds, TimestampMicroSecondsWithFrac,
+ TimestampMilliSeconds, TimestampMilliSecondsWithFrac, TimestampNanoSeconds,
+ TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac,
+};
+use alloc::{format, string::String, vec::Vec};
+use chrono_crate::{DateTime, Duration, Local, NaiveDateTime, TimeZone, Utc};
+use core::fmt;
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+/// Create a [`DateTime`] for the Unix Epoch using the [`Utc`] timezone
+fn unix_epoch_utc() -> DateTime<Utc> {
+ DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc)
+}
+
+/// Create a [`DateTime`] for the Unix Epoch using the [`Local`] timezone
+fn unix_epoch_local() -> DateTime<Local> {
+ DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc).with_timezone(&Local)
+}
+
+/// Create a [`NaiveDateTime`] for the Unix Epoch
+fn unix_epoch_naive() -> NaiveDateTime {
+ NaiveDateTime::from_timestamp(0, 0)
+}
+
+/// Deserialize a Unix timestamp with optional subsecond precision into a `DateTime<Utc>`.
+///
+/// The `DateTime<Utc>` can be serialized from an integer, a float, or a string representing a number.
+///
+/// # Examples
+///
+/// ```
+/// # use chrono_crate::{DateTime, Utc};
+/// # use serde::Deserialize;
+/// #
+/// #[derive(Debug, Deserialize)]
+/// struct S {
+/// #[serde(with = "serde_with::chrono::datetime_utc_ts_seconds_from_any")]
+/// date: DateTime<Utc>,
+/// }
+///
+/// // Deserializes integers
+/// assert!(serde_json::from_str::<S>(r#"{ "date": 1478563200 }"#).is_ok());
+/// // floats
+/// assert!(serde_json::from_str::<S>(r#"{ "date": 1478563200.123 }"#).is_ok());
+/// // and strings with numbers, for high-precision values
+/// assert!(serde_json::from_str::<S>(r#"{ "date": "1478563200.123" }"#).is_ok());
+/// ```
+pub mod datetime_utc_ts_seconds_from_any {
+ use super::*;
+ use chrono_crate::{DateTime, NaiveDateTime, Utc};
+ use serde::de::{Deserializer, Error, Unexpected, Visitor};
+
+ /// Deserialize a Unix timestamp with optional subsecond precision into a `DateTime<Utc>`.
+ pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct Helper;
+ impl<'de> Visitor<'de> for Helper {
+ type Value = DateTime<Utc>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter
+ .write_str("an integer, float, or string with optional subsecond precision.")
+ }
+
+ fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let ndt = NaiveDateTime::from_timestamp_opt(value, 0);
+ if let Some(ndt) = ndt {
+ Ok(DateTime::<Utc>::from_utc(ndt, Utc))
+ } else {
+ Err(Error::custom(format!(
+ "a timestamp which can be represented in a DateTime but received '{}'",
+ value
+ )))
+ }
+ }
+
+ fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let ndt = NaiveDateTime::from_timestamp_opt(value as i64, 0);
+ if let Some(ndt) = ndt {
+ Ok(DateTime::<Utc>::from_utc(ndt, Utc))
+ } else {
+ Err(Error::custom(format!(
+ "a timestamp which can be represented in a DateTime but received '{}'",
+ value
+ )))
+ }
+ }
+
+ fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let seconds = value.trunc() as i64;
+ let nsecs = (value.fract() * 1_000_000_000_f64).abs() as u32;
+ let ndt = NaiveDateTime::from_timestamp_opt(seconds, nsecs);
+ if let Some(ndt) = ndt {
+ Ok(DateTime::<Utc>::from_utc(ndt, Utc))
+ } else {
+ Err(Error::custom(format!(
+ "a timestamp which can be represented in a DateTime but received '{}'",
+ value
+ )))
+ }
+ }
+
+ fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let parts: Vec<_> = value.split('.').collect();
+
+ match *parts.as_slice() {
+ [seconds] => {
+ if let Ok(seconds) = seconds.parse() {
+ let ndt = NaiveDateTime::from_timestamp_opt(seconds, 0);
+ if let Some(ndt) = ndt {
+ Ok(DateTime::<Utc>::from_utc(ndt, Utc))
+ } else {
+ Err(Error::custom(format!(
+ "a timestamp which can be represented in a DateTime but received '{}'",
+ value
+ )))
+ }
+ } else {
+ Err(Error::invalid_value(Unexpected::Str(value), &self))
+ }
+ }
+ [seconds, subseconds] => {
+ if let Ok(seconds) = seconds.parse() {
+ let subseclen = subseconds.chars().count() as u32;
+ if subseclen > 9 {
+ return Err(Error::custom(format!(
+ "DateTimes only support nanosecond precision but '{}' has more than 9 digits.",
+ value
+ )));
+ }
+
+ if let Ok(mut subseconds) = subseconds.parse() {
+ // convert subseconds to nanoseconds (10^-9), require 9 places for nanoseconds
+ subseconds *= 10u32.pow(9 - subseclen);
+ let ndt = NaiveDateTime::from_timestamp_opt(seconds, subseconds);
+ if let Some(ndt) = ndt {
+ Ok(DateTime::<Utc>::from_utc(ndt, Utc))
+ } else {
+ Err(Error::custom(format!(
+ "a timestamp which can be represented in a DateTime but received '{}'",
+ value
+ )))
+ }
+ } else {
+ Err(Error::invalid_value(Unexpected::Str(value), &self))
+ }
+ } else {
+ Err(Error::invalid_value(Unexpected::Str(value), &self))
+ }
+ }
+
+ _ => Err(Error::invalid_value(Unexpected::Str(value), &self)),
+ }
+ }
+ }
+
+ deserializer.deserialize_any(Helper)
+ }
+}
+
+impl SerializeAs<NaiveDateTime> for DateTime<Utc> {
+ fn serialize_as<S>(source: &NaiveDateTime, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let datetime = DateTime::<Utc>::from_utc(*source, Utc);
+ datetime.serialize(serializer)
+ }
+}
+
+impl<'de> DeserializeAs<'de, NaiveDateTime> for DateTime<Utc> {
+ fn deserialize_as<D>(deserializer: D) -> Result<NaiveDateTime, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ DateTime::<Utc>::deserialize(deserializer).map(|datetime| datetime.naive_utc())
+ }
+}
+
+/// Convert a [`chrono::Duration`] into a [`DurationSigned`]
+fn duration_into_duration_signed(dur: &Duration) -> DurationSigned {
+ match dur.to_std() {
+ Ok(dur) => DurationSigned::with_duration(Sign::Positive, dur),
+ Err(_) => {
+ if let Ok(dur) = (-*dur).to_std() {
+ DurationSigned::with_duration(Sign::Negative, dur)
+ } else {
+ panic!("A chrono Duration should be convertible to a DurationSigned")
+ }
+ }
+ }
+}
+
+/// Convert a [`DurationSigned`] into a [`chrono::Duration`]
+fn duration_from_duration_signed<'de, D>(dur: DurationSigned) -> Result<Duration, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let mut chrono_dur = match Duration::from_std(dur.duration) {
+ Ok(dur) => dur,
+ Err(msg) => {
+ return Err(de::Error::custom(format!(
+ "Duration is outside of the representable range: {}",
+ msg
+ )))
+ }
+ };
+ if dur.sign.is_negative() {
+ chrono_dur = -chrono_dur;
+ }
+ Ok(chrono_dur)
+}
+
+macro_rules! use_duration_signed_ser {
+ (
+ $main_trait:ident $internal_trait:ident =>
+ {
+ $ty:ty; $converter:ident =>
+ $({
+ $format:ty, $strictness:ty =>
+ $($tbound:ident: $bound:ident $(,)?)*
+ })*
+ }
+ ) => {
+ $(
+ impl<$($tbound ,)*> SerializeAs<$ty> for $main_trait<$format, $strictness>
+ where
+ $($tbound: $bound,)*
+ {
+ fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let dur: DurationSigned = $converter(source);
+ $internal_trait::<$format, $strictness>::serialize_as(
+ &dur,
+ serializer,
+ )
+ }
+ }
+ )*
+ };
+ (
+ $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
+ ) => {
+ $( use_duration_signed_ser!($main_trait $internal_trait => $rest); )+
+ };
+}
+
+fn datetime_to_duration<TZ>(source: &DateTime<TZ>) -> DurationSigned
+where
+ TZ: TimeZone,
+{
+ duration_into_duration_signed(&source.clone().signed_duration_since(unix_epoch_utc()))
+}
+
+fn naive_datetime_to_duration(source: &NaiveDateTime) -> DurationSigned {
+ duration_into_duration_signed(&source.signed_duration_since(unix_epoch_naive()))
+}
+
+use_duration_signed_ser!(
+ DurationSeconds DurationSeconds,
+ DurationMilliSeconds DurationMilliSeconds,
+ DurationMicroSeconds DurationMicroSeconds,
+ DurationNanoSeconds DurationNanoSeconds,
+ => {
+ Duration; duration_into_duration_signed =>
+ {i64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ DateTime<TZ>; datetime_to_duration =>
+ {i64, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness}
+ {f64, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness}
+ {String, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ NaiveDateTime; naive_datetime_to_duration =>
+ {i64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+
+// Duration/Timestamp WITH FRACTIONS
+use_duration_signed_ser!(
+ DurationSecondsWithFrac DurationSecondsWithFrac,
+ DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ Duration; duration_into_duration_signed =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ DateTime<TZ>; datetime_to_duration =>
+ {f64, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness}
+ {String, STRICTNESS => TZ: TimeZone, STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ NaiveDateTime; naive_datetime_to_duration =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+
+macro_rules! use_duration_signed_de {
+ (
+ $main_trait:ident $internal_trait:ident =>
+ {
+ $ty:ty; $converter:ident =>
+ $({
+ $format:ty, $strictness:ty =>
+ $($tbound:ident: $bound:ident)*
+ })*
+ }
+ ) =>{
+ $(
+ impl<'de, $($tbound,)*> DeserializeAs<'de, $ty> for $main_trait<$format, $strictness>
+ where
+ $($tbound: $bound,)*
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$ty, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let dur: DurationSigned = $internal_trait::<$format, $strictness>::deserialize_as(deserializer)?;
+ $converter::<D>(dur)
+ }
+ }
+ )*
+ };
+ (
+ $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
+ ) => {
+ $( use_duration_signed_de!($main_trait $internal_trait => $rest); )+
+ };
+}
+
+fn duration_to_datetime_utc<'de, D>(dur: DurationSigned) -> Result<DateTime<Utc>, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ Ok(unix_epoch_utc() + duration_from_duration_signed::<D>(dur)?)
+}
+
+fn duration_to_datetime_local<'de, D>(dur: DurationSigned) -> Result<DateTime<Local>, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ Ok(unix_epoch_local() + duration_from_duration_signed::<D>(dur)?)
+}
+
+fn duration_to_naive_datetime<'de, D>(dur: DurationSigned) -> Result<NaiveDateTime, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ Ok(unix_epoch_naive() + duration_from_duration_signed::<D>(dur)?)
+}
+
+// No subsecond precision
+use_duration_signed_de!(
+ DurationSeconds DurationSeconds,
+ DurationMilliSeconds DurationMilliSeconds,
+ DurationMicroSeconds DurationMicroSeconds,
+ DurationNanoSeconds DurationNanoSeconds,
+ => {
+ Duration; duration_from_duration_signed =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ DateTime<Utc>; duration_to_datetime_utc =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ DateTime<Local>; duration_to_datetime_local =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ NaiveDateTime; duration_to_naive_datetime =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+
+// Duration/Timestamp WITH FRACTIONS
+use_duration_signed_de!(
+ DurationSecondsWithFrac DurationSecondsWithFrac,
+ DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ Duration; duration_from_duration_signed =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ DateTime<Utc>; duration_to_datetime_utc =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ DateTime<Local>; duration_to_datetime_local =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ NaiveDateTime; duration_to_naive_datetime =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
diff --git a/third_party/rust/serde_with/src/content/mod.rs b/third_party/rust/serde_with/src/content/mod.rs
new file mode 100644
index 0000000000..711af475c8
--- /dev/null
+++ b/third_party/rust/serde_with/src/content/mod.rs
@@ -0,0 +1,5 @@
+//! Import of the unstable private `Content` type from `serde`.
+//!
+//! <https://github.com/serde-rs/serde/blob/55a7cedd737278a9d75a2efd038c6f38b8c38bd6/serde/src/private/ser.rs#L338-L997>
+
+pub(crate) mod ser;
diff --git a/third_party/rust/serde_with/src/content/ser.rs b/third_party/rust/serde_with/src/content/ser.rs
new file mode 100644
index 0000000000..be02595af9
--- /dev/null
+++ b/third_party/rust/serde_with/src/content/ser.rs
@@ -0,0 +1,623 @@
+//! Buffer for serializing data.
+//!
+//! This is a copy and improvement of the `serde` private type:
+//! <https://github.com/serde-rs/serde/blob/55a7cedd737278a9d75a2efd038c6f38b8c38bd6/serde/src/private/ser.rs#L338-L997>
+//! The code is very stable in the `serde` crate, so no maintainability problem is expected.
+//!
+//! Since the type is private we copy the type here.
+//! `serde` is licensed as MIT+Apache2, the same as this crate.
+//!
+//! This version carries improvements compared to `serde`'s version.
+//! The types support 128-bit integers, which is supported for all targets in Rust 1.40+.
+//! The [`ContentSerializer`] can also be configured to human readable or compact representation.
+
+use alloc::{borrow::ToOwned, boxed::Box, string::String, vec::Vec};
+use core::marker::PhantomData;
+use serde::ser::{self, Serialize, Serializer};
+
+#[derive(Debug)]
+pub(crate) enum Content {
+ Bool(bool),
+
+ U8(u8),
+ U16(u16),
+ U32(u32),
+ U64(u64),
+ U128(u128),
+
+ I8(i8),
+ I16(i16),
+ I32(i32),
+ I64(i64),
+ I128(i128),
+
+ F32(f32),
+ F64(f64),
+
+ Char(char),
+ String(String),
+ Bytes(Vec<u8>),
+
+ None,
+ Some(Box<Content>),
+
+ Unit,
+ UnitStruct(&'static str),
+ UnitVariant(&'static str, u32, &'static str),
+ NewtypeStruct(&'static str, Box<Content>),
+ NewtypeVariant(&'static str, u32, &'static str, Box<Content>),
+
+ Seq(Vec<Content>),
+ Tuple(Vec<Content>),
+ TupleStruct(&'static str, Vec<Content>),
+ TupleVariant(&'static str, u32, &'static str, Vec<Content>),
+ Map(Vec<(Content, Content)>),
+ Struct(&'static str, Vec<(&'static str, Content)>),
+ StructVariant(
+ &'static str,
+ u32,
+ &'static str,
+ Vec<(&'static str, Content)>,
+ ),
+}
+
+impl Serialize for Content {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match *self {
+ Content::Bool(b) => serializer.serialize_bool(b),
+ Content::U8(u) => serializer.serialize_u8(u),
+ Content::U16(u) => serializer.serialize_u16(u),
+ Content::U32(u) => serializer.serialize_u32(u),
+ Content::U64(u) => serializer.serialize_u64(u),
+ Content::U128(u) => serializer.serialize_u128(u),
+ Content::I8(i) => serializer.serialize_i8(i),
+ Content::I16(i) => serializer.serialize_i16(i),
+ Content::I32(i) => serializer.serialize_i32(i),
+ Content::I64(i) => serializer.serialize_i64(i),
+ Content::I128(i) => serializer.serialize_i128(i),
+ Content::F32(f) => serializer.serialize_f32(f),
+ Content::F64(f) => serializer.serialize_f64(f),
+ Content::Char(c) => serializer.serialize_char(c),
+ Content::String(ref s) => serializer.serialize_str(s),
+ Content::Bytes(ref b) => serializer.serialize_bytes(b),
+ Content::None => serializer.serialize_none(),
+ Content::Some(ref c) => serializer.serialize_some(&**c),
+ Content::Unit => serializer.serialize_unit(),
+ Content::UnitStruct(n) => serializer.serialize_unit_struct(n),
+ Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v),
+ Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c),
+ Content::NewtypeVariant(n, i, v, ref c) => {
+ serializer.serialize_newtype_variant(n, i, v, &**c)
+ }
+ Content::Seq(ref elements) => elements.serialize(serializer),
+ Content::Tuple(ref elements) => {
+ use serde::ser::SerializeTuple;
+ let mut tuple = serializer.serialize_tuple(elements.len())?;
+ for e in elements {
+ tuple.serialize_element(e)?;
+ }
+ tuple.end()
+ }
+ Content::TupleStruct(n, ref fields) => {
+ use serde::ser::SerializeTupleStruct;
+ let mut ts = serializer.serialize_tuple_struct(n, fields.len())?;
+ for f in fields {
+ ts.serialize_field(f)?;
+ }
+ ts.end()
+ }
+ Content::TupleVariant(n, i, v, ref fields) => {
+ use serde::ser::SerializeTupleVariant;
+ let mut tv = serializer.serialize_tuple_variant(n, i, v, fields.len())?;
+ for f in fields {
+ tv.serialize_field(f)?;
+ }
+ tv.end()
+ }
+ Content::Map(ref entries) => {
+ use serde::ser::SerializeMap;
+ let mut map = serializer.serialize_map(Some(entries.len()))?;
+ for &(ref k, ref v) in entries {
+ map.serialize_entry(k, v)?;
+ }
+ map.end()
+ }
+ Content::Struct(n, ref fields) => {
+ use serde::ser::SerializeStruct;
+ let mut s = serializer.serialize_struct(n, fields.len())?;
+ for &(k, ref v) in fields {
+ s.serialize_field(k, v)?;
+ }
+ s.end()
+ }
+ Content::StructVariant(n, i, v, ref fields) => {
+ use serde::ser::SerializeStructVariant;
+ let mut sv = serializer.serialize_struct_variant(n, i, v, fields.len())?;
+ for &(k, ref v) in fields {
+ sv.serialize_field(k, v)?;
+ }
+ sv.end()
+ }
+ }
+ }
+}
+
+pub(crate) struct ContentSerializer<E> {
+ is_human_readable: bool,
+ error: PhantomData<E>,
+}
+
+impl<E> ContentSerializer<E> {
+ pub(crate) fn new(is_human_readable: bool) -> Self {
+ ContentSerializer {
+ is_human_readable,
+ error: PhantomData,
+ }
+ }
+}
+
+impl<E> Default for ContentSerializer<E> {
+ fn default() -> Self {
+ Self::new(true)
+ }
+}
+
+impl<E> Serializer for ContentSerializer<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ type SerializeSeq = SerializeSeq<E>;
+ type SerializeTuple = SerializeTuple<E>;
+ type SerializeTupleStruct = SerializeTupleStruct<E>;
+ type SerializeTupleVariant = SerializeTupleVariant<E>;
+ type SerializeMap = SerializeMap<E>;
+ type SerializeStruct = SerializeStruct<E>;
+ type SerializeStructVariant = SerializeStructVariant<E>;
+
+ fn is_human_readable(&self) -> bool {
+ self.is_human_readable
+ }
+
+ fn serialize_bool(self, v: bool) -> Result<Content, E> {
+ Ok(Content::Bool(v))
+ }
+
+ fn serialize_i8(self, v: i8) -> Result<Content, E> {
+ Ok(Content::I8(v))
+ }
+
+ fn serialize_i16(self, v: i16) -> Result<Content, E> {
+ Ok(Content::I16(v))
+ }
+
+ fn serialize_i32(self, v: i32) -> Result<Content, E> {
+ Ok(Content::I32(v))
+ }
+
+ fn serialize_i64(self, v: i64) -> Result<Content, E> {
+ Ok(Content::I64(v))
+ }
+
+ fn serialize_i128(self, v: i128) -> Result<Content, E> {
+ Ok(Content::I128(v))
+ }
+
+ fn serialize_u8(self, v: u8) -> Result<Content, E> {
+ Ok(Content::U8(v))
+ }
+
+ fn serialize_u16(self, v: u16) -> Result<Content, E> {
+ Ok(Content::U16(v))
+ }
+
+ fn serialize_u32(self, v: u32) -> Result<Content, E> {
+ Ok(Content::U32(v))
+ }
+
+ fn serialize_u64(self, v: u64) -> Result<Content, E> {
+ Ok(Content::U64(v))
+ }
+
+ fn serialize_u128(self, v: u128) -> Result<Content, E> {
+ Ok(Content::U128(v))
+ }
+
+ fn serialize_f32(self, v: f32) -> Result<Content, E> {
+ Ok(Content::F32(v))
+ }
+
+ fn serialize_f64(self, v: f64) -> Result<Content, E> {
+ Ok(Content::F64(v))
+ }
+
+ fn serialize_char(self, v: char) -> Result<Content, E> {
+ Ok(Content::Char(v))
+ }
+
+ fn serialize_str(self, value: &str) -> Result<Content, E> {
+ Ok(Content::String(value.to_owned()))
+ }
+
+ fn serialize_bytes(self, value: &[u8]) -> Result<Content, E> {
+ Ok(Content::Bytes(value.to_owned()))
+ }
+
+ fn serialize_none(self) -> Result<Content, E> {
+ Ok(Content::None)
+ }
+
+ fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E>
+ where
+ T: Serialize,
+ {
+ Ok(Content::Some(Box::new(value.serialize(self)?)))
+ }
+
+ fn serialize_unit(self) -> Result<Content, E> {
+ Ok(Content::Unit)
+ }
+
+ fn serialize_unit_struct(self, name: &'static str) -> Result<Content, E> {
+ Ok(Content::UnitStruct(name))
+ }
+
+ fn serialize_unit_variant(
+ self,
+ name: &'static str,
+ variant_index: u32,
+ variant: &'static str,
+ ) -> Result<Content, E> {
+ Ok(Content::UnitVariant(name, variant_index, variant))
+ }
+
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ name: &'static str,
+ value: &T,
+ ) -> Result<Content, E>
+ where
+ T: Serialize,
+ {
+ Ok(Content::NewtypeStruct(
+ name,
+ Box::new(value.serialize(self)?),
+ ))
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ name: &'static str,
+ variant_index: u32,
+ variant: &'static str,
+ value: &T,
+ ) -> Result<Content, E>
+ where
+ T: Serialize,
+ {
+ Ok(Content::NewtypeVariant(
+ name,
+ variant_index,
+ variant,
+ Box::new(value.serialize(self)?),
+ ))
+ }
+
+ fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> {
+ Ok(SerializeSeq {
+ is_human_readable: self.is_human_readable,
+ elements: Vec::with_capacity(len.unwrap_or(0)),
+ error: PhantomData,
+ })
+ }
+
+ fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
+ Ok(SerializeTuple {
+ is_human_readable: self.is_human_readable,
+ elements: Vec::with_capacity(len),
+ error: PhantomData,
+ })
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ name: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleStruct, E> {
+ Ok(SerializeTupleStruct {
+ is_human_readable: self.is_human_readable,
+ name,
+ fields: Vec::with_capacity(len),
+ error: PhantomData,
+ })
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ name: &'static str,
+ variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleVariant, E> {
+ Ok(SerializeTupleVariant {
+ is_human_readable: self.is_human_readable,
+ name,
+ variant_index,
+ variant,
+ fields: Vec::with_capacity(len),
+ error: PhantomData,
+ })
+ }
+
+ fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> {
+ Ok(SerializeMap {
+ is_human_readable: self.is_human_readable,
+ entries: Vec::with_capacity(len.unwrap_or(0)),
+ key: None,
+ error: PhantomData,
+ })
+ }
+
+ fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, E> {
+ Ok(SerializeStruct {
+ is_human_readable: self.is_human_readable,
+ name,
+ fields: Vec::with_capacity(len),
+ error: PhantomData,
+ })
+ }
+
+ fn serialize_struct_variant(
+ self,
+ name: &'static str,
+ variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeStructVariant, E> {
+ Ok(SerializeStructVariant {
+ is_human_readable: self.is_human_readable,
+ name,
+ variant_index,
+ variant,
+ fields: Vec::with_capacity(len),
+ error: PhantomData,
+ })
+ }
+}
+
+pub(crate) struct SerializeSeq<E> {
+ is_human_readable: bool,
+ elements: Vec<Content>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeSeq for SerializeSeq<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.elements.push(value);
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::Seq(self.elements))
+ }
+}
+
+pub(crate) struct SerializeTuple<E> {
+ is_human_readable: bool,
+ elements: Vec<Content>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeTuple for SerializeTuple<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.elements.push(value);
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::Tuple(self.elements))
+ }
+}
+
+pub(crate) struct SerializeTupleStruct<E> {
+ is_human_readable: bool,
+ name: &'static str,
+ fields: Vec<Content>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.fields.push(value);
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::TupleStruct(self.name, self.fields))
+ }
+}
+
+pub(crate) struct SerializeTupleVariant<E> {
+ is_human_readable: bool,
+ name: &'static str,
+ variant_index: u32,
+ variant: &'static str,
+ fields: Vec<Content>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.fields.push(value);
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::TupleVariant(
+ self.name,
+ self.variant_index,
+ self.variant,
+ self.fields,
+ ))
+ }
+}
+
+pub(crate) struct SerializeMap<E> {
+ is_human_readable: bool,
+ entries: Vec<(Content, Content)>,
+ key: Option<Content>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeMap for SerializeMap<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let key = key.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.key = Some(key);
+ Ok(())
+ }
+
+ fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let key = self
+ .key
+ .take()
+ .expect("serialize_value called before serialize_key");
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.entries.push((key, value));
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::Map(self.entries))
+ }
+
+ fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
+ where
+ K: Serialize,
+ V: Serialize,
+ {
+ let key = key.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.entries.push((key, value));
+ Ok(())
+ }
+}
+
+pub(crate) struct SerializeStruct<E> {
+ is_human_readable: bool,
+ name: &'static str,
+ fields: Vec<(&'static str, Content)>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeStruct for SerializeStruct<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.fields.push((key, value));
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::Struct(self.name, self.fields))
+ }
+}
+
+pub(crate) struct SerializeStructVariant<E> {
+ is_human_readable: bool,
+ name: &'static str,
+ variant_index: u32,
+ variant: &'static str,
+ fields: Vec<(&'static str, Content)>,
+ error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeStructVariant for SerializeStructVariant<E>
+where
+ E: ser::Error,
+{
+ type Ok = Content;
+ type Error = E;
+
+ fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
+ where
+ T: Serialize,
+ {
+ let value = value.serialize(ContentSerializer::<E>::new(self.is_human_readable))?;
+ self.fields.push((key, value));
+ Ok(())
+ }
+
+ fn end(self) -> Result<Content, E> {
+ Ok(Content::StructVariant(
+ self.name,
+ self.variant_index,
+ self.variant,
+ self.fields,
+ ))
+ }
+}
diff --git a/third_party/rust/serde_with/src/de/const_arrays.rs b/third_party/rust/serde_with/src/de/const_arrays.rs
new file mode 100644
index 0000000000..63f6d662d6
--- /dev/null
+++ b/third_party/rust/serde_with/src/de/const_arrays.rs
@@ -0,0 +1,338 @@
+use super::*;
+use crate::utils::{MapIter, SeqIter};
+use alloc::{borrow::Cow, boxed::Box, collections::BTreeMap, string::String, vec::Vec};
+use core::{convert::TryInto, fmt, mem::MaybeUninit};
+use serde::de::*;
+use std::collections::HashMap;
+
+// TODO this should probably be moved into the utils module when const generics are available for MSRV
+
+/// # Safety
+/// The code follow exactly the pattern of initializing an array element-by-element from the standard library.
+/// <https://doc.rust-lang.org/nightly/std/mem/union.MaybeUninit.html#initializing-an-array-element-by-element>
+fn array_from_iterator<I, T, E, const N: usize>(
+ mut iter: I,
+ expected: &dyn Expected,
+) -> Result<[T; N], E>
+where
+ I: Iterator<Item = Result<T, E>>,
+ E: Error,
+{
+ fn drop_array_elems<T, const N: usize>(num: usize, mut arr: [MaybeUninit<T>; N]) {
+ arr[..num].iter_mut().for_each(|elem| {
+ // TODO This would be better with assume_init_drop nightly function
+ // https://github.com/rust-lang/rust/issues/63567
+ unsafe { core::ptr::drop_in_place(elem.as_mut_ptr()) };
+ });
+ }
+
+ // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
+ // safe because the type we are claiming to have initialized here is a
+ // bunch of `MaybeUninit`s, which do not require initialization.
+ //
+ // TODO could be simplified with nightly maybe_uninit_uninit_array feature
+ // https://doc.rust-lang.org/nightly/std/mem/union.MaybeUninit.html#method.uninit_array
+ let mut arr: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+
+ // Dropping a `MaybeUninit` does nothing. Thus using raw pointer
+ // assignment instead of `ptr::write` does not cause the old
+ // uninitialized value to be dropped. Also if there is a panic during
+ // this loop, we have a memory leak, but there is no memory safety
+ // issue.
+ for (idx, elem) in arr[..].iter_mut().enumerate() {
+ *elem = match iter.next() {
+ Some(Ok(value)) => MaybeUninit::new(value),
+ Some(Err(err)) => {
+ drop_array_elems(idx, arr);
+ return Err(err);
+ }
+ None => {
+ drop_array_elems(idx, arr);
+ return Err(Error::invalid_length(idx, expected));
+ }
+ };
+ }
+
+ // Everything is initialized. Transmute the array to the
+ // initialized type.
+ // A normal transmute is not possible because of:
+ // https://github.com/rust-lang/rust/issues/61956
+ Ok(unsafe { core::mem::transmute_copy::<_, [T; N]>(&arr) })
+}
+
+impl<'de, T, As, const N: usize> DeserializeAs<'de, [T; N]> for [As; N]
+where
+ As: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<[T; N], D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct ArrayVisitor<T, const M: usize>(PhantomData<T>);
+
+ impl<'de, T, As, const M: usize> Visitor<'de> for ArrayVisitor<DeserializeAsWrap<T, As>, M>
+ where
+ As: DeserializeAs<'de, T>,
+ {
+ type Value = [T; M];
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_fmt(format_args!("an array of size {}", M))
+ }
+
+ fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ array_from_iterator(
+ SeqIter::new(seq).map(|res: Result<DeserializeAsWrap<T, As>, A::Error>| {
+ res.map(|t| t.into_inner())
+ }),
+ &self,
+ )
+ }
+ }
+
+ deserializer.deserialize_tuple(N, ArrayVisitor::<DeserializeAsWrap<T, As>, N>(PhantomData))
+ }
+}
+
+macro_rules! tuple_seq_as_map_impl_intern {
+ ($tyorig:ty, $ty:ident <KAs, VAs>) => {
+ #[allow(clippy::implicit_hasher)]
+ impl<'de, K, KAs, V, VAs, const N: usize> DeserializeAs<'de, $tyorig> for $ty<KAs, VAs>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$tyorig, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct MapVisitor<K, KAs, V, VAs, const M: usize> {
+ marker: PhantomData<(K, KAs, V, VAs)>,
+ }
+
+ impl<'de, K, KAs, V, VAs, const M: usize> Visitor<'de> for MapVisitor<K, KAs, V, VAs, M>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ {
+ type Value = [(K, V); M];
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_fmt(format_args!("a map of length {}", M))
+ }
+
+ fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ array_from_iterator(MapIter::new(access).map(
+ |res: Result<(DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>), A::Error>| {
+ res.map(|(k, v)| (k.into_inner(), v.into_inner()))
+ }
+ ), &self)
+ }
+ }
+
+ let visitor = MapVisitor::<K, KAs, V, VAs, N> {
+ marker: PhantomData,
+ };
+ deserializer.deserialize_map(visitor)
+ }
+ }
+ }
+}
+tuple_seq_as_map_impl_intern!([(K, V); N], BTreeMap<KAs, VAs>);
+tuple_seq_as_map_impl_intern!([(K, V); N], HashMap<KAs, VAs>);
+
+impl<'de, const N: usize> DeserializeAs<'de, [u8; N]> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<[u8; N], D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct ArrayVisitor<const M: usize>;
+
+ impl<'de, const M: usize> Visitor<'de> for ArrayVisitor<M> {
+ type Value = [u8; M];
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_fmt(format_args!("an byte array of size {}", M))
+ }
+
+ fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ array_from_iterator(SeqIter::new(seq), &self)
+ }
+
+ fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ v.try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))
+ }
+
+ fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ v.as_bytes()
+ .try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))
+ }
+ }
+
+ deserializer.deserialize_bytes(ArrayVisitor::<N>)
+ }
+}
+
+impl<'de, const N: usize> DeserializeAs<'de, &'de [u8; N]> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<&'de [u8; N], D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct ArrayVisitor<const M: usize>;
+
+ impl<'de, const M: usize> Visitor<'de> for ArrayVisitor<M> {
+ type Value = &'de [u8; M];
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_fmt(format_args!("a borrowed byte array of size {}", M))
+ }
+
+ fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ v.try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))
+ }
+
+ fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ v.as_bytes()
+ .try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))
+ }
+ }
+
+ deserializer.deserialize_bytes(ArrayVisitor::<N>)
+ }
+}
+
+impl<'de, const N: usize> DeserializeAs<'de, Cow<'de, [u8; N]>> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8; N]>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct CowVisitor<const M: usize>;
+
+ impl<'de, const M: usize> Visitor<'de> for CowVisitor<M> {
+ type Value = Cow<'de, [u8; M]>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a byte array")
+ }
+
+ fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Borrowed(
+ v.try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))?,
+ ))
+ }
+
+ fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Borrowed(
+ v.as_bytes()
+ .try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))?,
+ ))
+ }
+
+ fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(
+ v.to_vec()
+ .try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))?,
+ ))
+ }
+
+ fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(
+ v.as_bytes()
+ .to_vec()
+ .try_into()
+ .map_err(|_| Error::invalid_length(v.len(), &self))?,
+ ))
+ }
+
+ fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let len = v.len();
+ Ok(Cow::Owned(
+ v.try_into()
+ .map_err(|_| Error::invalid_length(len, &self))?,
+ ))
+ }
+
+ fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let len = v.len();
+ Ok(Cow::Owned(
+ v.into_bytes()
+ .try_into()
+ .map_err(|_| Error::invalid_length(len, &self))?,
+ ))
+ }
+
+ fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error>
+ where
+ V: SeqAccess<'de>,
+ {
+ Ok(Cow::Owned(array_from_iterator(SeqIter::new(seq), &self)?))
+ }
+ }
+
+ deserializer.deserialize_bytes(CowVisitor)
+ }
+}
+
+impl<'de, const N: usize> DeserializeAs<'de, Box<[u8; N]>> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<Box<[u8; N]>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Bytes::deserialize_as(deserializer).map(Box::new)
+ }
+}
+
+impl<'de, const N: usize> DeserializeAs<'de, Cow<'de, [u8; N]>> for BorrowCow {
+ fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8; N]>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Bytes::deserialize_as(deserializer)
+ }
+}
diff --git a/third_party/rust/serde_with/src/de/impls.rs b/third_party/rust/serde_with/src/de/impls.rs
new file mode 100644
index 0000000000..fc960c3d07
--- /dev/null
+++ b/third_party/rust/serde_with/src/de/impls.rs
@@ -0,0 +1,1508 @@
+use super::*;
+use crate::{
+ formats::{Flexible, Format, Strict},
+ rust::StringWithSeparator,
+ utils,
+ utils::duration::DurationSigned,
+};
+use alloc::{
+ borrow::{Cow, ToOwned},
+ boxed::Box,
+ collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque},
+ rc::{Rc, Weak as RcWeak},
+ string::String,
+ sync::{Arc, Weak as ArcWeak},
+ vec::Vec,
+};
+use core::{
+ cell::{Cell, RefCell},
+ convert::TryInto,
+ fmt::{self, Display},
+ hash::{BuildHasher, Hash},
+ iter::FromIterator,
+ str::FromStr,
+ time::Duration,
+};
+#[cfg(feature = "indexmap")]
+use indexmap_crate::{IndexMap, IndexSet};
+use serde::de::*;
+use std::{
+ collections::{HashMap, HashSet},
+ sync::{Mutex, RwLock},
+ time::SystemTime,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// region: Simple Wrapper types (e.g., Box, Option)
+
+impl<'de, T, U> DeserializeAs<'de, Box<T>> for Box<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Box<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Box::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, Option<T>> for Option<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Option<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct OptionVisitor<T, U>(PhantomData<(T, U)>);
+
+ impl<'de, T, U> Visitor<'de> for OptionVisitor<T, U>
+ where
+ U: DeserializeAs<'de, T>,
+ {
+ type Value = Option<T>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("option")
+ }
+
+ #[inline]
+ fn visit_unit<E>(self) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(None)
+ }
+
+ #[inline]
+ fn visit_none<E>(self) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(None)
+ }
+
+ #[inline]
+ fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ U::deserialize_as(deserializer).map(Some)
+ }
+ }
+
+ deserializer.deserialize_option(OptionVisitor::<T, U>(PhantomData))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, Rc<T>> for Rc<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Rc<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Rc::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, RcWeak<T>> for RcWeak<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<RcWeak<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ DeserializeAsWrap::<Option<Rc<T>>, Option<Rc<U>>>::deserialize(deserializer)?;
+ Ok(RcWeak::new())
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, Arc<T>> for Arc<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Arc<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Arc::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, ArcWeak<T>> for ArcWeak<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<ArcWeak<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ DeserializeAsWrap::<Option<Arc<T>>, Option<Arc<U>>>::deserialize(deserializer)?;
+ Ok(ArcWeak::new())
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, Cell<T>> for Cell<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Cell<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Cell::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, RefCell<T>> for RefCell<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<RefCell<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(RefCell::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, Mutex<T>> for Mutex<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Mutex<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Mutex::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, RwLock<T>> for RwLock<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<RwLock<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(RwLock::new(
+ DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+ ))
+ }
+}
+
+impl<'de, T, TAs, E, EAs> DeserializeAs<'de, Result<T, E>> for Result<TAs, EAs>
+where
+ TAs: DeserializeAs<'de, T>,
+ EAs: DeserializeAs<'de, E>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Result<T, E>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(
+ match Result::<DeserializeAsWrap<T, TAs>, DeserializeAsWrap<E, EAs>>::deserialize(
+ deserializer,
+ )? {
+ Ok(value) => Ok(value.into_inner()),
+ Err(err) => Err(err.into_inner()),
+ },
+ )
+ }
+}
+
+// endregion
+///////////////////////////////////////////////////////////////////////////////
+// region: Collection Types (e.g., Maps, Sets, Vec)
+
+macro_rules! seq_impl {
+ (
+ $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)* )* >,
+ $access:ident,
+ $with_capacity:expr,
+ $append:ident
+ ) => {
+ // Fix for clippy regression in macros on stable
+ // The bug no longer exists on nightly
+ // https://github.com/rust-lang/rust-clippy/issues/7768
+ #[allow(clippy::semicolon_if_nothing_returned)]
+ impl<'de, T, U $(, $typaram)*> DeserializeAs<'de, $ty<T $(, $typaram)*>> for $ty<U $(, $typaram)*>
+ where
+ U: DeserializeAs<'de, T>,
+ $(T: $tbound1 $(+ $tbound2)*,)*
+ $($typaram: $bound1 $(+ $bound2)*),*
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$ty<T $(, $typaram)*>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct SeqVisitor<T, U $(, $typaram)*> {
+ marker: PhantomData<(T, U $(, $typaram)*)>,
+ }
+
+ impl<'de, T, U $(, $typaram)*> Visitor<'de> for SeqVisitor<T, U $(, $typaram)*>
+ where
+ U: DeserializeAs<'de, T>,
+ $(T: $tbound1 $(+ $tbound2)*,)*
+ $($typaram: $bound1 $(+ $bound2)*),*
+ {
+ type Value = $ty<T $(, $typaram)*>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let mut values = $with_capacity;
+
+ while let Some(value) = $access
+ .next_element()?
+ .map(|v: DeserializeAsWrap<T, U>| v.into_inner())
+ {
+ values.$append(value);
+ }
+
+ Ok(values.into())
+ }
+ }
+
+ let visitor = SeqVisitor::<T, U $(, $typaram)*> {
+ marker: PhantomData,
+ };
+ deserializer.deserialize_seq(visitor)
+ }
+ }
+ };
+}
+
+type BoxedSlice<T> = Box<[T]>;
+seq_impl!(
+ BinaryHeap<T: Ord>,
+ seq,
+ BinaryHeap::with_capacity(utils::size_hint_cautious(seq.size_hint())),
+ push
+);
+seq_impl!(
+ BoxedSlice<T>,
+ seq,
+ Vec::with_capacity(utils::size_hint_cautious(seq.size_hint())),
+ push
+);
+seq_impl!(BTreeSet<T: Ord>, seq, BTreeSet::new(), insert);
+seq_impl!(
+ HashSet<T: Eq + Hash, S: BuildHasher + Default>,
+ seq,
+ HashSet::with_capacity_and_hasher(utils::size_hint_cautious(seq.size_hint()), S::default()),
+ insert
+);
+seq_impl!(LinkedList<T>, seq, LinkedList::new(), push_back);
+seq_impl!(
+ Vec<T>,
+ seq,
+ Vec::with_capacity(utils::size_hint_cautious(seq.size_hint())),
+ push
+);
+seq_impl!(
+ VecDeque<T>,
+ seq,
+ VecDeque::with_capacity(utils::size_hint_cautious(seq.size_hint())),
+ push_back
+);
+#[cfg(feature = "indexmap")]
+seq_impl!(
+ IndexSet<T: Eq + Hash, S: BuildHasher + Default>,
+ seq,
+ IndexSet::with_capacity_and_hasher(utils::size_hint_cautious(seq.size_hint()), S::default()),
+ insert
+);
+
+macro_rules! map_impl {
+ (
+ $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
+ // We need an external name, such that we can use it in the `with_capacity` expression
+ $access:ident,
+ $with_capacity:expr
+ ) => {
+ // Fix for clippy regression in macros on stable
+ // The bug no longer exists on nightly
+ // https://github.com/rust-lang/rust-clippy/issues/7768
+ #[allow(clippy::semicolon_if_nothing_returned)]
+ impl<'de, K, V, KU, VU $(, $typaram)*> DeserializeAs<'de, $ty<K, V $(, $typaram)*>> for $ty<KU, VU $(, $typaram)*>
+ where
+ KU: DeserializeAs<'de, K>,
+ VU: DeserializeAs<'de, V>,
+ $(K: $kbound1 $(+ $kbound2)*,)*
+ $($typaram: $bound1 $(+ $bound2)*),*
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$ty<K, V $(, $typaram)*>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct MapVisitor<K, V, KU, VU $(, $typaram)*> {
+ marker: PhantomData<$ty<K, V $(, $typaram)*>>,
+ marker2: PhantomData<$ty<KU, VU $(, $typaram)*>>,
+ }
+
+ impl<'de, K, V, KU, VU $(, $typaram)*> Visitor<'de> for MapVisitor<K, V, KU, VU $(, $typaram)*>
+ where
+ KU: DeserializeAs<'de, K>,
+ VU: DeserializeAs<'de, V>,
+ $(K: $kbound1 $(+ $kbound2)*,)*
+ $($typaram: $bound1 $(+ $bound2)*),*
+ {
+ type Value = $ty<K, V $(, $typaram)*>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a map")
+ }
+
+ #[inline]
+ fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ let mut values = $with_capacity;
+
+ while let Some((key, value)) = ($access.next_entry())?.map(|(k, v): (DeserializeAsWrap::<K, KU>, DeserializeAsWrap::<V, VU>)| (k.into_inner(), v.into_inner())) {
+ values.insert(key, value);
+ }
+
+ Ok(values)
+ }
+ }
+
+ let visitor = MapVisitor::<K, V, KU, VU $(, $typaram)*> { marker: PhantomData, marker2: PhantomData };
+ deserializer.deserialize_map(visitor)
+ }
+ }
+ }
+}
+
+map_impl!(
+ BTreeMap<K: Ord, V>,
+ map,
+ BTreeMap::new());
+map_impl!(
+ HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
+ map,
+ HashMap::with_capacity_and_hasher(utils::size_hint_cautious(map.size_hint()), S::default()));
+#[cfg(feature = "indexmap")]
+map_impl!(
+ IndexMap<K: Eq + Hash, V, S: BuildHasher + Default>,
+ map,
+ IndexMap::with_capacity_and_hasher(utils::size_hint_cautious(map.size_hint()), S::default()));
+
+macro_rules! tuple_impl {
+ ($len:literal $($n:tt $t:ident $tas:ident)+) => {
+ impl<'de, $($t, $tas,)+> DeserializeAs<'de, ($($t,)+)> for ($($tas,)+)
+ where
+ $($tas: DeserializeAs<'de, $t>,)+
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<($($t,)+), D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct TupleVisitor<$($t,)+>(PhantomData<($($t,)+)>);
+
+ impl<'de, $($t, $tas,)+> Visitor<'de>
+ for TupleVisitor<$(DeserializeAsWrap<$t, $tas>,)+>
+ where
+ $($tas: DeserializeAs<'de, $t>,)+
+ {
+ type Value = ($($t,)+);
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str(concat!("a tuple of size ", $len))
+ }
+
+ #[allow(non_snake_case)]
+ fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ $(
+ let $t: DeserializeAsWrap<$t, $tas> = match seq.next_element()? {
+ Some(value) => value,
+ None => return Err(Error::invalid_length($n, &self)),
+ };
+ )+
+
+ Ok(($($t.into_inner(),)+))
+ }
+ }
+
+ deserializer.deserialize_tuple(
+ $len,
+ TupleVisitor::<$(DeserializeAsWrap<$t, $tas>,)+>(PhantomData),
+ )
+ }
+ }
+ };
+}
+
+tuple_impl!(1 0 T0 As0);
+tuple_impl!(2 0 T0 As0 1 T1 As1);
+tuple_impl!(3 0 T0 As0 1 T1 As1 2 T2 As2);
+tuple_impl!(4 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3);
+tuple_impl!(5 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4);
+tuple_impl!(6 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5);
+tuple_impl!(7 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6);
+tuple_impl!(8 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7);
+tuple_impl!(9 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8);
+tuple_impl!(10 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9);
+tuple_impl!(11 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10);
+tuple_impl!(12 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11);
+tuple_impl!(13 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12);
+tuple_impl!(14 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13);
+tuple_impl!(15 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14);
+tuple_impl!(16 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14 15 T15 As15);
+
+macro_rules! map_as_tuple_seq {
+ ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V>) => {
+ impl<'de, K, KAs, V, VAs> DeserializeAs<'de, $ty<K, V>> for Vec<(KAs, VAs)>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ $(K: $kbound1 $(+ $kbound2)*,)*
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$ty<K, V>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct SeqVisitor<K, KAs, V, VAs> {
+ marker: PhantomData<(K, KAs, V, VAs)>,
+ }
+
+ impl<'de, K, KAs, V, VAs> Visitor<'de> for SeqVisitor<K, KAs, V, VAs>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ $(K: $kbound1 $(+ $kbound2)*,)*
+ {
+ type Value = $ty<K, V>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ #[inline]
+ fn visit_seq<A>(self, access: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let iter = utils::SeqIter::new(access);
+ iter.map(|res| {
+ res.map(
+ |(k, v): (DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>)| {
+ (k.into_inner(), v.into_inner())
+ },
+ )
+ })
+ .collect()
+ }
+ }
+
+ let visitor = SeqVisitor::<K, KAs, V, VAs> {
+ marker: PhantomData,
+ };
+ deserializer.deserialize_seq(visitor)
+ }
+ }
+ };
+}
+map_as_tuple_seq!(BTreeMap<K: Ord, V>);
+map_as_tuple_seq!(HashMap<K: Eq + Hash, V>);
+#[cfg(feature = "indexmap")]
+map_as_tuple_seq!(IndexMap<K: Eq + Hash, V>);
+
+// endregion
+///////////////////////////////////////////////////////////////////////////////
+// region: Conversion types which cause different serialization behavior
+
+impl<'de, T: Deserialize<'de>> DeserializeAs<'de, T> for Same {
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ T::deserialize(deserializer)
+ }
+}
+
+impl<'de, T> DeserializeAs<'de, T> for DisplayFromStr
+where
+ T: FromStr,
+ T::Err: Display,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ crate::rust::display_fromstr::deserialize(deserializer)
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, Vec<T>> for VecSkipError<U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ #[derive(serde::Deserialize)]
+ #[serde(
+ untagged,
+ bound(deserialize = "DeserializeAsWrap<T, TAs>: Deserialize<'de>")
+ )]
+ enum GoodOrError<'a, T, TAs>
+ where
+ TAs: DeserializeAs<'a, T>,
+ {
+ Good(DeserializeAsWrap<T, TAs>),
+ // This consumes one "item" when `T` errors while deserializing.
+ // This is necessary to make this work, when instead of having a direct value
+ // like integer or string, the deserializer sees a list or map.
+ Error(IgnoredAny),
+ #[serde(skip)]
+ _JustAMarkerForTheLifetime(PhantomData<&'a u32>),
+ }
+
+ struct SeqVisitor<T, U> {
+ marker: PhantomData<T>,
+ marker2: PhantomData<U>,
+ }
+
+ impl<'de, T, U> Visitor<'de> for SeqVisitor<T, U>
+ where
+ U: DeserializeAs<'de, T>,
+ {
+ type Value = Vec<T>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let mut values = Vec::with_capacity(seq.size_hint().unwrap_or_default());
+
+ while let Some(value) = seq.next_element()? {
+ if let GoodOrError::<T, U>::Good(value) = value {
+ values.push(value.into_inner());
+ }
+ }
+ Ok(values)
+ }
+ }
+
+ let visitor = SeqVisitor::<T, U> {
+ marker: PhantomData,
+ marker2: PhantomData,
+ };
+ deserializer.deserialize_seq(visitor)
+ }
+}
+
+impl<'de, Str> DeserializeAs<'de, Option<Str>> for NoneAsEmptyString
+where
+ Str: FromStr,
+ Str::Err: Display,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Option<Str>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ crate::rust::string_empty_as_none::deserialize(deserializer)
+ }
+}
+
+macro_rules! tuple_seq_as_map_impl_intern {
+ ($tyorig:ident < (K $(: $($kbound:ident $(+)?)+)?, V $(: $($vbound:ident $(+)?)+)?)>, $ty:ident <KAs, VAs>) => {
+ #[allow(clippy::implicit_hasher)]
+ impl<'de, K, KAs, V, VAs> DeserializeAs<'de, $tyorig < (K, V) >> for $ty<KAs, VAs>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ K: $($($kbound +)*)*,
+ V: $($($vbound +)*)*,
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$tyorig < (K, V) >, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct MapVisitor<K, KAs, V, VAs> {
+ marker: PhantomData<(K, KAs, V, VAs)>,
+ }
+
+ impl<'de, K, KAs, V, VAs> Visitor<'de> for MapVisitor<K, KAs, V, VAs>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ K: $($($kbound +)*)*,
+ V: $($($vbound +)*)*,
+ {
+ type Value = $tyorig < (K, V) >;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a map")
+ }
+
+ #[inline]
+ fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ let iter = utils::MapIter::new(access);
+ iter.map(|res| {
+ res.map(
+ |(k, v): (DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>)| {
+ (k.into_inner(), v.into_inner())
+ },
+ )
+ })
+ .collect()
+ }
+ }
+
+ let visitor = MapVisitor::<K, KAs, V, VAs> {
+ marker: PhantomData,
+ };
+ deserializer.deserialize_map(visitor)
+ }
+ }
+ }
+}
+macro_rules! tuple_seq_as_map_impl {
+ ($($tyorig:ident < (K $(: $($kbound:ident $(+)?)+)?, V $(: $($vbound:ident $(+)?)+)?)> $(,)?)+) => {$(
+ tuple_seq_as_map_impl_intern!($tyorig < (K $(: $($kbound +)+)?, V $(: $($vbound +)+)?) >, BTreeMap<KAs, VAs>);
+ tuple_seq_as_map_impl_intern!($tyorig < (K $(: $($kbound +)+)?, V $(: $($vbound +)+)?) >, HashMap<KAs, VAs>);
+ )+}
+}
+
+tuple_seq_as_map_impl! {
+ BinaryHeap<(K: Ord, V: Ord)>,
+ BTreeSet<(K: Ord, V: Ord)>,
+ LinkedList<(K, V)>,
+ Vec<(K, V)>,
+ VecDeque<(K, V)>,
+}
+tuple_seq_as_map_impl!(HashSet<(K: Eq + Hash, V: Eq + Hash)>);
+#[cfg(feature = "indexmap")]
+tuple_seq_as_map_impl!(IndexSet<(K: Eq + Hash, V: Eq + Hash)>);
+
+macro_rules! tuple_seq_as_map_option_impl {
+ ($($ty:ident $(,)?)+) => {$(
+ #[allow(clippy::implicit_hasher)]
+ impl<'de, K, KAs, V, VAs> DeserializeAs<'de, Option<(K, V)>> for $ty<KAs, VAs>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<Option<(K, V)>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct MapVisitor<K, KAs, V, VAs> {
+ marker: PhantomData<(K, KAs, V, VAs)>,
+ }
+
+ impl<'de, K, KAs, V, VAs> Visitor<'de> for MapVisitor<K, KAs, V, VAs>
+ where
+ KAs: DeserializeAs<'de, K>,
+ VAs: DeserializeAs<'de, V>,
+ {
+ type Value = Option<(K, V)>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a map of size 1")
+ }
+
+ #[inline]
+ fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ let iter = utils::MapIter::new(access);
+ iter.map(|res| {
+ res.map(
+ |(k, v): (DeserializeAsWrap<K, KAs>, DeserializeAsWrap<V, VAs>)| {
+ (k.into_inner(), v.into_inner())
+ },
+ )
+ })
+ .next()
+ .transpose()
+ }
+ }
+
+ let visitor = MapVisitor::<K, KAs, V, VAs> {
+ marker: PhantomData,
+ };
+ deserializer.deserialize_map(visitor)
+ }
+ }
+ )+}
+}
+tuple_seq_as_map_option_impl!(BTreeMap);
+tuple_seq_as_map_option_impl!(HashMap);
+
+impl<'de, T, TAs> DeserializeAs<'de, T> for DefaultOnError<TAs>
+where
+ TAs: DeserializeAs<'de, T>,
+ T: Default,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ #[derive(serde::Deserialize)]
+ #[serde(
+ untagged,
+ bound(deserialize = "DeserializeAsWrap<T, TAs>: Deserialize<'de>")
+ )]
+ enum GoodOrError<'a, T, TAs>
+ where
+ TAs: DeserializeAs<'a, T>,
+ {
+ Good(DeserializeAsWrap<T, TAs>),
+ // This consumes one "item" when `T` errors while deserializing.
+ // This is necessary to make this work, when instead of having a direct value
+ // like integer or string, the deserializer sees a list or map.
+ Error(IgnoredAny),
+ #[serde(skip)]
+ _JustAMarkerForTheLifetime(PhantomData<&'a u32>),
+ }
+
+ Ok(match Deserialize::deserialize(deserializer) {
+ Ok(GoodOrError::<T, TAs>::Good(res)) => res.into_inner(),
+ _ => Default::default(),
+ })
+ }
+}
+
+impl<'de> DeserializeAs<'de, Vec<u8>> for BytesOrString {
+ fn deserialize_as<D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ crate::rust::bytes_or_string::deserialize(deserializer)
+ }
+}
+
+impl<'de, SEPARATOR, I, T> DeserializeAs<'de, I> for StringWithSeparator<SEPARATOR, T>
+where
+ SEPARATOR: Separator,
+ I: FromIterator<T>,
+ T: FromStr,
+ T::Err: Display,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<I, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let s = String::deserialize(deserializer)?;
+ if s.is_empty() {
+ Ok(None.into_iter().collect())
+ } else {
+ s.split(SEPARATOR::separator())
+ .map(FromStr::from_str)
+ .collect::<Result<_, _>>()
+ .map_err(Error::custom)
+ }
+ }
+}
+
+macro_rules! use_signed_duration {
+ (
+ $main_trait:ident $internal_trait:ident =>
+ {
+ $ty:ty; $converter:ident =>
+ $({
+ $format:ty, $strictness:ty =>
+ $($tbound:ident: $bound:ident $(,)?)*
+ })*
+ }
+ ) => {
+ $(
+ impl<'de, $($tbound,)*> DeserializeAs<'de, $ty> for $main_trait<$format, $strictness>
+ where
+ $($tbound: $bound,)*
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$ty, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let dur: DurationSigned = $internal_trait::<$format, $strictness>::deserialize_as(deserializer)?;
+ dur.$converter::<D>()
+ }
+ }
+ )*
+ };
+ (
+ $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
+ ) => {
+ $( use_signed_duration!($main_trait $internal_trait => $rest); )+
+ };
+}
+
+use_signed_duration!(
+ DurationSeconds DurationSeconds,
+ DurationMilliSeconds DurationMilliSeconds,
+ DurationMicroSeconds DurationMicroSeconds,
+ DurationNanoSeconds DurationNanoSeconds,
+ => {
+ Duration; to_std_duration =>
+ {u64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_signed_duration!(
+ DurationSecondsWithFrac DurationSecondsWithFrac,
+ DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ Duration; to_std_duration =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+
+use_signed_duration!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ SystemTime; to_system_time =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_signed_duration!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ SystemTime; to_system_time =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+
+impl<'de, T, U> DeserializeAs<'de, T> for DefaultOnNull<U>
+where
+ U: DeserializeAs<'de, T>,
+ T: Default,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(Option::<U>::deserialize_as(deserializer)?.unwrap_or_default())
+ }
+}
+
+impl<'de> DeserializeAs<'de, &'de [u8]> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<&'de [u8], D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ <&'de [u8]>::deserialize(deserializer)
+ }
+}
+
+// serde_bytes implementation for ByteBuf
+// https://github.com/serde-rs/bytes/blob/cbae606b9dc225fc094b031cc84eac9493da2058/src/bytebuf.rs#L196
+//
+// Implements:
+// * visit_seq
+// * visit_bytes
+// * visit_byte_buf
+// * visit_str
+// * visit_string
+impl<'de> DeserializeAs<'de, Vec<u8>> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct VecVisitor;
+
+ impl<'de> Visitor<'de> for VecVisitor {
+ type Value = Vec<u8>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a byte array")
+ }
+
+ fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ utils::SeqIter::new(seq).collect::<Result<_, _>>()
+ }
+
+ fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v.to_vec())
+ }
+
+ fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v)
+ }
+
+ fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v.as_bytes().to_vec())
+ }
+
+ fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v.into_bytes())
+ }
+ }
+
+ deserializer.deserialize_byte_buf(VecVisitor)
+ }
+}
+
+impl<'de> DeserializeAs<'de, Box<[u8]>> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<Box<[u8]>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ <Bytes as DeserializeAs<'de, Vec<u8>>>::deserialize_as(deserializer)
+ .map(|vec| vec.into_boxed_slice())
+ }
+}
+
+// serde_bytes implementation for Cow<'a, [u8]>
+// https://github.com/serde-rs/bytes/blob/cbae606b9dc225fc094b031cc84eac9493da2058/src/de.rs#L77
+//
+// Implements:
+// * visit_borrowed_bytes
+// * visit_borrowed_str
+// * visit_bytes
+// * visit_str
+// * visit_byte_buf
+// * visit_string
+// * visit_seq
+impl<'de> DeserializeAs<'de, Cow<'de, [u8]>> for Bytes {
+ fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8]>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct CowVisitor;
+
+ impl<'de> Visitor<'de> for CowVisitor {
+ type Value = Cow<'de, [u8]>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a byte array")
+ }
+
+ fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Borrowed(v))
+ }
+
+ fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Borrowed(v.as_bytes()))
+ }
+
+ fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(v.to_vec()))
+ }
+
+ fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(v.as_bytes().to_vec()))
+ }
+
+ fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(v))
+ }
+
+ fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(v.into_bytes()))
+ }
+
+ fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error>
+ where
+ V: SeqAccess<'de>,
+ {
+ Ok(Cow::Owned(
+ utils::SeqIter::new(seq).collect::<Result<_, _>>()?,
+ ))
+ }
+ }
+
+ deserializer.deserialize_bytes(CowVisitor)
+ }
+}
+
+impl<'de, T, U, FORMAT> DeserializeAs<'de, Vec<T>> for OneOrMany<U, FORMAT>
+where
+ U: DeserializeAs<'de, T>,
+ FORMAT: Format,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ #[derive(serde::Deserialize)]
+ #[serde(
+ untagged,
+ bound(deserialize = r#"DeserializeAsWrap<T, U>: Deserialize<'de>,
+ DeserializeAsWrap<Vec<T>, Vec<U>>: Deserialize<'de>"#),
+ expecting = "a list or single element"
+ )]
+ enum Helper<'a, T, U>
+ where
+ U: DeserializeAs<'a, T>,
+ {
+ One(DeserializeAsWrap<T, U>),
+ Many(DeserializeAsWrap<Vec<T>, Vec<U>>),
+ #[serde(skip)]
+ _JustAMarkerForTheLifetime(PhantomData<&'a u32>),
+ }
+
+ let h: Helper<'de, T, U> = Deserialize::deserialize(deserializer)?;
+ match h {
+ Helper::One(one) => Ok(alloc::vec![one.into_inner()]),
+ Helper::Many(many) => Ok(many.into_inner()),
+ Helper::_JustAMarkerForTheLifetime(_) => unreachable!(),
+ }
+ }
+}
+
+impl<'de, T, TAs1> DeserializeAs<'de, T> for PickFirst<(TAs1,)>
+where
+ TAs1: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(DeserializeAsWrap::<T, TAs1>::deserialize(deserializer)?.into_inner())
+ }
+}
+
+impl<'de, T, TAs1, TAs2> DeserializeAs<'de, T> for PickFirst<(TAs1, TAs2)>
+where
+ TAs1: DeserializeAs<'de, T>,
+ TAs2: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ #[derive(serde::Deserialize)]
+ #[serde(
+ untagged,
+ bound(deserialize = r#"
+ DeserializeAsWrap<T, TAs1>: Deserialize<'de>,
+ DeserializeAsWrap<T, TAs2>: Deserialize<'de>,
+ "#),
+ expecting = "PickFirst could not deserialize data"
+ )]
+ enum Helper<'a, T, TAs1, TAs2>
+ where
+ TAs1: DeserializeAs<'a, T>,
+ TAs2: DeserializeAs<'a, T>,
+ {
+ First(DeserializeAsWrap<T, TAs1>),
+ Second(DeserializeAsWrap<T, TAs2>),
+ #[serde(skip)]
+ _JustAMarkerForTheLifetime(PhantomData<&'a u32>),
+ }
+
+ let h: Helper<'de, T, TAs1, TAs2> = Deserialize::deserialize(deserializer)?;
+ match h {
+ Helper::First(first) => Ok(first.into_inner()),
+ Helper::Second(second) => Ok(second.into_inner()),
+ Helper::_JustAMarkerForTheLifetime(_) => unreachable!(),
+ }
+ }
+}
+
+impl<'de, T, TAs1, TAs2, TAs3> DeserializeAs<'de, T> for PickFirst<(TAs1, TAs2, TAs3)>
+where
+ TAs1: DeserializeAs<'de, T>,
+ TAs2: DeserializeAs<'de, T>,
+ TAs3: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ #[derive(serde::Deserialize)]
+ #[serde(
+ untagged,
+ bound(deserialize = r#"
+ DeserializeAsWrap<T, TAs1>: Deserialize<'de>,
+ DeserializeAsWrap<T, TAs2>: Deserialize<'de>,
+ DeserializeAsWrap<T, TAs3>: Deserialize<'de>,
+ "#),
+ expecting = "PickFirst could not deserialize data"
+ )]
+ enum Helper<'a, T, TAs1, TAs2, TAs3>
+ where
+ TAs1: DeserializeAs<'a, T>,
+ TAs2: DeserializeAs<'a, T>,
+ TAs3: DeserializeAs<'a, T>,
+ {
+ First(DeserializeAsWrap<T, TAs1>),
+ Second(DeserializeAsWrap<T, TAs2>),
+ Third(DeserializeAsWrap<T, TAs3>),
+ #[serde(skip)]
+ _JustAMarkerForTheLifetime(PhantomData<&'a u32>),
+ }
+
+ let h: Helper<'de, T, TAs1, TAs2, TAs3> = Deserialize::deserialize(deserializer)?;
+ match h {
+ Helper::First(first) => Ok(first.into_inner()),
+ Helper::Second(second) => Ok(second.into_inner()),
+ Helper::Third(third) => Ok(third.into_inner()),
+ Helper::_JustAMarkerForTheLifetime(_) => unreachable!(),
+ }
+ }
+}
+
+impl<'de, T, TAs1, TAs2, TAs3, TAs4> DeserializeAs<'de, T> for PickFirst<(TAs1, TAs2, TAs3, TAs4)>
+where
+ TAs1: DeserializeAs<'de, T>,
+ TAs2: DeserializeAs<'de, T>,
+ TAs3: DeserializeAs<'de, T>,
+ TAs4: DeserializeAs<'de, T>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ #[derive(serde::Deserialize)]
+ #[serde(
+ untagged,
+ bound(deserialize = r#"
+ DeserializeAsWrap<T, TAs1>: Deserialize<'de>,
+ DeserializeAsWrap<T, TAs2>: Deserialize<'de>,
+ DeserializeAsWrap<T, TAs3>: Deserialize<'de>,
+ DeserializeAsWrap<T, TAs4>: Deserialize<'de>,
+ "#),
+ expecting = "PickFirst could not deserialize data"
+ )]
+ enum Helper<'a, T, TAs1, TAs2, TAs3, TAs4>
+ where
+ TAs1: DeserializeAs<'a, T>,
+ TAs2: DeserializeAs<'a, T>,
+ TAs3: DeserializeAs<'a, T>,
+ TAs4: DeserializeAs<'a, T>,
+ {
+ First(DeserializeAsWrap<T, TAs1>),
+ Second(DeserializeAsWrap<T, TAs2>),
+ Third(DeserializeAsWrap<T, TAs3>),
+ Forth(DeserializeAsWrap<T, TAs4>),
+ #[serde(skip)]
+ _JustAMarkerForTheLifetime(PhantomData<&'a u32>),
+ }
+
+ let h: Helper<'de, T, TAs1, TAs2, TAs3, TAs4> = Deserialize::deserialize(deserializer)?;
+ match h {
+ Helper::First(first) => Ok(first.into_inner()),
+ Helper::Second(second) => Ok(second.into_inner()),
+ Helper::Third(third) => Ok(third.into_inner()),
+ Helper::Forth(forth) => Ok(forth.into_inner()),
+ Helper::_JustAMarkerForTheLifetime(_) => unreachable!(),
+ }
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, T> for FromInto<U>
+where
+ U: Into<T>,
+ U: Deserialize<'de>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(U::deserialize(deserializer)?.into())
+ }
+}
+
+impl<'de, T, U> DeserializeAs<'de, T> for TryFromInto<U>
+where
+ U: TryInto<T>,
+ <U as TryInto<T>>::Error: Display,
+ U: Deserialize<'de>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ U::deserialize(deserializer)?
+ .try_into()
+ .map_err(Error::custom)
+ }
+}
+
+impl<'de> DeserializeAs<'de, Cow<'de, str>> for BorrowCow {
+ fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, str>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct CowVisitor;
+
+ impl<'de> Visitor<'de> for CowVisitor {
+ type Value = Cow<'de, str>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("an optionally borrowed string")
+ }
+
+ fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Borrowed(v))
+ }
+
+ fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(v.to_owned()))
+ }
+
+ fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(Cow::Owned(v))
+ }
+ }
+
+ deserializer.deserialize_str(CowVisitor)
+ }
+}
+
+impl<'de> DeserializeAs<'de, Cow<'de, [u8]>> for BorrowCow {
+ fn deserialize_as<D>(deserializer: D) -> Result<Cow<'de, [u8]>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Bytes::deserialize_as(deserializer)
+ }
+}
+
+impl<'de> DeserializeAs<'de, bool> for BoolFromInt<Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<bool, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct U8Visitor;
+ impl<'de> Visitor<'de> for U8Visitor {
+ type Value = bool;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("an integer 0 or 1")
+ }
+
+ fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match v {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ unexp => Err(Error::invalid_value(
+ Unexpected::Unsigned(unexp as u64),
+ &"0 or 1",
+ )),
+ }
+ }
+
+ fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match v {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ unexp => Err(Error::invalid_value(
+ Unexpected::Signed(unexp as i64),
+ &"0 or 1",
+ )),
+ }
+ }
+
+ fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match v {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ unexp => Err(Error::invalid_value(Unexpected::Unsigned(unexp), &"0 or 1")),
+ }
+ }
+
+ fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match v {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ unexp => Err(Error::invalid_value(Unexpected::Signed(unexp), &"0 or 1")),
+ }
+ }
+
+ fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match v {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ unexp => Err(Error::invalid_value(
+ Unexpected::Unsigned(unexp as u64),
+ &"0 or 1",
+ )),
+ }
+ }
+
+ fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match v {
+ 0 => Ok(false),
+ 1 => Ok(true),
+ unexp => Err(Error::invalid_value(
+ Unexpected::Unsigned(unexp as u64),
+ &"0 or 1",
+ )),
+ }
+ }
+ }
+
+ deserializer.deserialize_u8(U8Visitor)
+ }
+}
+
+impl<'de> DeserializeAs<'de, bool> for BoolFromInt<Flexible> {
+ fn deserialize_as<D>(deserializer: D) -> Result<bool, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct U8Visitor;
+ impl<'de> Visitor<'de> for U8Visitor {
+ type Value = bool;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("an integer")
+ }
+
+ fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v != 0)
+ }
+
+ fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v != 0)
+ }
+
+ fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v != 0)
+ }
+
+ fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v != 0)
+ }
+
+ fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v != 0)
+ }
+
+ fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(v != 0)
+ }
+ }
+
+ deserializer.deserialize_u8(U8Visitor)
+ }
+}
+
+// endregion
diff --git a/third_party/rust/serde_with/src/de/legacy_arrays.rs b/third_party/rust/serde_with/src/de/legacy_arrays.rs
new file mode 100644
index 0000000000..550e444a2f
--- /dev/null
+++ b/third_party/rust/serde_with/src/de/legacy_arrays.rs
@@ -0,0 +1,85 @@
+use super::*;
+use core::fmt;
+use serde::de::*;
+
+macro_rules! array_impl {
+ ($len:literal $($idx:tt)*) => {
+ impl<'de, T, As> DeserializeAs<'de, [T; $len]> for [As; $len]
+ where
+ As: DeserializeAs<'de, T>,
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<[T; $len], D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct ArrayVisitor<T>(PhantomData<T>);
+
+ impl<'de, T, As> Visitor<'de>
+ for ArrayVisitor<DeserializeAsWrap<T, As>>
+ where
+ As: DeserializeAs<'de, T>,
+ {
+ type Value = [T; $len];
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str(concat!("an array of size ", $len))
+ }
+
+ #[allow(non_snake_case)]
+ // Because of 0-size arrays
+ #[allow(unused_variables, unused_mut)]
+ fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ Ok([$(
+ match seq.next_element::<DeserializeAsWrap<T, As>>()? {
+ Some(value) => value.into_inner(),
+ None => return Err(Error::invalid_length($idx, &self)),
+ },
+ )*])
+ }
+ }
+
+ deserializer.deserialize_tuple(
+ $len,
+ ArrayVisitor::<DeserializeAsWrap<T, As>>(PhantomData),
+ )
+ }
+ }
+ };
+}
+
+array_impl!(0);
+array_impl!(1 0);
+array_impl!(2 0 1);
+array_impl!(3 0 1 2);
+array_impl!(4 0 1 2 3);
+array_impl!(5 0 1 2 3 4);
+array_impl!(6 0 1 2 3 4 5);
+array_impl!(7 0 1 2 3 4 5 6);
+array_impl!(8 0 1 2 3 4 5 6 7);
+array_impl!(9 0 1 2 3 4 5 6 7 8);
+array_impl!(10 0 1 2 3 4 5 6 7 8 9);
+array_impl!(11 0 1 2 3 4 5 6 7 8 9 10);
+array_impl!(12 0 1 2 3 4 5 6 7 8 9 10 11);
+array_impl!(13 0 1 2 3 4 5 6 7 8 9 10 11 12);
+array_impl!(14 0 1 2 3 4 5 6 7 8 9 10 11 12 13);
+array_impl!(15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14);
+array_impl!(16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15);
+array_impl!(17 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
+array_impl!(18 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17);
+array_impl!(19 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18);
+array_impl!(20 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19);
+array_impl!(21 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20);
+array_impl!(22 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21);
+array_impl!(23 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22);
+array_impl!(24 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23);
+array_impl!(25 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24);
+array_impl!(26 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25);
+array_impl!(27 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26);
+array_impl!(28 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27);
+array_impl!(29 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28);
+array_impl!(30 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29);
+array_impl!(31 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30);
+array_impl!(32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31);
diff --git a/third_party/rust/serde_with/src/de/mod.rs b/third_party/rust/serde_with/src/de/mod.rs
new file mode 100644
index 0000000000..518b4f2606
--- /dev/null
+++ b/third_party/rust/serde_with/src/de/mod.rs
@@ -0,0 +1,143 @@
+//! Module for [`DeserializeAs`][] implementations
+//!
+//! The module contains the [`DeserializeAs`][] trait and helper code.
+//! Additionally, it contains implementations of [`DeserializeAs`][] for types defined in the Rust Standard Library or this crate.
+//!
+//! You can find more details on how to implement this trait for your types in the documentation of the [`DeserializeAs`][] trait and details about the usage in the [user guide][].
+//!
+//! [user guide]: crate::guide
+
+mod const_arrays;
+mod impls;
+
+use super::*;
+
+/// A **data structure** that can be deserialized from any data format supported by Serde, analogue to [`Deserialize`].
+///
+/// The trait is analogue to the [`serde::Deserialize`][`Deserialize`] trait, with the same meaning of input and output arguments.
+/// It can and should the implemented using the same code structure as the [`Deserialize`] trait.
+/// As such, the same advice for [implementing `Deserialize`][impl-deserialize] applies here.
+///
+/// # Differences to [`Deserialize`]
+///
+/// The trait is only required for container-like types or types implementing specific conversion functions.
+/// Container-like types are [`Vec`], [`BTreeMap`], but also [`Option`] and [`Box`].
+/// Conversion types deserialize into a different Rust type.
+/// For example, [`DisplayFromStr`] uses the [`FromStr`] trait after deserializing a string and [`DurationSeconds`] creates a [`Duration`] from either String or integer values.
+///
+/// This code shows how to implement [`Deserialize`] for [`Box`]:
+///
+/// ```rust,ignore
+/// impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> {
+/// fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+/// where
+/// D: Deserializer<'de>,
+/// {
+/// Ok(Box::new(Deserialize::deserialize(deserializer)?))
+/// }
+/// }
+/// ```
+///
+/// and this code shows how to do the same using [`DeserializeAs`][]:
+///
+/// ```rust,ignore
+/// impl<'de, T, U> DeserializeAs<'de, Box<T>> for Box<U>
+/// where
+/// U: DeserializeAs<'de, T>,
+/// {
+/// fn deserialize_as<D>(deserializer: D) -> Result<Box<T>, D::Error>
+/// where
+/// D: Deserializer<'de>,
+/// {
+/// Ok(Box::new(
+/// DeserializeAsWrap::<T, U>::deserialize(deserializer)?.into_inner(),
+/// ))
+/// }
+/// }
+/// ```
+///
+/// It uses two type parameters, `T` and `U` instead of only one and performs the deserialization step using the `DeserializeAsWrap` type.
+/// The `T` type is the on the Rust side after deserialization, whereas the `U` type determines how the value will be deserialized.
+/// These two changes are usually enough to make a container type implement [`DeserializeAs`][].
+///
+///
+/// [`DeserializeAsWrap`] is a piece of glue code which turns [`DeserializeAs`] into a serde compatible datatype, by converting all calls to `deserialize` into `deserialize_as`.
+/// This allows us to implement [`DeserializeAs`] such that it can be applied recursively throughout the whole data structure.
+/// This is mostly important for container types, such as `Vec` or `BTreeMap`.
+/// In a `BTreeMap` this allows us to specify two different serialization behaviors, one for key and one for value, using the [`DeserializeAs`] trait.
+///
+/// ## Implementing a converter Type
+///
+/// This shows a simplified implementation for [`DisplayFromStr`].
+///
+/// ```rust
+/// # #[cfg(all(feature = "macros"))] {
+/// # use serde::Deserialize;
+/// # use serde::de::Error;
+/// # use serde_with::DeserializeAs;
+/// # use std::str::FromStr;
+/// # use std::fmt::Display;
+/// struct DisplayFromStr;
+///
+/// impl<'de, T> DeserializeAs<'de, T> for DisplayFromStr
+/// where
+/// T: FromStr,
+/// T::Err: Display,
+/// {
+/// fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+/// where
+/// D: serde::Deserializer<'de>,
+/// {
+/// let s = String::deserialize(deserializer).map_err(Error::custom)?;
+/// s.parse().map_err(Error::custom)
+/// }
+/// }
+/// #
+/// # #[serde_with::serde_as]
+/// # #[derive(serde::Deserialize)]
+/// # struct S (#[serde_as(as = "DisplayFromStr")] bool);
+/// #
+/// # assert_eq!(false, serde_json::from_str::<S>(r#""false""#).unwrap().0);
+/// # }
+/// ```
+/// [`Box`]: std::boxed::Box
+/// [`BTreeMap`]: std::collections::BTreeMap
+/// [`Duration`]: std::time::Duration
+/// [`FromStr`]: std::str::FromStr
+/// [`Vec`]: std::vec::Vec
+/// [impl-deserialize]: https://serde.rs/impl-deserialize.html
+pub trait DeserializeAs<'de, T>: Sized {
+ /// Deserialize this value from the given Serde deserializer.
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>;
+}
+
+/// Helper type to implement [`DeserializeAs`] for container-like types.
+#[derive(Debug)]
+pub struct DeserializeAsWrap<T, U> {
+ value: T,
+ marker: PhantomData<U>,
+}
+
+impl<T, U> DeserializeAsWrap<T, U> {
+ /// Return the inner value of type `T`.
+ pub fn into_inner(self) -> T {
+ self.value
+ }
+}
+
+impl<'de, T, U> Deserialize<'de> for DeserializeAsWrap<T, U>
+where
+ U: DeserializeAs<'de, T>,
+{
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ U::deserialize_as(deserializer).map(|value| Self {
+ value,
+ marker: PhantomData,
+ })
+ }
+}
diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs b/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs
new file mode 100644
index 0000000000..9370f5fd51
--- /dev/null
+++ b/third_party/rust/serde_with/src/duplicate_key_impls/error_on_duplicate.rs
@@ -0,0 +1,127 @@
+use alloc::collections::{BTreeMap, BTreeSet};
+use core::hash::{BuildHasher, Hash};
+#[cfg(feature = "indexmap")]
+use indexmap_crate::{IndexMap, IndexSet};
+use std::collections::{HashMap, HashSet};
+
+pub trait PreventDuplicateInsertsSet<T> {
+ fn new(size_hint: Option<usize>) -> Self;
+
+ /// Return true if the insert was successful and the value did not exist in the set
+ fn insert(&mut self, value: T) -> bool;
+}
+
+pub trait PreventDuplicateInsertsMap<K, V> {
+ fn new(size_hint: Option<usize>) -> Self;
+
+ /// Return true if the insert was successful and the key did not exist in the map
+ fn insert(&mut self, key: K, value: V) -> bool;
+}
+
+impl<T, S> PreventDuplicateInsertsSet<T> for HashSet<T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, value: T) -> bool {
+ self.insert(value)
+ }
+}
+
+#[cfg(feature = "indexmap")]
+impl<T, S> PreventDuplicateInsertsSet<T> for IndexSet<T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, value: T) -> bool {
+ self.insert(value)
+ }
+}
+
+impl<T> PreventDuplicateInsertsSet<T> for BTreeSet<T>
+where
+ T: Ord,
+{
+ #[inline]
+ fn new(_size_hint: Option<usize>) -> Self {
+ Self::new()
+ }
+
+ #[inline]
+ fn insert(&mut self, value: T) -> bool {
+ self.insert(value)
+ }
+}
+
+impl<K, V, S> PreventDuplicateInsertsMap<K, V> for HashMap<K, V, S>
+where
+ K: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, key: K, value: V) -> bool {
+ self.insert(key, value).is_none()
+ }
+}
+
+#[cfg(feature = "indexmap")]
+impl<K, V, S> PreventDuplicateInsertsMap<K, V> for IndexMap<K, V, S>
+where
+ K: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, key: K, value: V) -> bool {
+ self.insert(key, value).is_none()
+ }
+}
+
+impl<K, V> PreventDuplicateInsertsMap<K, V> for BTreeMap<K, V>
+where
+ K: Ord,
+{
+ #[inline]
+ fn new(_size_hint: Option<usize>) -> Self {
+ Self::new()
+ }
+
+ #[inline]
+ fn insert(&mut self, key: K, value: V) -> bool {
+ self.insert(key, value).is_none()
+ }
+}
diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs b/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs
new file mode 100644
index 0000000000..faf922b8c2
--- /dev/null
+++ b/third_party/rust/serde_with/src/duplicate_key_impls/first_value_wins.rs
@@ -0,0 +1,136 @@
+use alloc::collections::{BTreeMap, BTreeSet};
+use core::hash::{BuildHasher, Hash};
+#[cfg(feature = "indexmap")]
+use indexmap_crate::IndexMap;
+use std::collections::{HashMap, HashSet};
+
+#[deprecated = "This is serde's default behavior."]
+pub trait DuplicateInsertsFirstWinsSet<T> {
+ fn new(size_hint: Option<usize>) -> Self;
+
+ /// Insert the value into the set, if there is not already an existing value
+ fn insert(&mut self, value: T);
+}
+
+pub trait DuplicateInsertsFirstWinsMap<K, V> {
+ fn new(size_hint: Option<usize>) -> Self;
+
+ /// Insert the value into the map, if there is not already an existing value
+ fn insert(&mut self, key: K, value: V);
+}
+
+#[allow(deprecated)]
+impl<T, S> DuplicateInsertsFirstWinsSet<T> for HashSet<T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, value: T) {
+ // Hashset already fulfils the contract and always keeps the first value
+ self.insert(value);
+ }
+}
+
+#[allow(deprecated)]
+impl<T> DuplicateInsertsFirstWinsSet<T> for BTreeSet<T>
+where
+ T: Ord,
+{
+ #[inline]
+ fn new(_size_hint: Option<usize>) -> Self {
+ Self::new()
+ }
+
+ #[inline]
+ fn insert(&mut self, value: T) {
+ // BTreeSet already fulfils the contract and always keeps the first value
+ self.insert(value);
+ }
+}
+
+impl<K, V, S> DuplicateInsertsFirstWinsMap<K, V> for HashMap<K, V, S>
+where
+ K: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, key: K, value: V) {
+ use std::collections::hash_map::Entry;
+
+ match self.entry(key) {
+ // we want to keep the first value, so do nothing
+ Entry::Occupied(_) => {}
+ Entry::Vacant(vacant) => {
+ vacant.insert(value);
+ }
+ }
+ }
+}
+
+#[cfg(feature = "indexmap")]
+impl<K, V, S> DuplicateInsertsFirstWinsMap<K, V> for IndexMap<K, V, S>
+where
+ K: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn insert(&mut self, key: K, value: V) {
+ use indexmap_crate::map::Entry;
+
+ match self.entry(key) {
+ // we want to keep the first value, so do nothing
+ Entry::Occupied(_) => {}
+ Entry::Vacant(vacant) => {
+ vacant.insert(value);
+ }
+ }
+ }
+}
+
+impl<K, V> DuplicateInsertsFirstWinsMap<K, V> for BTreeMap<K, V>
+where
+ K: Ord,
+{
+ #[inline]
+ fn new(_size_hint: Option<usize>) -> Self {
+ Self::new()
+ }
+
+ #[inline]
+ fn insert(&mut self, key: K, value: V) {
+ use alloc::collections::btree_map::Entry;
+
+ match self.entry(key) {
+ // we want to keep the first value, so do nothing
+ Entry::Occupied(_) => {}
+ Entry::Vacant(vacant) => {
+ vacant.insert(value);
+ }
+ }
+ }
+}
diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs b/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs
new file mode 100644
index 0000000000..3eeeaac079
--- /dev/null
+++ b/third_party/rust/serde_with/src/duplicate_key_impls/last_value_wins.rs
@@ -0,0 +1,69 @@
+use alloc::collections::BTreeSet;
+use core::hash::{BuildHasher, Hash};
+#[cfg(feature = "indexmap")]
+use indexmap_crate::IndexSet;
+use std::collections::HashSet;
+
+pub trait DuplicateInsertsLastWinsSet<T> {
+ fn new(size_hint: Option<usize>) -> Self;
+
+ /// Insert or replace the existing value
+ fn replace(&mut self, value: T);
+}
+
+impl<T, S> DuplicateInsertsLastWinsSet<T> for HashSet<T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn replace(&mut self, value: T) {
+ // Hashset already fulfils the contract
+ self.replace(value);
+ }
+}
+
+#[cfg(feature = "indexmap")]
+impl<T, S> DuplicateInsertsLastWinsSet<T> for IndexSet<T, S>
+where
+ T: Eq + Hash,
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn new(size_hint: Option<usize>) -> Self {
+ match size_hint {
+ Some(size) => Self::with_capacity_and_hasher(size, S::default()),
+ None => Self::with_hasher(S::default()),
+ }
+ }
+
+ #[inline]
+ fn replace(&mut self, value: T) {
+ // Hashset already fulfils the contract
+ self.replace(value);
+ }
+}
+
+impl<T> DuplicateInsertsLastWinsSet<T> for BTreeSet<T>
+where
+ T: Ord,
+{
+ #[inline]
+ fn new(_size_hint: Option<usize>) -> Self {
+ Self::new()
+ }
+
+ #[inline]
+ fn replace(&mut self, value: T) {
+ // BTreeSet already fulfils the contract
+ self.replace(value);
+ }
+}
diff --git a/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs b/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs
new file mode 100644
index 0000000000..6080812232
--- /dev/null
+++ b/third_party/rust/serde_with/src/duplicate_key_impls/mod.rs
@@ -0,0 +1,10 @@
+mod error_on_duplicate;
+mod first_value_wins;
+mod last_value_wins;
+
+#[allow(deprecated)]
+pub use self::{
+ error_on_duplicate::{PreventDuplicateInsertsMap, PreventDuplicateInsertsSet},
+ first_value_wins::{DuplicateInsertsFirstWinsMap, DuplicateInsertsFirstWinsSet},
+ last_value_wins::DuplicateInsertsLastWinsSet,
+};
diff --git a/third_party/rust/serde_with/src/enum_map.rs b/third_party/rust/serde_with/src/enum_map.rs
new file mode 100644
index 0000000000..ef65f8985f
--- /dev/null
+++ b/third_party/rust/serde_with/src/enum_map.rs
@@ -0,0 +1,888 @@
+use crate::{
+ content::ser::{Content, ContentSerializer},
+ DeserializeAs, SerializeAs,
+};
+use alloc::{string::ToString, vec::Vec};
+use core::{fmt, marker::PhantomData};
+use serde::{
+ de::{DeserializeSeed, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor},
+ ser,
+ ser::{Impossible, SerializeMap, SerializeSeq, SerializeStructVariant, SerializeTupleVariant},
+ Deserialize, Deserializer, Serialize, Serializer,
+};
+
+/// Represent a list of enum values as a map.
+///
+/// This **only works** if the enum uses the default *externally tagged* representation.
+/// Other enum representations are not supported.
+///
+/// serde data formats often represent *externally tagged* enums as maps with a single key.
+/// The key is the enum variant name, and the value is the variant value.
+/// Sometimes a map with multiple keys should be treated like a list of enum values.
+///
+/// # Examples
+///
+/// ## JSON Map with multiple keys
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// use serde_with::EnumMap;
+///
+/// # #[derive(Debug, Clone, PartialEq, Eq)]
+/// #[derive(Serialize, Deserialize)]
+/// enum EnumValue {
+/// Int(i32),
+/// String(String),
+/// Unit,
+/// Tuple(i32, String, bool),
+/// Struct {
+/// a: i32,
+/// b: String,
+/// c: bool,
+/// },
+/// }
+///
+/// #[serde_with::serde_as]
+/// # #[derive(Debug, Clone, PartialEq, Eq)]
+/// #[derive(Serialize, Deserialize)]
+/// struct VecEnumValues (
+/// #[serde_as(as = "EnumMap")]
+/// Vec<EnumValue>,
+/// );
+///
+/// // ---
+///
+/// // This will serialize this list of values
+/// let values = VecEnumValues(vec![
+/// EnumValue::Int(123),
+/// EnumValue::String("FooBar".to_string()),
+/// EnumValue::Int(456),
+/// EnumValue::String("XXX".to_string()),
+/// EnumValue::Unit,
+/// EnumValue::Tuple(1, "Middle".to_string(), false),
+/// EnumValue::Struct {
+/// a: 666,
+/// b: "BBB".to_string(),
+/// c: true,
+/// },
+/// ]);
+///
+/// // into this JSON map
+/// // Duplicate keys are emitted for identical enum variants.
+/// let expected =
+/// r#"{
+/// "Int": 123,
+/// "String": "FooBar",
+/// "Int": 456,
+/// "String": "XXX",
+/// "Unit": null,
+/// "Tuple": [
+/// 1,
+/// "Middle",
+/// false
+/// ],
+/// "Struct": {
+/// "a": 666,
+/// "b": "BBB",
+/// "c": true
+/// }
+/// }"#;
+///
+/// // Both serialization and deserialization work flawlessly.
+/// let serialized = serde_json::to_string_pretty(&values).unwrap();
+/// assert_eq!(expected, serialized);
+/// let deserialized: VecEnumValues = serde_json::from_str(&serialized).unwrap();
+/// assert_eq!(values, deserialized);
+/// # }
+/// ```
+///
+/// ## XML structure with varying keys
+///
+/// With `serde_xml_rs` tuple and struct variants are not supported since they fail to roundtrip.
+/// The enum may have such variants as long as they are not serialized or deserialized.
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// use serde_with::EnumMap;
+///
+/// # #[derive(Debug, Clone, PartialEq, Eq)]
+/// #[derive(Serialize, Deserialize)]
+/// enum EnumValue {
+/// Int(i32),
+/// String(String),
+/// Unit,
+/// }
+///
+/// #[serde_with::serde_as]
+/// # #[derive(Debug, Clone, PartialEq, Eq)]
+/// #[derive(Serialize, Deserialize)]
+/// struct VecEnumValues {
+/// #[serde_as(as = "EnumMap")]
+/// vec: Vec<EnumValue>,
+/// }
+///
+/// // ---
+///
+/// // This will serialize this list of values
+/// let values = VecEnumValues {
+/// vec: vec![
+/// EnumValue::Int(123),
+/// EnumValue::String("FooBar".to_string()),
+/// EnumValue::Int(456),
+/// EnumValue::String("XXX".to_string()),
+/// EnumValue::Unit,
+/// ],
+/// };
+///
+/// // into this XML document
+/// // Duplicate keys are emitted for identical enum variants.
+/// let expected = r#"
+/// <VecEnumValues>
+/// <vec>
+/// <Int>123</Int>
+/// <String>FooBar</String>
+/// <Int>456</Int>
+/// <String>XXX</String>
+/// <Unit></Unit>
+/// </vec>
+/// </VecEnumValues>"#
+/// // Remove whitespace
+/// .replace(' ', "")
+/// .replace('\n', "");
+///
+/// // Both serialization and deserialization work flawlessly.
+/// let serialized = serde_xml_rs::to_string(&values).unwrap();
+/// assert_eq!(expected, serialized);
+/// let deserialized: VecEnumValues = serde_xml_rs::from_str(&serialized).unwrap();
+/// assert_eq!(values, deserialized);
+/// # }
+/// ```
+#[derive(Debug, Copy, Clone)]
+pub struct EnumMap;
+
+impl<T> SerializeAs<Vec<T>> for EnumMap
+where
+ T: Serialize,
+{
+ fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source.serialize(SeqAsMapSerializer(serializer))
+ }
+}
+
+impl<'de, T> DeserializeAs<'de, Vec<T>> for EnumMap
+where
+ T: Deserialize<'de>,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct EnumMapVisitor<T>(PhantomData<T>);
+
+ impl<'de, T> Visitor<'de> for EnumMapVisitor<T>
+ where
+ T: Deserialize<'de>,
+ {
+ type Value = Vec<T>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(formatter, "a map or enum values")
+ }
+
+ fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
+ Vec::deserialize(SeqDeserializer(map))
+ }
+ }
+
+ deserializer.deserialize_map(EnumMapVisitor(PhantomData))
+ }
+}
+
+static END_OF_MAP_IDENTIFIER: &str = "__PRIVATE_END_OF_MAP_MARKER__";
+
+// Serialization code below here
+
+/// Convert a sequence to a map during serialization.
+///
+/// Only `serialize_seq` is implemented and forwarded to `serialize_map` on the inner `Serializer`.
+/// The elements are serialized with [`SerializeSeqElement`].
+struct SeqAsMapSerializer<S>(S);
+
+impl<S> Serializer for SeqAsMapSerializer<S>
+where
+ S: Serializer,
+{
+ type Ok = S::Ok;
+ type Error = S::Error;
+
+ type SerializeSeq = SerializeSeqElement<S::SerializeMap>;
+ type SerializeTuple = Impossible<S::Ok, S::Error>;
+ type SerializeTupleStruct = Impossible<S::Ok, S::Error>;
+ type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
+ type SerializeMap = Impossible<S::Ok, S::Error>;
+ type SerializeStruct = Impossible<S::Ok, S::Error>;
+ type SerializeStructVariant = Impossible<S::Ok, S::Error>;
+
+ fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ ) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+ let is_human_readable = self.0.is_human_readable();
+ self.0
+ .serialize_map(len)
+ .map(|delegate| SerializeSeqElement {
+ delegate,
+ is_human_readable,
+ })
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStruct, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+}
+
+/// Serialize a single element but turn the sequence into a map logic.
+///
+/// It uses [`SerializeEnumAsMapElement`] for the map element serialization.
+///
+/// The [`Serializer`] implementation handles all the `serialize_*_variant` functions and defers to [`SerializeVariant`] for the more complicated tuple and struct variants.
+struct SerializeSeqElement<M> {
+ delegate: M,
+ is_human_readable: bool,
+}
+
+impl<M> SerializeSeq for SerializeSeqElement<M>
+where
+ M: SerializeMap,
+{
+ type Ok = M::Ok;
+ type Error = M::Error;
+
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ where
+ T: Serialize,
+ {
+ value.serialize(EnumAsMapElementSerializer {
+ delegate: &mut self.delegate,
+ is_human_readable: self.is_human_readable,
+ })?;
+ Ok(())
+ }
+
+ fn end(self) -> Result<Self::Ok, Self::Error> {
+ self.delegate.end()
+ }
+}
+
+struct EnumAsMapElementSerializer<'a, M> {
+ delegate: &'a mut M,
+ is_human_readable: bool,
+}
+
+impl<'a, M> Serializer for EnumAsMapElementSerializer<'a, M>
+where
+ M: SerializeMap,
+{
+ type Ok = ();
+ type Error = M::Error;
+
+ type SerializeSeq = Impossible<Self::Ok, Self::Error>;
+ type SerializeTuple = Impossible<Self::Ok, Self::Error>;
+ type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
+ type SerializeTupleVariant = SerializeVariant<'a, M>;
+ type SerializeMap = Impossible<Self::Ok, Self::Error>;
+ type SerializeStruct = Impossible<Self::Ok, Self::Error>;
+ type SerializeStructVariant = SerializeVariant<'a, M>;
+
+ fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ ) -> Result<Self::Ok, Self::Error> {
+ self.delegate.serialize_entry(variant, &())?;
+ Ok(())
+ }
+
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ self.delegate.serialize_entry(variant, value)?;
+ Ok(())
+ }
+
+ fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+ Ok(SerializeVariant {
+ delegate: self.delegate,
+ is_human_readable: self.is_human_readable,
+ variant,
+ content: Content::TupleStruct(name, Vec::with_capacity(len)),
+ })
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStruct, Self::Error> {
+ Err(ser::Error::custom("wrong type for EnumMap"))
+ }
+
+ fn serialize_struct_variant(
+ self,
+ name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeStructVariant, Self::Error> {
+ Ok(SerializeVariant {
+ delegate: self.delegate,
+ is_human_readable: self.is_human_readable,
+ variant,
+ content: Content::Struct(name, Vec::with_capacity(len)),
+ })
+ }
+}
+
+/// Serialize a struct or tuple variant enum as a map element
+///
+/// [`SerializeStructVariant`] serializes a struct variant, and [`SerializeTupleVariant`] a tuple variant.
+struct SerializeVariant<'a, M> {
+ delegate: &'a mut M,
+ is_human_readable: bool,
+ variant: &'static str,
+ content: Content,
+}
+
+impl<'a, M> SerializeStructVariant for SerializeVariant<'a, M>
+where
+ M: SerializeMap,
+{
+ type Ok = ();
+
+ type Error = M::Error;
+
+ fn serialize_field<T: ?Sized>(
+ &mut self,
+ key: &'static str,
+ value: &T,
+ ) -> Result<(), Self::Error>
+ where
+ T: Serialize,
+ {
+ // Serialize to a Content type first
+ let value: Content = value.serialize(ContentSerializer::new(self.is_human_readable))?;
+ if let Content::Struct(_name, fields) = &mut self.content {
+ fields.push((key, value));
+ }
+ Ok(())
+ }
+
+ fn end(self) -> Result<Self::Ok, Self::Error> {
+ self.delegate.serialize_entry(&self.variant, &self.content)
+ }
+}
+
+impl<'a, M> SerializeTupleVariant for SerializeVariant<'a, M>
+where
+ M: SerializeMap,
+{
+ type Ok = ();
+
+ type Error = M::Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+ where
+ T: Serialize,
+ {
+ // Serialize to a Content type first
+ let value: Content = value.serialize(ContentSerializer::new(self.is_human_readable))?;
+ if let Content::TupleStruct(_name, fields) = &mut self.content {
+ fields.push(value);
+ }
+ Ok(())
+ }
+
+ fn end(self) -> Result<Self::Ok, Self::Error> {
+ self.delegate.serialize_entry(&self.variant, &self.content)
+ }
+}
+
+// Below is deserialization code
+
+/// Deserialize the sequence of enum instances.
+///
+/// The main [`Deserializer`] implementation handles the outer sequence (e.g., `Vec`), while the [`SeqAccess`] implementation is responsible for the inner elements.
+struct SeqDeserializer<M>(M);
+
+impl<'de, M> Deserializer<'de> for SeqDeserializer<M>
+where
+ M: MapAccess<'de>,
+{
+ type Error = M::Error;
+
+ fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_seq(self)
+ }
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+impl<'de, M> SeqAccess<'de> for SeqDeserializer<M>
+where
+ M: MapAccess<'de>,
+{
+ type Error = M::Error;
+
+ fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match seed.deserialize(EnumDeserializer(&mut self.0)) {
+ Ok(value) => Ok(Some(value)),
+ Err(err) => {
+ // Unfortunately we loose the optional aspect of MapAccess, so we need to special case an error value to mark the end of the map.
+ if err.to_string().contains(END_OF_MAP_IDENTIFIER) {
+ Ok(None)
+ } else {
+ Err(err)
+ }
+ }
+ }
+ }
+
+ fn size_hint(&self) -> Option<usize> {
+ self.0.size_hint()
+ }
+}
+
+/// Deserialize an enum from a map element
+///
+/// The [`Deserializer`] implementation is the starting point, which first calls the [`EnumAccess`] methods.
+/// The [`EnumAccess`] is used to deserialize the enum variant type of the enum.
+/// The [`VariantAccess`] is used to deserialize the value part of the enum.
+struct EnumDeserializer<M>(M);
+
+impl<'de, M> Deserializer<'de> for EnumDeserializer<M>
+where
+ M: MapAccess<'de>,
+{
+ type Error = M::Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_enum("", &[], visitor)
+ }
+
+ fn deserialize_enum<V>(
+ self,
+ _name: &'static str,
+ _variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_enum(self)
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct identifier ignored_any
+ }
+}
+
+impl<'de, M> EnumAccess<'de> for EnumDeserializer<M>
+where
+ M: MapAccess<'de>,
+{
+ type Error = M::Error;
+ type Variant = Self;
+
+ fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.0.next_key_seed(seed)? {
+ Some(key) => Ok((key, self)),
+
+ // Unfortunately we loose the optional aspect of MapAccess, so we need to special case an error value to mark the end of the map.
+ None => Err(Error::custom(END_OF_MAP_IDENTIFIER)),
+ }
+ }
+}
+
+impl<'de, M> VariantAccess<'de> for EnumDeserializer<M>
+where
+ M: MapAccess<'de>,
+{
+ type Error = M::Error;
+
+ fn unit_variant(mut self) -> Result<(), Self::Error> {
+ self.0.next_value()
+ }
+
+ fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ self.0.next_value_seed(seed)
+ }
+
+ fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.0.next_value_seed(SeedTupleVariant { len, visitor })
+ }
+
+ fn struct_variant<V>(
+ mut self,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.0.next_value_seed(SeedStructVariant { visitor })
+ }
+}
+
+struct SeedTupleVariant<V> {
+ len: usize,
+ visitor: V,
+}
+
+impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
+where
+ V: Visitor<'de>,
+{
+ type Value = V::Value;
+
+ fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_tuple(self.len, self.visitor)
+ }
+}
+
+struct SeedStructVariant<V> {
+ visitor: V,
+}
+
+impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
+where
+ V: Visitor<'de>,
+{
+ type Value = V::Value;
+
+ fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_map(self.visitor)
+ }
+}
diff --git a/third_party/rust/serde_with/src/flatten_maybe.rs b/third_party/rust/serde_with/src/flatten_maybe.rs
new file mode 100644
index 0000000000..e012812d5a
--- /dev/null
+++ b/third_party/rust/serde_with/src/flatten_maybe.rs
@@ -0,0 +1,86 @@
+/// Support deserializing from flattened and non-flattened representation
+///
+/// When working with different serialization formats, sometimes it is more idiomatic to flatten
+/// fields, while other formats prefer nesting. Using `#[serde(flatten)]` only the flattened form
+/// is supported.
+///
+/// This helper creates a function, which support deserializing from either the flattened or the
+/// nested form. It gives an error, when both forms are provided. The `flatten` attribute is
+/// required on the field such that the helper works. The serialization format will always be
+/// flattened.
+///
+/// # Examples
+///
+/// ```rust
+/// # use serde::Deserialize;
+/// #
+/// // Setup the types
+/// #[derive(Deserialize, Debug)]
+/// struct S {
+/// #[serde(flatten, deserialize_with = "deserialize_t")]
+/// t: T,
+/// }
+///
+/// #[derive(Deserialize, Debug)]
+/// struct T {
+/// i: i32,
+/// }
+///
+/// // The macro creates custom deserialization code.
+/// // You need to specify a function name and the field name of the flattened field.
+/// serde_with::flattened_maybe!(deserialize_t, "t");
+///
+/// # fn main() {
+/// // Supports both flattened
+/// let j = r#" {"i":1} "#;
+/// assert!(serde_json::from_str::<S>(j).is_ok());
+///
+/// // and non-flattened versions.
+/// let j = r#" {"t":{"i":1}} "#;
+/// assert!(serde_json::from_str::<S>(j).is_ok());
+///
+/// // Ensure that the value is given
+/// let j = r#" {} "#;
+/// assert!(serde_json::from_str::<S>(j).is_err());
+///
+/// // and only occurs once, not multiple times.
+/// let j = r#" {"i":1,"t":{"i":1}} "#;
+/// assert!(serde_json::from_str::<S>(j).is_err());
+/// # }
+/// ```
+#[macro_export]
+macro_rules! flattened_maybe {
+ ($fn:ident, $field:literal) => {
+ fn $fn<'de, T, D>(deserializer: D) -> ::std::result::Result<T, D::Error>
+ where
+ T: $crate::serde::Deserialize<'de>,
+ D: $crate::serde::Deserializer<'de>,
+ {
+ use ::std::{
+ option::Option::{self, None, Some},
+ result::Result::{self, Err, Ok},
+ };
+ use $crate::serde;
+
+ #[derive($crate::serde::Deserialize)]
+ #[serde(crate = "serde")]
+ pub struct Both<T> {
+ #[serde(flatten)]
+ flat: Option<T>,
+ #[serde(rename = $field)]
+ not_flat: Option<T>,
+ }
+
+ let both: Both<T> = $crate::serde::Deserialize::deserialize(deserializer)?;
+ match (both.flat, both.not_flat) {
+ (Some(t), None) | (None, Some(t)) => Ok(t),
+ (None, None) => Err($crate::serde::de::Error::missing_field($field)),
+ (Some(_), Some(_)) => Err($crate::serde::de::Error::custom(concat!(
+ "`",
+ $field,
+ "` is both flattened and not"
+ ))),
+ }
+ }
+ };
+}
diff --git a/third_party/rust/serde_with/src/formats.rs b/third_party/rust/serde_with/src/formats.rs
new file mode 100644
index 0000000000..2d7aaa6965
--- /dev/null
+++ b/third_party/rust/serde_with/src/formats.rs
@@ -0,0 +1,96 @@
+//! Specify the format and how lenient the deserialization is
+
+use alloc::string::String;
+
+/// Specify how to serialize/deserialize a type
+///
+/// The format specifier allows to configure how a value is serialized/deserialized.
+/// For example, you can serialize a timestamp as an integer using the UNIX epoch, as a string containing an integer, or as a string using ISO 8601.
+/// This [`Format`] traits allows more flexibility in configuring the format without the need to create a new type for each case.
+pub trait Format {}
+
+macro_rules! impl_format {
+ ($(#[$attr:meta] $t:ty)*) => {
+ $(
+ #[$attr]
+ impl Format for $t {}
+ )*
+ };
+}
+macro_rules! create_format {
+ ($(#[$attr:meta] $t:ident)*) => {
+ $(
+ #[$attr]
+ #[derive(Copy, Clone, Debug, Default)]
+ pub struct $t;
+ impl_format!(#[$attr] $t);
+ )*
+ };
+}
+impl_format!(
+ /// Serialize into an i8
+ i8
+ /// Serialize into a u8
+ u8
+ /// Serialize into an i16
+ i16
+ /// Serialize into a u16
+ u16
+ /// Serialize into an i32
+ i32
+ /// Serialize into a u32
+ u32
+ /// Serialize into an i64
+ i64
+ /// Serialize into a u64
+ u64
+
+ /// Serialize into a f32
+ f32
+ /// Serialize into a f64
+ f64
+
+ /// Serialize into a bool
+ bool
+
+ /// Serialize into a String
+ String
+);
+serde::serde_if_integer128!(impl_format!(
+ /// Serialize into an i128
+ i128
+ /// Serialize into a u128
+ u128
+););
+
+create_format!(
+ /// Use uppercase characters
+ Uppercase
+ /// Use lowercase characters
+ Lowercase
+
+ /// Use in combination with [`OneOrMany`](crate::OneOrMany). Emit single element for lists of size 1.
+ PreferOne
+ /// Use in combination with [`OneOrMany`](crate::OneOrMany). Always emit the list form.
+ PreferMany
+
+ /// Emit padding during serialization.
+ Padded
+ /// Do not emit padding during serialization.
+ Unpadded
+);
+
+/// Specify how lenient the deserialization process should be
+///
+/// Formats which make use of this trait should specify how it affects the deserialization behavior.
+pub trait Strictness {}
+
+/// Use strict deserialization behavior, see [`Strictness`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Strict;
+impl Strictness for Strict {}
+
+/// Use a flexible deserialization behavior, see [`Strictness`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Flexible;
+impl Strictness for Flexible {}
diff --git a/third_party/rust/serde_with/src/guide.md b/third_party/rust/serde_with/src/guide.md
new file mode 100644
index 0000000000..9eb80dd915
--- /dev/null
+++ b/third_party/rust/serde_with/src/guide.md
@@ -0,0 +1,144 @@
+# `serde_with` User Guide
+
+This crate provides helper functions to extend and change how [`serde`] serializes different data types.
+For example, you can serialize [a map as a sequence of tuples][crate::guide::serde_as#maps-to-vec-of-tuples], serialize [using the `Display` and `FromStr` traits][`DisplayFromStr`], or serialize [an empty `String` like `None`][NoneAsEmptyString].
+`serde_with` covers types from the Rust Standard Library and some common crates like [`chrono`][serde_with_chrono].
+
+[**A list of all supported transformations is available on this page.**](crate::guide::serde_as_transformations)
+
+The crate offers four types of functionality.
+
+## 1. A more flexible and composable replacement for the with annotation, called `serde_as` *(v1.5.0+)*
+
+This is an alternative to [serde's with-annotation][with-annotation], which adds flexibility and composability to the scheme.
+The main downside is that it work with fewer types than [with-annotations][with-annotation].
+However, all types from the Rust Standard Library should be supported in all combinations and any missing entry is a bug.
+
+The `serde_as` scheme is based on two new traits: [`SerializeAs`] and [`DeserializeAs`].
+[Check out the detailed page about `serde_as` and the available features.](crate::guide::serde_as)
+
+### Example
+
+```rust
+# use serde::{Deserialize, Serialize};
+# use serde_with::{serde_as, DisplayFromStr};
+# use std::collections::HashMap;
+# use std::net::Ipv4Addr;
+#
+#[serde_as]
+# #[derive(Debug, PartialEq, Eq)]
+#[derive(Deserialize, Serialize)]
+struct Data {
+ // Type does not implement Serialize or Deserialize
+ #[serde_as(as = "DisplayFromStr")]
+ address: Ipv4Addr,
+ // Treat the Vec like a map with duplicates
+ // Convert u32 into a String and keep the String the same type
+ #[serde_as(as = "HashMap<DisplayFromStr, _>")]
+ vec_as_map: Vec<(u32, String)>,
+}
+
+let data = Data {
+ address: Ipv4Addr::new(192, 168, 0, 1),
+ vec_as_map: vec![
+ (123, "Hello".into()),
+ (456, "World".into()),
+ (123, "Hello".into()),
+ ],
+};
+
+let json = r#"{
+ "address": "192.168.0.1",
+ "vec_as_map": {
+ "123": "Hello",
+ "456": "World",
+ "123": "Hello"
+ }
+}"#;
+
+// Test Serialization
+assert_eq!(json, serde_json::to_string_pretty(&data).unwrap());
+// Test Deserialization
+assert_eq!(data, serde_json::from_str(json).unwrap());
+```
+
+## 2. Integration with serde's with-annotation
+
+[serde's with-annotation][with-annotation] allows specifying a different serialization or deserialization function for a field.
+It is useful to adapt the serialization of existing types to the requirements of a protocol.
+Most modules in this crate can be used together with the with-annotation.
+
+The annotation approach has one big drawback, in that it is very inflexible.
+It allows specifying arbitrary serialization code, but the code has to perform the correct transformations.
+It is not possible to combine multiple of those functions.
+One common use case for this is the serialization of collections like `Vec`.
+If you have a field of type `T`, you can apply the with-annotation, but if you have a field of type `Vec<T>`, there is no way to re-use the same functions for the with-annotation.
+This inflexibility is fixed in the `serde_as` scheme presented above.
+
+The example shows a similar setup as in the `serde_as` example above, but using the with-annotation.
+
+### Example
+
+```rust
+# use serde::{Deserialize, Serialize};
+# use std::net::Ipv4Addr;
+#
+# #[derive(Debug, PartialEq, Eq)]
+#[derive(Deserialize, Serialize)]
+struct Data {
+ // Type does not implement Serialize or Deserialize
+ #[serde(with = "serde_with::rust::display_fromstr")]
+ address: Ipv4Addr,
+ // Treat the Vec like a map with duplicates
+ #[serde(with = "serde_with::rust::tuple_list_as_map")]
+ vec_as_map: Vec<(String, u32)>,
+}
+
+let data = Data {
+ address: Ipv4Addr::new(192, 168, 0, 1),
+ vec_as_map: vec![
+ ("Hello".into(), 123),
+ ("World".into(), 456),
+ ("Hello".into(), 123),
+ ],
+};
+
+let json = r#"{
+ "address": "192.168.0.1",
+ "vec_as_map": {
+ "Hello": 123,
+ "World": 456,
+ "Hello": 123
+ }
+}"#;
+
+// Test Serialization
+assert_eq!(json, serde_json::to_string_pretty(&data).unwrap());
+// Test Deserialization
+assert_eq!(data, serde_json::from_str(json).unwrap());
+```
+
+## 3. proc-macros to make it easier to use both above parts
+
+The proc-macros are an optional addition and improve the user experience for common tasks.
+We have already seen how the `serde_as` attribute is used to define the serialization instructions.
+
+The proc-macro attributes are defined in the [`serde_with_macros`] crate and re-exported from the root of this crate.
+The proc-macros are optional, but enabled by default.
+For further details, please refer to the documentation of each proc-macro.
+
+## 4. Derive macros to implement `Deserialize` and `Serialize`
+
+The derive macros work similar to the serde provided ones, but they do implement other de/serialization schemes.
+For example, the derives [`DeserializeFromStr`] and [`SerializeDisplay`] require that the type also implement [`FromStr`] and [`Display`] and de/serializes from/to a string instead of the usual way of iterating over all fields.
+
+## Migrating from the with-annotations to `serde_as`
+
+Each old style module explains how it can be converted to `serde_as`.
+Not all modules have such a description since not all are migrated and some are hard to implement in the `serde_as` system.
+
+[`Display`]: std::fmt::Display
+[`FromStr`]: std::str::FromStr
+[`serde_with_macros`]: serde_with_macros
+[serde_with_chrono]: crate::chrono
+[with-annotation]: https://serde.rs/field-attrs.html#with
diff --git a/third_party/rust/serde_with/src/guide/feature_flags.md b/third_party/rust/serde_with/src/guide/feature_flags.md
new file mode 100644
index 0000000000..9e80177ad2
--- /dev/null
+++ b/third_party/rust/serde_with/src/guide/feature_flags.md
@@ -0,0 +1,62 @@
+# Available Feature Flags
+
+This crate has the following features which can be enabled.
+Each entry will explain the feature in more detail.
+
+1. [`base64`](#base64)
+2. [`chrono`](#chrono)
+3. [`guide`](#guide)
+4. [`hex`](#hex)
+5. [`indexmap`](#indexmap)
+6. [`json`](#json)
+7. [`macros`](#macros)
+8. [`time_0_3`](#time_0_3)
+
+## `base64`
+
+The `base64` feature enables serializing data in base64 format.
+
+This pulls in `base64` as a dependency.
+
+## `chrono`
+
+The `chrono` feature enables integration of `chrono` specific conversions.
+This includes support for the timestamp and duration types.
+
+This pulls in `chrono` as a dependency.
+
+## `guide`
+
+The `guide` feature enables inclusion of this user guide.
+The feature only changes the rustdoc output and enables no other effects.
+
+## `hex`
+
+The `hex` feature enables serializing data in hex format.
+
+This pulls in `hex` as a dependency.
+
+## `indexmap`
+
+The `indexmap` feature enables implementations of `indexmap` specific checks.
+This includes support for checking duplicate keys
+
+## `json`
+
+The `json` features enables JSON conversions from the `json` module.
+
+This pulls in `serde_json` as a dependency.
+
+## `macros`
+
+The `macros` features enables all helper macros and derives.
+It is enabled by default, since the macros provide a usability benefit, especially for `serde_as`.
+
+This pulls in `serde_with_macros` as a dependency.
+
+## `time_0_3`
+
+The `time_0_3` enables integration of `time` v0.3 specific conversions.
+This includes support for the timestamp and duration types.
+
+This pulls in `time` v0.3 as a dependency.
diff --git a/third_party/rust/serde_with/src/guide/serde_as.md b/third_party/rust/serde_with/src/guide/serde_as.md
new file mode 100644
index 0000000000..76275f0047
--- /dev/null
+++ b/third_party/rust/serde_with/src/guide/serde_as.md
@@ -0,0 +1,332 @@
+# `serde_as` Annotation
+
+This is an alternative to serde's with-annotation.
+It is more flexible and composable, but work with fewer types.
+
+The scheme is based on two new traits, [`SerializeAs`] and [`DeserializeAs`], which need to be implemented by all types which want to be compatible with `serde_as`.
+The proc-macro attribute [`#[serde_as]`][crate::serde_as] exists as a usability boost for users.
+The basic design of `serde_as` was developed by [@markazmierczak](https://github.com/markazmierczak).
+
+This page contains some general advice on the usage of `serde_as` and on implementing the necessary traits.
+[**A list of all supported transformations enabled by `serde_as` is available on this page.**](crate::guide::serde_as_transformations)
+
+1. [Switching from serde's with to `serde_as`](#switching-from-serdes-with-to-serde_as)
+ 1. [Deserializing Optional Fields](#deserializing-optional-fields)
+ 2. [Gating `serde_as` on Features](#gating-serde_as-on-features)
+2. [Implementing `SerializeAs` / `DeserializeAs`](#implementing-serializeas--deserializeas)
+ 1. [Using `#[serde_as]` on types without `SerializeAs` and `Serialize` implementations](#using-serde_as-on-types-without-serializeas-and-serialize-implementations)
+ 2. [Using `#[serde_as]` with serde's remote derives](#using-serde_as-with-serdes-remote-derives)
+3. [Re-exporting `serde_as`](#re-exporting-serde_as)
+
+## Switching from serde's with to `serde_as`
+
+For the user, the main difference is that instead of
+
+```rust,ignore
+#[serde(with = "...")]
+```
+
+you now have to write
+
+```rust,ignore
+#[serde_as(as = "...")]
+```
+
+and place the `#[serde_as]` attribute *before* the `#[derive]` attribute.
+You still need the `#[derive(Serialize, Deserialize)]` on the struct/enum.
+
+All together, this looks like:
+
+```rust
+use serde::{Deserialize, Serialize};
+use serde_with::{serde_as, DisplayFromStr};
+
+#[serde_as]
+#[derive(Serialize, Deserialize)]
+struct A {
+ #[serde_as(as = "DisplayFromStr")]
+ mime: mime::Mime,
+}
+```
+
+The main advantage is that you can compose `serde_as` stuff, which is impossible with the with-annotation.
+For example, the `mime` field from above could be nested in one or more data structures:
+
+```rust
+# use std::collections::BTreeMap;
+# use serde::{Deserialize, Serialize};
+# use serde_with::{serde_as, DisplayFromStr};
+#
+#[serde_as]
+#[derive(Serialize, Deserialize)]
+struct A {
+ #[serde_as(as = "Option<BTreeMap<_, Vec<DisplayFromStr>>>")]
+ mime: Option<BTreeMap<String, Vec<mime::Mime>>>,
+}
+```
+
+### Deserializing Optional Fields
+
+During deserialization, serde treats fields of `Option<T>` as optional and does not require them to be present.
+This breaks when adding either the `serde_as` annotation or serde's `with` annotation.
+The default behavior can be restored by adding serde's `default` attribute.
+
+```rust
+# use serde::{Deserialize, Serialize};
+# use serde_with::{serde_as, DisplayFromStr};
+#
+#[serde_as]
+#[derive(Serialize, Deserialize)]
+struct A {
+ #[serde_as(as = "Option<DisplayFromStr>")]
+ // Allows deserialization without providing a value for `val`
+ #[serde(default)]
+ val: Option<u32>,
+}
+```
+
+In the future, this behavior might change and `default` would be applied on `Option<T>` fields.
+You can add your feedback at [serde_with#185].
+
+### Gating `serde_as` on Features
+
+Gating `serde_as` behind optional features is currently not supported.
+More details can be found in the corresponding issue [serde_with#355].
+
+```rust,ignore
+#[cfg_attr(feature="serde" ,serde_as)]
+#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
+struct StructC {
+ #[cfg_attr(feature="serde" ,serde_as(as = "Vec<(_, _)>"))]
+ map: HashMap<(i32,i32), i32>,
+}
+```
+
+The `serde_as` proc-macro attribute will not recognize the `serde_as` attribute on the field and will not perform the necessary translation steps.
+The problem can be avoided by forcing Rust to evaluate all cfg-expressions before running `serde_as`.
+This is possible with the `#[cfg_eval]` attribute, which is considered for stabilization ([rust#82679], [rust#87221]).
+
+As a workaround, it is possible to remove the `serde_as` proc-macro attribute and perform the transformation manually.
+The transformation steps are listed in the [`serde_as`] documentations.
+For the example above, this means to replace the field attribute with:
+
+```rust,ignore
+use serde_with::{As, Same};
+
+#[cfg_attr(feature="serde", serde(with = "As::<Vec<(Same, Same)>>"))]
+map: HashMap<(i32,i32), i32>,
+```
+
+[rust#82679]: https://github.com/rust-lang/rust/issues/82679
+[rust#87221]: https://github.com/rust-lang/rust/pull/87221
+[serde_with#355]: https://github.com/jonasbb/serde_with/issues/355
+
+## Implementing `SerializeAs` / `DeserializeAs`
+
+You can support [`SerializeAs`] / [`DeserializeAs`] on your own types too.
+Most "leaf" types do not need to implement these traits, since they are supported implicitly.
+"Leaf" type refers to types which directly serialize like plain data types.
+[`SerializeAs`] / [`DeserializeAs`] is very important for collection types, like `Vec` or `BTreeMap`, since they need special handling for the key/value de/serialization such that the conversions can be done on the key/values.
+You also find them implemented on the conversion types, such as the [`DisplayFromStr`] type.
+These make up the bulk of this crate and allow you to perform all the nice conversions to [hex strings], the [bytes to string converter], or [duration to UNIX epoch].
+
+In many cases, conversion is only required from one serializable type to another one, without requiring the full power of the `Serialize` or `Deserialize` traits.
+In these cases, the [`serde_conv!`] macro conveniently allows defining conversion types without the boilerplate.
+The documentation of [`serde_conv!`] contains more details how to use it.
+
+The trait documentations for [`SerializeAs`] and [`DeserializeAs`] describe in details how to implement them for container types like `Box` or `Vec` and other types.
+
+### Using `#[serde_as]` on types without `SerializeAs` and `Serialize` implementations
+
+The `SerializeAs` and `DeserializeAs` traits can easily be used together with types from other crates without running into orphan rule problems.
+This is a distinct advantage of the `serde_as` system.
+For this example we assume we have a type `RemoteType` from a dependency which does not implement `Serialize` nor `SerializeAs`.
+We assume we have a module containing a `serialize` and a `deserialize` function, which can be used in the `#[serde(with = "MODULE")]` annotation.
+You find an example in the [official serde documentation](https://serde.rs/custom-date-format.html).
+
+Our goal is to serialize this `Data` struct.
+Right now, we do not have anything we can use to replace `???` with, since `_` only works if `RemoteType` would implement `Serialize`, which it does not.
+
+```rust
+# #[cfg(FALSE)] {
+#[serde_as]
+#[derive(serde::Serialize)]
+struct Data {
+ #[serde_as(as = "Vec<???>")]
+ vec: Vec<RemoteType>,
+}
+# }
+```
+
+We need to create a new type for which we can implement `SerializeAs`, to replace the `???`.
+The `SerializeAs` implementation is **always** written for a local type.
+This allows it to seamlessly work with types from dependencies without running into orphan rule problems.
+
+```rust
+# #[cfg(FALSE)] {
+struct LocalType;
+
+impl SerializeAs<RemoteType> for LocalType {
+ fn serialize_as<S>(value: &RemoteType, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ MODULE::serialize(value, serializer)
+ }
+}
+
+impl<'de> DeserializeAs<'de, RemoteType> for LocalType {
+ fn deserialize_as<D>(deserializer: D) -> Result<RemoteType, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ MODULE::deserialize(deserializer)
+ }
+}
+# }
+```
+
+This is how the final implementation looks like.
+We assumed we have a module `MODULE` with a `serialize` function already, which we use here to provide the implementation.
+As can be seen, this is mostly boilerplate, since the most part is encapsulated in `$module::serialize`.
+The final `Data` struct will now look like:
+
+```rust
+# #[cfg(FALSE)] {
+#[serde_as]
+#[derive(serde::Serialize)]
+struct Data {
+ #[serde_as(as = "Vec<LocalType>")]
+ vec: Vec<RemoteType>,
+}
+# }
+```
+
+### Using `#[serde_as]` with serde's remote derives
+
+A special case of the above section is using it on remote derives.
+This is a special functionality of serde, where it derives the de/serialization code for a type from another crate if all fields are `pub`.
+You can find all the details in the [official serde documentation](https://serde.rs/remote-derive.html).
+
+```rust
+# #[cfg(FALSE)] {
+// Pretend that this is somebody else's crate, not a module.
+mod other_crate {
+ // Neither Serde nor the other crate provides Serialize and Deserialize
+ // impls for this struct.
+ pub struct Duration {
+ pub secs: i64,
+ pub nanos: i32,
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+use other_crate::Duration;
+
+// Serde calls this the definition of the remote type. It is just a copy of the
+// remote data structure. The `remote` attribute gives the path to the actual
+// type we intend to derive code for.
+#[derive(serde::Serialize, serde::Deserialize)]
+#[serde(remote = "Duration")]
+struct DurationDef {
+ secs: i64,
+ nanos: i32,
+}
+# }
+```
+
+Our goal is now to use `Duration` within `serde_as`.
+We use the existing `DurationDef` type and its `serialize` and `deserialize` functions.
+We can write this implementation.
+The implementation for `DeserializeAs` works analogue.
+
+```rust
+# #[cfg(FALSE)] {
+impl SerializeAs<Duration> for DurationDef {
+ fn serialize_as<S>(value: &Duration, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ DurationDef::serialize(value, serializer)
+ }
+}
+# }
+```
+
+This now allows us to use `Duration` for serialization.
+
+```rust
+# #[cfg(FALSE)] {
+use other_crate::Duration;
+
+#[serde_as]
+#[derive(serde::Serialize)]
+struct Data {
+ #[serde_as(as = "Vec<DurationDef>")]
+ vec: Vec<Duration>,
+}
+# }
+```
+
+## Re-exporting `serde_as`
+
+If `serde_as` is being used in a context where the `serde_with` crate is not available from the root
+path, but is re-exported at some other path, the `crate = "..."` attribute argument should be used
+to specify its path. This may be the case if `serde_as` is being used in a procedural macro -
+otherwise, users of that macro would need to add `serde_with` to their own Cargo manifest.
+
+The `crate` argument will generally be used in conjunction with [`serde`'s own `crate` argument].
+
+For example, a type definition may be defined in a procedural macro:
+
+```rust,ignore
+// some_other_lib_derive/src/lib.rs
+
+use proc_macro::TokenStream;
+use quote::quote;
+
+#[proc_macro]
+pub fn define_some_type(_item: TokenStream) -> TokenStream {
+ let def = quote! {
+ #[serde(crate = "::some_other_lib::serde")]
+ #[::some_other_lib::serde_with::serde_as(crate = "::some_other_lib::serde_with")]
+ #[derive(::some_other_lib::serde::Deserialize)]
+ struct Data {
+ #[serde_as(as = "_")]
+ a: u32,
+ }
+ };
+
+ TokenStream::from(def)
+}
+```
+
+This can be re-exported through a library which also re-exports `serde` and `serde_with`:
+
+```rust,ignore
+// some_other_lib/src/lib.rs
+
+pub use serde;
+pub use serde_with;
+pub use some_other_lib_derive::define_some_type;
+```
+
+The procedural macro can be used by other crates without any additional imports:
+
+```rust,ignore
+// consuming_crate/src/main.rs
+
+some_other_lib::define_some_type!();
+```
+
+[`DeserializeAs`]: crate::DeserializeAs
+[`DisplayFromStr`]: crate::DisplayFromStr
+[`serde_as`]: crate::serde_as
+[`serde_conv!`]: crate::serde_conv!
+[`serde`'s own `crate` argument]: https://serde.rs/container-attrs.html#crate
+[`SerializeAs`]: crate::SerializeAs
+[bytes to string converter]: crate::BytesOrString
+[duration to UNIX epoch]: crate::DurationSeconds
+[hex strings]: crate::hex::Hex
+[serde_with#185]: https://github.com/jonasbb/serde_with/issues/185
diff --git a/third_party/rust/serde_with/src/guide/serde_as_transformations.md b/third_party/rust/serde_with/src/guide/serde_as_transformations.md
new file mode 100644
index 0000000000..9be67e154b
--- /dev/null
+++ b/third_party/rust/serde_with/src/guide/serde_as_transformations.md
@@ -0,0 +1,518 @@
+# De/Serialize Transformations Available
+
+This page lists the transformations implemented in this crate and supported by `serde_as`.
+
+1. [Base64 encode bytes](#base64-encode-bytes)
+2. [Big Array support](#big-array-support)
+3. [`bool` from integer](#bool-from-integer)
+4. [Borrow from the input for `Cow` type](#borrow-from-the-input-for-cow-type)
+5. [`Bytes` with more efficiency](#bytes-with-more-efficiency)
+6. [Convert to an intermediate type using `Into`](#convert-to-an-intermediate-type-using-into)
+7. [Convert to an intermediate type using `TryInto`](#convert-to-an-intermediate-type-using-tryinto)
+8. [`Default` from `null`](#default-from-null)
+9. [De/Serialize into `Vec`, ignoring errors](#deserialize-into-vec-ignoring-errors)
+10. [De/Serialize with `FromStr` and `Display`](#deserialize-with-fromstr-and-display)
+11. [`Duration` as seconds](#duration-as-seconds)
+12. [Hex encode bytes](#hex-encode-bytes)
+13. [Ignore deserialization errors](#ignore-deserialization-errors)
+14. [`Maps` to `Vec` of enums](#maps-to-vec-of-enums)
+15. [`Maps` to `Vec` of tuples](#maps-to-vec-of-tuples)
+16. [`NaiveDateTime` like UTC timestamp](#naivedatetime-like-utc-timestamp)
+17. [`None` as empty `String`](#none-as-empty-string)
+18. [One or many elements into `Vec`](#one-or-many-elements-into-vec)
+19. [Pick first successful deserialization](#pick-first-successful-deserialization)
+20. [Timestamps as seconds since UNIX epoch](#timestamps-as-seconds-since-unix-epoch)
+21. [Value into JSON String](#value-into-json-string)
+22. [`Vec` of tuples to `Maps`](#vec-of-tuples-to-maps)
+23. [Well-known time formats for `OffsetDateTime`](#well-known-time-formats-for-offsetdatetime)
+
+## Base64 encode bytes
+
+[`Base64`]
+
+Requires the `base64` feature.
+The character set and padding behavior can be configured.
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::base64::Base64")]
+value: Vec<u8>,
+#[serde_as(as = "Base64<Bcrypt, Unpadded>")]
+bcrypt_unpadded: Vec<u8>,
+
+// JSON
+"value": "SGVsbG8gV29ybGQ=",
+"bcrypt_unpadded": "QETqZE6eT07wZEO",
+```
+
+## Big Array support
+
+Support for arrays of arbitrary size.
+
+```ignore
+// Rust
+#[serde_as(as = "[[_; 64]; 33]")]
+value: [[u8; 64]; 33],
+
+// JSON
+"value": [[0,0,0,0,0,...], [0,0,0,...], ...],
+```
+
+## `bool` from integer
+
+Deserialize an integer and convert it into a `bool`.
+[`BoolFromInt<Strict>`] (default) deserializes 0 to `false` and `1` to `true`, other numbers are errors.
+[`BoolFromInt<Flexible>`] deserializes any non-zero as `true`.
+Serialization only emits 0/1.
+
+```ignore
+// Rust
+#[serde_as(as = "BoolFromInt")] // BoolFromInt<Strict>
+b: bool,
+
+// JSON
+"b": 1,
+```
+
+## Borrow from the input for `Cow` type
+
+The types `Cow<'_, str>`, `Cow<'_, [u8]>`, or `Cow<'_, [u8; N]>` can borrow from the input, avoiding extra copies.
+
+```ignore
+// Rust
+#[serde_as(as = "BorrowCow")]
+value: Cow<'a, str>,
+
+// JSON
+"value": "foobar",
+```
+
+## `Bytes` with more efficiency
+
+[`Bytes`]
+
+More efficient serialization for byte slices and similar.
+
+```ignore
+// Rust
+#[serde_as(as = "Bytes")]
+value: Vec<u8>,
+
+// JSON
+"value": [0, 1, 2, 3, ...],
+```
+
+## Convert to an intermediate type using `Into`
+
+[`FromInto`]
+
+```ignore
+// Rust
+#[serde_as(as = "FromInto<(u8, u8, u8)>")]
+value: Rgb,
+
+impl From<(u8, u8, u8)> for Rgb { ... }
+impl From<Rgb> for (u8, u8, u8) { ... }
+
+// JSON
+"value": [128, 64, 32],
+```
+
+## Convert to an intermediate type using `TryInto`
+
+[`TryFromInto`]
+
+```ignore
+// Rust
+#[serde_as(as = "TryFromInto<i8>")]
+value: u8,
+
+// JSON
+"value": 127,
+```
+
+## `Default` from `null`
+
+[`DefaultOnNull`]
+
+```ignore
+// Rust
+#[serde_as(as = "DefaultOnNull")]
+value: u32,
+#[serde_as(as = "DefaultOnNull<DisplayFromStr>")]
+value2: u32,
+
+// JSON
+"value": 123,
+"value2": "999",
+
+// Deserializes null into the Default value, i.e.,
+null => 0
+```
+
+## De/Serialize into `Vec`, ignoring errors
+
+[`VecSkipError`]
+
+For formats with heterogenous-typed sequences, we can collect only the deserializable elements.
+This is also useful for unknown enum variants.
+
+```ignore
+#[derive(serde::Deserialize)]
+enum Color {
+ Red,
+ Green,
+ Blue,
+}
+
+// JSON
+"colors": ["Blue", "Yellow", "Green"],
+
+// Rust
+#[serde_as(as = "VecSkipError<_>")]
+colors: Vec<Color>,
+
+// => vec![Blue, Green]
+```
+
+## De/Serialize with `FromStr` and `Display`
+
+Useful if a type implements `FromStr` / `Display` but not `Deserialize` / `Serialize`.
+
+[`DisplayFromStr`]
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::DisplayFromStr")]
+value: u128,
+#[serde_as(as = "serde_with::DisplayFromStr")]
+mime: mime::Mime,
+
+// JSON
+"value": "340282366920938463463374607431768211455",
+"mime": "text/*",
+```
+
+## `Duration` as seconds
+
+[`DurationSeconds`]
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::DurationSeconds<u64>")]
+value: Duration,
+
+// JSON
+"value": 86400,
+```
+
+[`DurationSecondsWithFrac`] supports subsecond precision:
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::DurationSecondsWithFrac<f64>")]
+value: Duration,
+
+// JSON
+"value": 1.234,
+```
+
+Different serialization formats are possible:
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::DurationSecondsWithFrac<String>")]
+value: Duration,
+
+// JSON
+"value": "1.234",
+```
+
+The same conversions are also implemented for [`chrono::Duration`] with the `chrono` feature.
+
+The same conversions are also implemented for [`time::Duration`] with the `time_0_3` feature.
+
+## Hex encode bytes
+
+[`Hex`]
+
+Requires the `hex` feature.
+The hex string can use upper- and lowercase characters.
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::hex::Hex")]
+lowercase: Vec<u8>,
+#[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Uppercase>")]
+uppercase: Vec<u8>,
+
+// JSON
+"lowercase": "deadbeef",
+"uppercase": "DEADBEEF",
+```
+
+## Ignore deserialization errors
+
+Check the documentation for [`DefaultOnError`].
+
+## `Maps` to `Vec` of enums
+
+[`EnumMap`]
+
+Combine multiple enum values into a single map.
+The key is the enum variant name, and the value is the variant value.
+This only works with [*externally tagged*] enums, the default enum representation.
+Other forms cannot be supported.
+
+```ignore
+enum EnumValue {
+ Int(i32),
+ String(String),
+ Unit,
+ Tuple(i32, String),
+ Struct {
+ a: i32,
+ b: String,
+ },
+}
+
+// Rust
+struct VecEnumValues (
+ #[serde_as(as = "EnumMap")]
+ Vec<EnumValue>,
+);
+
+VecEnumValues(vec![
+ EnumValue::Int(123),
+ EnumValue::String("Foo".to_string()),
+ EnumValue::Unit,
+ EnumValue::Tuple(1, "Bar".to_string()),
+ EnumValue::Struct {
+ a: 666,
+ b: "Baz".to_string(),
+ },
+])
+
+// JSON
+{
+ "Int": 123,
+ "String": "Foo",
+ "Unit": null,
+ "Tuple": [
+ 1,
+ "Bar",
+ ],
+ "Struct": {
+ "a": 666,
+ "b": "Baz",
+ }
+}
+```
+
+[*externally tagged*]: https://serde.rs/enum-representations.html#externally-tagged
+
+## `Maps` to `Vec` of tuples
+
+```ignore
+// Rust
+#[serde_as(as = "Vec<(_, _)>")]
+value: HashMap<String, u32>, // also works with BTreeMap
+
+// JSON
+"value": [
+ ["hello", 1],
+ ["world", 2]
+],
+```
+
+The [inverse operation](#vec-of-tuples-to-maps) is also available.
+
+## `NaiveDateTime` like UTC timestamp
+
+Requires the `chrono` feature.
+
+```ignore
+// Rust
+#[serde_as(as = "chrono::DateTime<chrono::Utc>")]
+value: chrono::NaiveDateTime,
+
+// JSON
+"value": "1994-11-05T08:15:30Z",
+ ^ Pretend DateTime is UTC
+```
+
+## `None` as empty `String`
+
+[`NoneAsEmptyString`]
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::NoneAsEmptyString")]
+value: Option<String>,
+
+// JSON
+"value": "", // converts to None
+
+"value": "Hello World!", // converts to Some
+```
+
+## One or many elements into `Vec`
+
+[`OneOrMany`]
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::OneOrMany<_>")]
+value: Vec<String>,
+
+// JSON
+"value": "", // Deserializes single elements
+
+"value": ["Hello", "World!"], // or lists of many
+```
+
+## Pick first successful deserialization
+
+[`PickFirst`]
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::PickFirst<(_, serde_with::DisplayFromStr)>")]
+value: u32,
+
+// JSON
+// serialize into
+"value": 666,
+// deserialize from either
+"value": 666,
+"value": "666",
+```
+
+## Timestamps as seconds since UNIX epoch
+
+[`TimestampSeconds`]
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::TimestampSeconds<i64>")]
+value: SystemTime,
+
+// JSON
+"value": 86400,
+```
+
+[`TimestampSecondsWithFrac`] supports subsecond precision:
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::TimestampSecondsWithFrac<f64>")]
+value: SystemTime,
+
+// JSON
+"value": 1.234,
+```
+
+Different serialization formats are possible:
+
+```ignore
+// Rust
+#[serde_as(as = "serde_with::TimestampSecondsWithFrac<String>")]
+value: SystemTime,
+
+// JSON
+"value": "1.234",
+```
+
+The same conversions are also implemented for [`chrono::DateTime<Utc>`], [`chrono::DateTime<Local>`], and [`chrono::NaiveDateTime`] with the `chrono` feature.
+
+The conversions are availble for [`time::OffsetDateTime`] and [`time::PrimitiveDateTime`] with the `time_0_3` feature enabled.
+
+## Value into JSON String
+
+Some JSON APIs are weird and return a JSON encoded string in a JSON response
+
+[`JsonString`]
+
+Requires the `json` feature.
+
+```ignore
+// Rust
+#[derive(Deserialize, Serialize)]
+struct OtherStruct {
+ value: usize,
+}
+
+#[serde_as(as = "serde_with::json::JsonString")]
+value: OtherStruct,
+
+// JSON
+"value": "{\"value\":5}",
+```
+
+## `Vec` of tuples to `Maps`
+
+```ignore
+// Rust
+#[serde_as(as = "HashMap<_, _>")] // also works with BTreeMap
+value: Vec<(String, u32)>,
+
+// JSON
+"value": {
+ "hello": 1,
+ "world": 2
+},
+```
+
+This operation is also available for other sequence types.
+This includes `BinaryHeap<(K, V)>`, `BTreeSet<(K, V)>`, `HashSet<(K, V)>`, `LinkedList<(K, V)>`, `VecDeque<(K, V)>`, `Option<(K, V)>` and `[(K, V); N]` for all sizes of N.
+
+The [inverse operation](#maps-to-vec-of-tuples) is also available.
+
+## Well-known time formats for `OffsetDateTime`
+
+[`time::OffsetDateTime`] can be serialized in string format in different well-known formats.
+Two formats are supported, [`time::format_description::well_known::Rfc2822`] and [`time::format_description::well_known::Rfc3339`].
+
+```ignore
+// Rust
+#[serde_as(as = "time::format_description::well_known::Rfc2822")]
+rfc_2822: OffsetDateTime,
+#[serde_as(as = "time::format_description::well_known::Rfc3339")]
+rfc_3339: OffsetDateTime,
+
+// JSON
+"rfc_2822": "Fri, 21 Nov 1997 09:55:06 -0600",
+"rfc_3339": "1997-11-21T09:55:06-06:00",
+```
+
+These conversions are availble with the `time_0_3` feature flag.
+
+[`Base64`]: crate::base64::Base64
+[`BoolFromInt<Flexible>`]: crate::BoolFromInt
+[`BoolFromInt<Strict>`]: crate::BoolFromInt
+[`Bytes`]: crate::Bytes
+[`chrono::DateTime<Local>`]: chrono_crate::DateTime
+[`chrono::DateTime<Utc>`]: chrono_crate::DateTime
+[`chrono::Duration`]: https://docs.rs/chrono/latest/chrono/struct.Duration.html
+[`chrono::NaiveDateTime`]: chrono_crate::NaiveDateTime
+[`DefaultOnError`]: crate::DefaultOnError
+[`DefaultOnNull`]: crate::DefaultOnNull
+[`DisplayFromStr`]: crate::DisplayFromStr
+[`DurationSeconds`]: crate::DurationSeconds
+[`DurationSecondsWithFrac`]: crate::DurationSecondsWithFrac
+[`EnumMap`]: crate::EnumMap
+[`FromInto`]: crate::FromInto
+[`Hex`]: crate::hex::Hex
+[`JsonString`]: crate::json::JsonString
+[`NoneAsEmptyString`]: crate::NoneAsEmptyString
+[`OneOrMany`]: crate::OneOrMany
+[`PickFirst`]: crate::PickFirst
+[`time::Duration`]: time_0_3::Duration
+[`time::format_description::well_known::Rfc2822`]: time_0_3::format_description::well_known::Rfc2822
+[`time::format_description::well_known::Rfc3339`]: time_0_3::format_description::well_known::Rfc3339
+[`time::OffsetDateTime`]: time_0_3::OffsetDateTime
+[`time::PrimitiveDateTime`]: time_0_3::PrimitiveDateTime
+[`TimestampSeconds`]: crate::TimestampSeconds
+[`TimestampSecondsWithFrac`]: crate::TimestampSecondsWithFrac
+[`TryFromInto`]: crate::TryFromInto
+[`VecSkipError`]: crate::VecSkipError
diff --git a/third_party/rust/serde_with/src/hex.rs b/third_party/rust/serde_with/src/hex.rs
new file mode 100644
index 0000000000..1937e35394
--- /dev/null
+++ b/third_party/rust/serde_with/src/hex.rs
@@ -0,0 +1,155 @@
+//! De/Serialization of hexadecimal encoded bytes
+//!
+//! This modules is only available when using the `hex` feature of the crate.
+//!
+//! Please check the documentation on the [`Hex`] type for details.
+
+use crate::{
+ de::DeserializeAs,
+ formats::{Format, Lowercase, Uppercase},
+ ser::SerializeAs,
+};
+use alloc::{borrow::Cow, format, vec::Vec};
+use core::{
+ convert::{TryFrom, TryInto},
+ marker::PhantomData,
+};
+use serde::{de::Error, Deserialize, Deserializer, Serializer};
+
+/// Serialize bytes as a hex string
+///
+/// The type serializes a sequence of bytes as a hexadecimal string.
+/// It works on any type implementing `AsRef<[u8]>` for serialization and `TryFrom<Vec<u8>>` for deserialization.
+///
+/// The format type parameter specifies if the hex string should use lower- or uppercase characters.
+/// Valid options are the types [`Lowercase`] and [`Uppercase`].
+/// Deserialization always supports lower- and uppercase characters, even mixed in one string.
+///
+/// # Example
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::serde_as;
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq, Eq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct BytesLowercase(
+/// // Equivalent to serde_with::hex::Hex<serde_with::formats::Lowercase>
+/// #[serde_as(as = "serde_with::hex::Hex")]
+/// Vec<u8>
+/// );
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq, Eq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct BytesUppercase(
+/// #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Uppercase>")]
+/// Vec<u8>
+/// );
+///
+/// let b = b"Hello World!";
+///
+/// // Hex with lowercase letters
+/// assert_eq!(
+/// json!("48656c6c6f20576f726c6421"),
+/// serde_json::to_value(BytesLowercase(b.to_vec())).unwrap()
+/// );
+/// // Hex with uppercase letters
+/// assert_eq!(
+/// json!("48656C6C6F20576F726C6421"),
+/// serde_json::to_value(BytesUppercase(b.to_vec())).unwrap()
+/// );
+///
+/// // Serialization always work from lower- and uppercase characters, even mixed case.
+/// assert_eq!(
+/// BytesLowercase(vec![0x00, 0xaa, 0xbc, 0x99, 0xff]),
+/// serde_json::from_value(json!("00aAbc99FF")).unwrap()
+/// );
+/// assert_eq!(
+/// BytesUppercase(vec![0x00, 0xaa, 0xbc, 0x99, 0xff]),
+/// serde_json::from_value(json!("00aAbc99FF")).unwrap()
+/// );
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq, Eq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct ByteArray(
+/// // Equivalent to serde_with::hex::Hex<serde_with::formats::Lowercase>
+/// #[serde_as(as = "serde_with::hex::Hex")]
+/// [u8; 12]
+/// );
+///
+/// let b = b"Hello World!";
+///
+/// assert_eq!(
+/// json!("48656c6c6f20576f726c6421"),
+/// serde_json::to_value(ByteArray(b.clone())).unwrap()
+/// );
+///
+/// // Serialization always work from lower- and uppercase characters, even mixed case.
+/// assert_eq!(
+/// ByteArray([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0xaa, 0xbc, 0x99, 0xff]),
+/// serde_json::from_value(json!("0011223344556677aAbc99FF")).unwrap()
+/// );
+///
+/// // Remember that the conversion may fail. (The following errors are specific to fixed-size arrays)
+/// let error_result: Result<ByteArray, _> = serde_json::from_value(json!("42")); // Too short
+/// error_result.unwrap_err();
+///
+/// let error_result: Result<ByteArray, _> =
+/// serde_json::from_value(json!("000000000000000000000000000000")); // Too long
+/// error_result.unwrap_err();
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Hex<FORMAT: Format = Lowercase>(PhantomData<FORMAT>);
+
+impl<T> SerializeAs<T> for Hex<Lowercase>
+where
+ T: AsRef<[u8]>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_str(&hex::encode(source))
+ }
+}
+
+impl<T> SerializeAs<T> for Hex<Uppercase>
+where
+ T: AsRef<[u8]>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_str(&hex::encode_upper(source))
+ }
+}
+
+impl<'de, T, FORMAT> DeserializeAs<'de, T> for Hex<FORMAT>
+where
+ T: TryFrom<Vec<u8>>,
+ FORMAT: Format,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ <Cow<'de, str> as Deserialize<'de>>::deserialize(deserializer)
+ .and_then(|s| hex::decode(&*s).map_err(Error::custom))
+ .and_then(|vec: Vec<u8>| {
+ let length = vec.len();
+ vec.try_into().map_err(|_e: T::Error| {
+ Error::custom(format!(
+ "Can't convert a Byte Vector of length {} to the output type.",
+ length
+ ))
+ })
+ })
+ }
+}
diff --git a/third_party/rust/serde_with/src/json.rs b/third_party/rust/serde_with/src/json.rs
new file mode 100644
index 0000000000..699d31c8d2
--- /dev/null
+++ b/third_party/rust/serde_with/src/json.rs
@@ -0,0 +1,150 @@
+//! De/Serialization of JSON
+//!
+//! This modules is only available when using the `json` feature of the crate.
+
+use crate::{de::DeserializeAs, ser::SerializeAs};
+use serde::{de::DeserializeOwned, Deserializer, Serialize, Serializer};
+
+/// Serialize value as string containing JSON
+///
+/// The same functionality is also available as [`serde_with::json::JsonString`][crate::json::JsonString] compatible with the `serde_as`-annotation.
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::json::nested")]
+/// other_struct: B,
+/// }
+/// #[derive(Deserialize, Serialize)]
+/// struct B {
+/// value: usize,
+/// }
+///
+/// let v: A = serde_json::from_str(r#"{"other_struct":"{\"value\":5}"}"#).unwrap();
+/// assert_eq!(5, v.other_struct.value);
+///
+/// let x = A {
+/// other_struct: B { value: 10 },
+/// };
+/// assert_eq!(
+/// r#"{"other_struct":"{\"value\":10}"}"#,
+/// serde_json::to_string(&x).unwrap()
+/// );
+/// ```
+pub mod nested {
+ use core::{fmt, marker::PhantomData};
+ use serde::{
+ de::{DeserializeOwned, Deserializer, Error, Visitor},
+ ser::{self, Serialize, Serializer},
+ };
+
+ /// Deserialize value from a string which is valid JSON
+ pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: DeserializeOwned,
+ {
+ #[derive(Default)]
+ struct Helper<S: DeserializeOwned>(PhantomData<S>);
+
+ impl<'de, S> Visitor<'de> for Helper<S>
+ where
+ S: DeserializeOwned,
+ {
+ type Value = S;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(formatter, "valid json object")
+ }
+
+ fn visit_str<E>(self, value: &str) -> Result<S, E>
+ where
+ E: Error,
+ {
+ serde_json::from_str(value).map_err(Error::custom)
+ }
+ }
+
+ deserializer.deserialize_str(Helper(PhantomData))
+ }
+
+ /// Serialize value as string containing JSON
+ ///
+ /// # Errors
+ ///
+ /// Serialization can fail if `T`'s implementation of `Serialize` decides to
+ /// fail, or if `T` contains a map with non-string keys.
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ let s = serde_json::to_string(value).map_err(ser::Error::custom)?;
+ serializer.serialize_str(&*s)
+ }
+}
+
+/// Serialize value as string containing JSON
+///
+/// The same functionality is also available as [`serde_with::json::nested`][crate::json::nested] compatible with serde's with-annotation.
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{serde_as, json::JsonString};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "JsonString")]
+/// other_struct: B,
+/// }
+/// #[derive(Deserialize, Serialize)]
+/// struct B {
+/// value: usize,
+/// }
+///
+/// let v: A = serde_json::from_str(r#"{"other_struct":"{\"value\":5}"}"#).unwrap();
+/// assert_eq!(5, v.other_struct.value);
+///
+/// let x = A {
+/// other_struct: B { value: 10 },
+/// };
+/// assert_eq!(
+/// r#"{"other_struct":"{\"value\":10}"}"#,
+/// serde_json::to_string(&x).unwrap()
+/// );
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct JsonString;
+
+impl<T> SerializeAs<T> for JsonString
+where
+ T: Serialize,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ crate::json::nested::serialize(source, serializer)
+ }
+}
+
+impl<'de, T> DeserializeAs<'de, T> for JsonString
+where
+ T: DeserializeOwned,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ crate::json::nested::deserialize(deserializer)
+ }
+}
diff --git a/third_party/rust/serde_with/src/lib.rs b/third_party/rust/serde_with/src/lib.rs
new file mode 100644
index 0000000000..6285a6f695
--- /dev/null
+++ b/third_party/rust/serde_with/src/lib.rs
@@ -0,0 +1,2034 @@
+#![warn(
+ clippy::semicolon_if_nothing_returned,
+ missing_copy_implementations,
+ // missing_crate_level_docs, not available in MSRV
+ missing_debug_implementations,
+ missing_docs,
+ rust_2018_idioms,
+ trivial_casts,
+ trivial_numeric_casts,
+ unused_extern_crates,
+ unused_import_braces,
+ unused_qualifications,
+ variant_size_differences
+)]
+#![doc(test(attr(forbid(unsafe_code))))]
+#![doc(test(attr(deny(
+ missing_copy_implementations,
+ missing_debug_implementations,
+ trivial_casts,
+ trivial_numeric_casts,
+ unused_extern_crates,
+ unused_import_braces,
+ unused_qualifications,
+))))]
+#![doc(test(attr(warn(rust_2018_idioms))))]
+// Not needed for 2018 edition and conflicts with `rust_2018_idioms`
+#![doc(test(no_crate_inject))]
+#![doc(html_root_url = "https://docs.rs/serde_with/1.14.0")]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![allow(
+ // clippy is broken and shows wrong warnings
+ // clippy on stable does not know yet about the lint name
+ unknown_lints,
+ // https://github.com/rust-lang/rust-clippy/issues/8560
+ clippy::only_used_in_recursion,
+ // https://github.com/rust-lang/rust-clippy/issues/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+#![no_std]
+
+//! [![crates.io badge](https://img.shields.io/crates/v/serde_with.svg)](https://crates.io/crates/serde_with/)
+//! [![Build Status](https://github.com/jonasbb/serde_with/workflows/Rust%20CI/badge.svg)](https://github.com/jonasbb/serde_with)
+//! [![codecov](https://codecov.io/gh/jonasbb/serde_with/branch/master/graph/badge.svg)](https://codecov.io/gh/jonasbb/serde_with)
+//! [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4322/badge)](https://bestpractices.coreinfrastructure.org/projects/4322)
+//! [![Binder](https://img.shields.io/badge/Try%20on%20-binder-579ACA.svg?logo=data:image/png;base64,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)](https://mybinder.org/v2/gist/jonasbb/18b9aece4c17f617b1c2b3946d29eeb0/HEAD?filepath=serde-with-demo.ipynb)
+//!
+//! ---
+//!
+//! This crate provides custom de/serialization helpers to use in combination with [serde's with-annotation][with-annotation] and with the improved [`serde_as`][as-annotation]-annotation.
+//! Some common use cases are:
+//!
+//! * De/Serializing a type using the `Display` and `FromStr` traits, e.g., for `u8`, `url::Url`, or `mime::Mime`.
+//! Check [`DisplayFromStr`][] or [`serde_with::rust::display_fromstr`][display_fromstr] for details.
+//! * Support for arrays larger than 32 elements or using const generics.
+//! With `serde_as` large arrays are supported, even if they are nested in other types.
+//! `[bool; 64]`, `Option<[u8; M]>`, and `Box<[[u8; 64]; N]>` are all supported, as [this examples shows](#large-and-const-generic-arrays).
+//! * Skip serializing all empty `Option` types with [`#[skip_serializing_none]`][skip_serializing_none].
+//! * Apply a prefix to each field name of a struct, without changing the de/serialize implementations of the struct using [`with_prefix!`][].
+//! * Deserialize a comma separated list like `#hash,#tags,#are,#great` into a `Vec<String>`.
+//! Check the documentation for [`serde_with::rust::StringWithSeparator::<CommaSeparator>`][StringWithSeparator].
+//!
+//! ## Getting Help
+//!
+//! **Check out the [user guide][user guide] to find out more tips and tricks about this crate.**
+//!
+//! For further help using this crate you can [open a new discussion](https://github.com/jonasbb/serde_with/discussions/new) or ask on [users.rust-lang.org](https://users.rust-lang.org/).
+//! For bugs, please open a [new issue](https://github.com/jonasbb/serde_with/issues/new) on GitHub.
+//!
+//! # Use `serde_with` in your Project
+//!
+//! Add this to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies.serde_with]
+//! version = "1.14.0"
+//! features = [ "..." ]
+//! ```
+//!
+//! The crate contains different features for integration with other common crates.
+//! Check the [feature flags][] section for information about all available features.
+//!
+//! # Examples
+//!
+//! Annotate your struct or enum to enable the custom de/serializer.
+//! The `#[serde_as]` attribute must be place *before* the `#[derive]`.
+//!
+//! ## `DisplayFromStr`
+//!
+//! ```rust
+//! # #[cfg(feature = "macros")]
+//! # use serde::{Deserialize, Serialize};
+//! # #[cfg(feature = "macros")]
+//! # use serde_with::{serde_as, DisplayFromStr};
+//! # #[cfg(feature = "macros")]
+//! #[serde_as]
+//! # #[derive(Debug, Eq, PartialEq)]
+//! #[derive(Deserialize, Serialize)]
+//! struct Foo {
+//! // Serialize with Display, deserialize with FromStr
+//! #[serde_as(as = "DisplayFromStr")]
+//! bar: u8,
+//! }
+//!
+//! # #[cfg(all(feature = "macros", feature = "json"))] {
+//! // This will serialize
+//! # let foo =
+//! Foo {bar: 12}
+//! # ;
+//!
+//! // into this JSON
+//! # let json = r#"
+//! {"bar": "12"}
+//! # "#;
+//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap());
+//! # assert_eq!(foo, serde_json::from_str(&json).unwrap());
+//! # }
+//! ```
+//!
+//! ## Large and const-generic arrays
+//!
+//! serde does not support arrays with more than 32 elements or using const-generics.
+//! The `serde_as` attribute allows circumventing this restriction, even for nested types and nested arrays.
+//!
+//! ```rust
+//! # #[cfg(FALSE)] {
+//! # #[cfg(feature = "macros")]
+//! # use serde::{Deserialize, Serialize};
+//! # #[cfg(feature = "macros")]
+//! # use serde_with::serde_as;
+//! # #[cfg(feature = "macros")]
+//! #[serde_as]
+//! # #[derive(Debug, Eq, PartialEq)]
+//! #[derive(Deserialize, Serialize)]
+//! struct Arrays<const N: usize, const M: usize> {
+//! #[serde_as(as = "[_; N]")]
+//! constgeneric: [bool; N],
+//!
+//! #[serde_as(as = "Box<[[_; 64]; N]>")]
+//! nested: Box<[[u8; 64]; N]>,
+//!
+//! #[serde_as(as = "Option<[_; M]>")]
+//! optional: Option<[u8; M]>,
+//! }
+//!
+//! # #[cfg(all(feature = "macros", feature = "json"))] {
+//! // This allows us to serialize a struct like this
+//! let arrays: Arrays<100, 128> = Arrays {
+//! constgeneric: [true; 100],
+//! nested: Box::new([[111; 64]; 100]),
+//! optional: Some([222; 128])
+//! };
+//! assert!(serde_json::to_string(&arrays).is_ok());
+//! # }
+//! # }
+//! ```
+//!
+//! ## `skip_serializing_none`
+//!
+//! This situation often occurs with JSON, but other formats also support optional fields.
+//! If many fields are optional, putting the annotations on the structs can become tedious.
+//! The `#[skip_serializing_none]` attribute must be place *before* the `#[derive]`.
+//!
+//! ```rust
+//! # #[cfg(feature = "macros")]
+//! # use serde::{Deserialize, Serialize};
+//! # #[cfg(feature = "macros")]
+//! # use serde_with::skip_serializing_none;
+//! # #[cfg(feature = "macros")]
+//! #[skip_serializing_none]
+//! # #[derive(Debug, Eq, PartialEq)]
+//! #[derive(Deserialize, Serialize)]
+//! struct Foo {
+//! a: Option<usize>,
+//! b: Option<usize>,
+//! c: Option<usize>,
+//! d: Option<usize>,
+//! e: Option<usize>,
+//! f: Option<usize>,
+//! g: Option<usize>,
+//! }
+//!
+//! # #[cfg(all(feature = "macros", feature = "json"))] {
+//! // This will serialize
+//! # let foo =
+//! Foo {a: None, b: None, c: None, d: Some(4), e: None, f: None, g: Some(7)}
+//! # ;
+//!
+//! // into this JSON
+//! # let json = r#"
+//! {"d": 4, "g": 7}
+//! # "#;
+//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap());
+//! # assert_eq!(foo, serde_json::from_str(&json).unwrap());
+//! # }
+//! ```
+//!
+//! ## Advanced `serde_as` usage
+//!
+//! This example is mainly supposed to highlight the flexibility of the `serde_as`-annotation compared to [serde's with-annotation][with-annotation].
+//! More details about `serde_as` can be found in the [user guide][].
+//!
+//! ```rust
+//! # #[cfg(all(feature = "macros", feature = "hex"))]
+//! # use {
+//! # serde::{Deserialize, Serialize},
+//! # serde_with::{serde_as, DisplayFromStr, DurationSeconds, hex::Hex},
+//! # std::time::Duration,
+//! # std::collections::BTreeMap,
+//! # };
+//! # #[cfg(all(feature = "macros", feature = "hex"))]
+//! #[serde_as]
+//! # #[derive(Debug, Eq, PartialEq)]
+//! #[derive(Deserialize, Serialize)]
+//! struct Foo {
+//! // Serialize them into a list of number as seconds
+//! #[serde_as(as = "Vec<DurationSeconds>")]
+//! durations: Vec<Duration>,
+//! // We can treat a Vec like a map with duplicates.
+//! // JSON only allows string keys, so convert i32 to strings
+//! // The bytes will be hex encoded
+//! #[serde_as(as = "BTreeMap<DisplayFromStr, Hex>")]
+//! bytes: Vec<(i32, Vec<u8>)>,
+//! }
+//!
+//! # #[cfg(all(feature = "macros", feature = "json", feature = "hex"))] {
+//! // This will serialize
+//! # let foo =
+//! Foo {
+//! durations: vec![Duration::new(5, 0), Duration::new(3600, 0), Duration::new(0, 0)],
+//! bytes: vec![
+//! (1, vec![0, 1, 2]),
+//! (-100, vec![100, 200, 255]),
+//! (1, vec![0, 111, 222]),
+//! ],
+//! }
+//! # ;
+//!
+//! // into this JSON
+//! # let json = r#"
+//! {
+//! "durations": [5, 3600, 0],
+//! "bytes": {
+//! "1": "000102",
+//! "-100": "64c8ff",
+//! "1": "006fde"
+//! }
+//! }
+//! # "#;
+//! # assert_eq!(json.replace(" ", "").replace("\n", ""), serde_json::to_string(&foo).unwrap());
+//! # assert_eq!(foo, serde_json::from_str(&json).unwrap());
+//! # }
+//! ```
+//!
+//! [`DisplayFromStr`]: https://docs.rs/serde_with/1.14.0/serde_with/struct.DisplayFromStr.html
+//! [`with_prefix!`]: https://docs.rs/serde_with/1.14.0/serde_with/macro.with_prefix.html
+//! [display_fromstr]: https://docs.rs/serde_with/1.14.0/serde_with/rust/display_fromstr/index.html
+//! [feature flags]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html
+//! [skip_serializing_none]: https://docs.rs/serde_with/1.14.0/serde_with/attr.skip_serializing_none.html
+//! [StringWithSeparator]: https://docs.rs/serde_with/1.14.0/serde_with/rust/struct.StringWithSeparator.html
+//! [user guide]: https://docs.rs/serde_with/1.14.0/serde_with/guide/index.html
+//! [with-annotation]: https://serde.rs/field-attrs.html#with
+//! [as-annotation]: https://docs.rs/serde_with/1.14.0/serde_with/guide/serde_as/index.html
+
+extern crate alloc;
+#[doc(hidden)]
+pub extern crate serde;
+extern crate std;
+
+#[cfg(feature = "base64")]
+#[cfg_attr(docsrs, doc(cfg(feature = "base64")))]
+pub mod base64;
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+pub mod chrono;
+mod content;
+pub mod de;
+mod duplicate_key_impls;
+mod enum_map;
+mod flatten_maybe;
+pub mod formats;
+#[cfg(feature = "hex")]
+#[cfg_attr(docsrs, doc(cfg(feature = "hex")))]
+pub mod hex;
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+pub mod json;
+pub mod rust;
+pub mod ser;
+mod serde_conv;
+#[cfg(feature = "time_0_3")]
+#[cfg_attr(docsrs, doc(cfg(feature = "time_0_3")))]
+pub mod time_0_3;
+mod utils;
+#[doc(hidden)]
+pub mod with_prefix;
+
+// Taken from shepmaster/snafu
+// Originally licensed as MIT+Apache 2
+// https://github.com/shepmaster/snafu/blob/fd37d79d4531ed1d3eebffad0d658928eb860cfe/src/lib.rs#L121-L165
+#[cfg(feature = "guide")]
+#[allow(unused_macro_rules)]
+macro_rules! generate_guide {
+ (pub mod $name:ident; $($rest:tt)*) => {
+ generate_guide!(@gen ".", pub mod $name { } $($rest)*);
+ };
+ (pub mod $name:ident { $($children:tt)* } $($rest:tt)*) => {
+ generate_guide!(@gen ".", pub mod $name { $($children)* } $($rest)*);
+ };
+ (@gen $prefix:expr, ) => {};
+ (@gen $prefix:expr, pub mod $name:ident; $($rest:tt)*) => {
+ generate_guide!(@gen $prefix, pub mod $name { } $($rest)*);
+ };
+ (@gen $prefix:expr, @code pub mod $name:ident; $($rest:tt)*) => {
+ pub mod $name;
+ generate_guide!(@gen $prefix, $($rest)*);
+ };
+ (@gen $prefix:expr, pub mod $name:ident { $($children:tt)* } $($rest:tt)*) => {
+ doc_comment::doc_comment! {
+ include_str!(concat!($prefix, "/", stringify!($name), ".md")),
+ pub mod $name {
+ generate_guide!(@gen concat!($prefix, "/", stringify!($name)), $($children)*);
+ }
+ }
+ generate_guide!(@gen $prefix, $($rest)*);
+ };
+}
+
+#[cfg(feature = "guide")]
+generate_guide! {
+ pub mod guide {
+ pub mod feature_flags;
+ pub mod serde_as;
+ pub mod serde_as_transformations;
+ }
+}
+
+#[doc(inline)]
+pub use crate::{
+ de::DeserializeAs, enum_map::EnumMap, rust::StringWithSeparator, ser::SerializeAs,
+};
+use core::marker::PhantomData;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+// Re-Export all proc_macros, as these should be seen as part of the serde_with crate
+#[cfg(feature = "macros")]
+#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
+#[doc(inline)]
+pub use serde_with_macros::*;
+
+/// Separator for string-based collection de/serialization
+pub trait Separator {
+ /// Return the string delimiting two elements in the string-based collection
+ fn separator() -> &'static str;
+}
+
+/// Predefined separator using a single space
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
+pub struct SpaceSeparator;
+
+impl Separator for SpaceSeparator {
+ #[inline]
+ fn separator() -> &'static str {
+ " "
+ }
+}
+
+/// Predefined separator using a single comma
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
+pub struct CommaSeparator;
+
+impl Separator for CommaSeparator {
+ #[inline]
+ fn separator() -> &'static str {
+ ","
+ }
+}
+
+/// Adapter to convert from `serde_as` to the serde traits.
+///
+/// The `As` type adapter allows using types which implement [`DeserializeAs`] or [`SerializeAs`] in place of serde's with-annotation.
+/// The with-annotation allows running custom code when de/serializing, however it is quite inflexible.
+/// The traits [`DeserializeAs`]/[`SerializeAs`] are more flexible, as they allow composition and nesting of types to create more complex de/serialization behavior.
+/// However, they are not directly compatible with serde, as they are not provided by serde.
+/// The `As` type adapter makes them compatible, by forwarding the function calls to `serialize`/`deserialize` to the corresponding functions `serialize_as` and `deserialize_as`.
+///
+/// It is not required to use this type directly.
+/// Instead, it is highly encouraged to use the [`#[serde_as]`][serde_as] attribute since it includes further usability improvements.
+/// If the use of the use of the proc-macro is not acceptable, then `As` can be used directly with serde.
+///
+/// ```rust
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{As, DisplayFromStr};
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// # struct S {
+/// // Serialize numbers as sequence of strings, using Display and FromStr
+/// #[serde(with = "As::<Vec<DisplayFromStr>>")]
+/// field: Vec<u8>,
+/// # }
+/// ```
+/// If the normal `Deserialize`/`Serialize` traits should be used, the placeholder type [`Same`] can be used.
+/// It implements [`DeserializeAs`][]/[`SerializeAs`][], when the underlying type implements `Deserialize`/`Serialize`.
+///
+/// ```rust
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{As, DisplayFromStr, Same};
+/// # use std::collections::BTreeMap;
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// # struct S {
+/// // Serialize map, turn keys into strings but keep type of value
+/// #[serde(with = "As::<BTreeMap<DisplayFromStr, Same>>")]
+/// field: BTreeMap<u8, i32>,
+/// # }
+/// ```
+///
+/// [serde_as]: https://docs.rs/serde_with/1.14.0/serde_with/attr.serde_as.html
+#[derive(Copy, Clone, Debug, Default)]
+pub struct As<T: ?Sized>(PhantomData<T>);
+
+impl<T: ?Sized> As<T> {
+ /// Serialize type `T` using [`SerializeAs`][]
+ ///
+ /// The function signature is compatible with [serde's with-annotation][with-annotation].
+ ///
+ /// [with-annotation]: https://serde.rs/field-attrs.html#with
+ pub fn serialize<S, I>(value: &I, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ T: SerializeAs<I>,
+ I: ?Sized,
+ {
+ T::serialize_as(value, serializer)
+ }
+
+ /// Deserialize type `T` using [`DeserializeAs`][]
+ ///
+ /// The function signature is compatible with [serde's with-annotation][with-annotation].
+ ///
+ /// [with-annotation]: https://serde.rs/field-attrs.html#with
+ pub fn deserialize<'de, D, I>(deserializer: D) -> Result<I, D::Error>
+ where
+ T: DeserializeAs<'de, I>,
+ D: Deserializer<'de>,
+ {
+ T::deserialize_as(deserializer)
+ }
+}
+
+/// Adapter to convert from `serde_as` to the serde traits.
+///
+/// This is the counter-type to [`As`][].
+/// It can be used whenever a type implementing [`DeserializeAs`][]/[`SerializeAs`][] is required but the normal `Deserialize`/`Serialize` traits should be used.
+/// Check [`As`] for an example.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Same;
+
+/// De/Serialize using [`Display`] and [`FromStr`] implementation
+///
+/// This allows deserializing a string as a number.
+/// It can be very useful for serialization formats like JSON, which do not support integer
+/// numbers and have to resort to strings to represent them.
+///
+/// Another use case is types with [`Display`] and [`FromStr`] implementations, but without serde
+/// support, which can be found in some crates.
+///
+/// If you control the type you want to de/serialize, you can instead use the two derive macros, [`SerializeDisplay`] and [`DeserializeFromStr`].
+/// They properly implement the traits [`Serialize`] and [`Deserialize`] such that user of the type no longer have to use the `serde_as` system.
+///
+/// The same functionality is also available as [`serde_with::rust::display_fromstr`][crate::rust::display_fromstr] compatible with serde's with-annotation.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DisplayFromStr};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "DisplayFromStr")]
+/// mime: mime::Mime,
+/// #[serde_as(as = "DisplayFromStr")]
+/// number: u32,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({
+/// "mime": "text/plain",
+/// "number": "159",
+/// })).unwrap();
+/// assert_eq!(mime::TEXT_PLAIN, v.mime);
+/// assert_eq!(159, v.number);
+///
+/// let x = A {
+/// mime: mime::STAR_STAR,
+/// number: 777,
+/// };
+/// assert_eq!(json!({ "mime": "*/*", "number": "777" }), serde_json::to_value(&x).unwrap());
+/// # }
+/// ```
+///
+/// [`Display`]: std::fmt::Display
+/// [`FromStr`]: std::str::FromStr
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DisplayFromStr;
+
+/// De/Serialize a [`Option<String>`] type while transforming the empty string to [`None`]
+///
+/// Convert an [`Option<T>`] from/to string using [`FromStr`] and [`AsRef<str>`] implementations.
+/// An empty string is deserialized as [`None`] and a [`None`] vice versa.
+///
+/// The same functionality is also available as [`serde_with::rust::string_empty_as_none`][crate::rust::string_empty_as_none] compatible with serde's with-annotation.
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, NoneAsEmptyString};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "NoneAsEmptyString")]
+/// tags: Option<String>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({ "tags": "" })).unwrap();
+/// assert_eq!(None, v.tags);
+///
+/// let v: A = serde_json::from_value(json!({ "tags": "Hi" })).unwrap();
+/// assert_eq!(Some("Hi".to_string()), v.tags);
+///
+/// let x = A {
+/// tags: Some("This is text".to_string()),
+/// };
+/// assert_eq!(json!({ "tags": "This is text" }), serde_json::to_value(&x).unwrap());
+///
+/// let x = A {
+/// tags: None,
+/// };
+/// assert_eq!(json!({ "tags": "" }), serde_json::to_value(&x).unwrap());
+/// # }
+/// ```
+///
+/// [`FromStr`]: std::str::FromStr
+#[derive(Copy, Clone, Debug, Default)]
+pub struct NoneAsEmptyString;
+
+/// Deserialize value and return [`Default`] on error
+///
+/// The main use case is ignoring error while deserializing.
+/// Instead of erroring, it simply deserializes the [`Default`] variant of the type.
+/// It is not possible to find the error location, i.e., which field had a deserialization error, with this method.
+/// During serialization this wrapper does nothing.
+/// The serialization behavior of the underlying type is preserved.
+/// The type must implement [`Default`] for this conversion to work.
+///
+/// The same functionality is also available as [`serde_with::rust::default_on_error`][crate::rust::default_on_error] compatible with serde's with-annotation.
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, DefaultOnError};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Debug)]
+/// struct A {
+/// #[serde_as(deserialize_as = "DefaultOnError")]
+/// value: u32,
+/// }
+///
+/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap();
+/// assert_eq!(123, a.value);
+///
+/// // null is of invalid type
+/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // String is of invalid type
+/// let a: A = serde_json::from_str(r#"{"value": "123"}"#).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // Map is of invalid type
+/// let a: A = dbg!(serde_json::from_str(r#"{"value": {}}"#)).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // Missing entries still cause errors
+/// assert!(serde_json::from_str::<A>(r#"{ }"#).is_err());
+/// # }
+/// ```
+///
+/// Deserializing missing values can be supported by adding the `default` field attribute:
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, DefaultOnError};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct B {
+/// #[serde_as(deserialize_as = "DefaultOnError")]
+/// #[serde(default)]
+/// value: u32,
+/// }
+///
+/// let b: B = serde_json::from_str(r#"{ }"#).unwrap();
+/// assert_eq!(0, b.value);
+/// # }
+/// ```
+///
+/// `DefaultOnError` can be combined with other conversion methods.
+/// In this example, we deserialize a `Vec`, each element is deserialized from a string.
+/// If the string does not parse as a number, then we get the default value of 0.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DefaultOnError, DisplayFromStr};
+/// #
+/// #[serde_as]
+/// #[derive(Serialize, Deserialize)]
+/// struct C {
+/// #[serde_as(as = "Vec<DefaultOnError<DisplayFromStr>>")]
+/// value: Vec<u32>,
+/// };
+///
+/// let c: C = serde_json::from_value(json!({
+/// "value": ["1", "2", "a3", "", {}, "6"]
+/// })).unwrap();
+/// assert_eq!(vec![1, 2, 0, 0, 0, 6], c.value);
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DefaultOnError<T = Same>(PhantomData<T>);
+
+/// Deserialize [`Default`] from `null` values
+///
+/// Instead of erroring on `null` values, it simply deserializes the [`Default`] variant of the type.
+/// During serialization this wrapper does nothing.
+/// The serialization behavior of the underlying type is preserved.
+/// The type must implement [`Default`] for this conversion to work.
+///
+/// The same functionality is also available as [`serde_with::rust::default_on_null`][crate::rust::default_on_null] compatible with serde's with-annotation.
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, DefaultOnNull};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Debug)]
+/// struct A {
+/// #[serde_as(deserialize_as = "DefaultOnNull")]
+/// value: u32,
+/// }
+///
+/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap();
+/// assert_eq!(123, a.value);
+///
+/// // null values are deserialized into the default, here 0
+/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap();
+/// assert_eq!(0, a.value);
+/// # }
+/// ```
+///
+/// `DefaultOnNull` can be combined with other conversion methods.
+/// In this example, we deserialize a `Vec`, each element is deserialized from a string.
+/// If we encounter null, then we get the default value of 0.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DefaultOnNull, DisplayFromStr};
+/// #
+/// #[serde_as]
+/// #[derive(Serialize, Deserialize)]
+/// struct C {
+/// #[serde_as(as = "Vec<DefaultOnNull<DisplayFromStr>>")]
+/// value: Vec<u32>,
+/// };
+///
+/// let c: C = serde_json::from_value(json!({
+/// "value": ["1", "2", null, null, "5"]
+/// })).unwrap();
+/// assert_eq!(vec![1, 2, 0, 0, 5], c.value);
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DefaultOnNull<T = Same>(PhantomData<T>);
+
+/// Deserialize from bytes or string
+///
+/// Any Rust [`String`] can be converted into bytes, i.e., `Vec<u8>`.
+/// Accepting both as formats while deserializing can be helpful while interacting with language
+/// which have a looser definition of string than Rust.
+///
+/// # Example
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, BytesOrString};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "BytesOrString")]
+/// bytes_or_string: Vec<u8>,
+/// }
+///
+/// // Here we deserialize from a byte array ...
+/// let j = json!({
+/// "bytes_or_string": [
+/// 0,
+/// 1,
+/// 2,
+/// 3
+/// ]
+/// });
+///
+/// let a: A = serde_json::from_value(j.clone()).unwrap();
+/// assert_eq!(vec![0, 1, 2, 3], a.bytes_or_string);
+///
+/// // and serialization works too.
+/// assert_eq!(j, serde_json::to_value(&a).unwrap());
+///
+/// // But we also support deserializing from a String
+/// let j = json!({
+/// "bytes_or_string": "✨Works!"
+/// });
+///
+/// let a: A = serde_json::from_value(j).unwrap();
+/// assert_eq!("✨Works!".as_bytes(), &*a.bytes_or_string);
+/// # }
+/// ```
+/// [`String`]: std::string::String
+#[derive(Copy, Clone, Debug, Default)]
+pub struct BytesOrString;
+
+/// De/Serialize Durations as number of seconds.
+///
+/// De/serialize durations as number of seconds with subsecond precision.
+/// Subsecond precision is *only* supported for [`DurationSecondsWithFrac`], but not for [`DurationSeconds`].
+/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier.
+///
+/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`].
+/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `u64` deserialization from a `f64` will error.
+/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct duration and allows deserialization from any type.
+/// For example, deserializing `DurationSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number.
+///
+/// This type also supports [`chrono::Duration`] with the `chrono`-[feature flag].
+/// This type also supports [`time::Duration`][::time_0_3::Duration] with the `time_0_3`-[feature flag].
+///
+/// | Duration Type | Converter | Available `FORMAT`s |
+/// | --------------------- | ------------------------- | ---------------------- |
+/// | `std::time::Duration` | `DurationSeconds` | `u64`, `f64`, `String` |
+/// | `std::time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::Duration` | `DurationSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::Duration` | `DurationSecondsWithFrac` | `f64`, `String` |
+/// | `time::Duration` | `DurationSeconds` | `i64`, `f64`, `String` |
+/// | `time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` |
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DurationSeconds};
+/// use std::time::Duration;
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Durations {
+/// #[serde_as(as = "DurationSeconds<u64>")]
+/// d_u64: Duration,
+/// #[serde_as(as = "DurationSeconds<f64>")]
+/// d_f64: Duration,
+/// #[serde_as(as = "DurationSeconds<String>")]
+/// d_string: Duration,
+/// };
+///
+/// // Serialization
+/// // See how the values get rounded, since subsecond precision is not allowed.
+///
+/// let d = Durations {
+/// d_u64: Duration::new(12345, 0), // Create from seconds and nanoseconds
+/// d_f64: Duration::new(12345, 500_000_000),
+/// d_string: Duration::new(12345, 999_999_999),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "d_u64": 12345,
+/// "d_f64": 12346.0,
+/// "d_string": "12346",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&d).unwrap());
+///
+/// // Deserialization works too
+/// // Subsecond precision in numbers will be rounded away
+///
+/// let json = json!({
+/// "d_u64": 12345,
+/// "d_f64": 12345.5,
+/// "d_string": "12346",
+/// });
+/// let expected = Durations {
+/// d_u64: Duration::new(12345, 0), // Create from seconds and nanoseconds
+/// d_f64: Duration::new(12346, 0),
+/// d_string: Duration::new(12346, 0),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`chrono::Duration`] is also supported when using the `chrono` feature.
+/// It is a signed duration, thus can be de/serialized as an `i64` instead of a `u64`.
+///
+/// ```rust
+/// # #[cfg(all(feature = "macros", feature = "chrono"))] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DurationSeconds};
+/// # use chrono_crate::Duration;
+/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate
+/// use chrono::Duration;
+/// # */
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Durations {
+/// #[serde_as(as = "DurationSeconds<i64>")]
+/// d_i64: Duration,
+/// #[serde_as(as = "DurationSeconds<f64>")]
+/// d_f64: Duration,
+/// #[serde_as(as = "DurationSeconds<String>")]
+/// d_string: Duration,
+/// };
+///
+/// // Serialization
+/// // See how the values get rounded, since subsecond precision is not allowed.
+///
+/// let d = Durations {
+/// d_i64: Duration::seconds(-12345),
+/// d_f64: Duration::seconds(-12345) + Duration::milliseconds(500),
+/// d_string: Duration::seconds(12345) + Duration::nanoseconds(999_999_999),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "d_i64": -12345,
+/// "d_f64": -12345.0,
+/// "d_string": "12346",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&d).unwrap());
+///
+/// // Deserialization works too
+/// // Subsecond precision in numbers will be rounded away
+///
+/// let json = json!({
+/// "d_i64": -12345,
+/// "d_f64": -12345.5,
+/// "d_string": "12346",
+/// });
+/// let expected = Durations {
+/// d_i64: Duration::seconds(-12345),
+/// d_f64: Duration::seconds(-12346),
+/// d_string: Duration::seconds(12346),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`chrono::Duration`]: chrono_crate::Duration
+/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationSeconds<
+ FORMAT: formats::Format = u64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// De/Serialize Durations as number of seconds.
+///
+/// De/serialize durations as number of seconds with subsecond precision.
+/// Subsecond precision is *only* supported for [`DurationSecondsWithFrac`], but not for [`DurationSeconds`].
+/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier.
+///
+/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`].
+/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `u64` deserialization from a `f64` will error.
+/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct duration and allows deserialization from any type.
+/// For example, deserializing `DurationSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number.
+///
+/// This type also supports [`chrono::Duration`] with the `chrono`-[feature flag].
+/// This type also supports [`time::Duration`][::time_0_3::Duration] with the `time_0_3`-[feature flag].
+///
+/// | Duration Type | Converter | Available `FORMAT`s |
+/// | --------------------- | ------------------------- | ---------------------- |
+/// | `std::time::Duration` | `DurationSeconds` | `u64`, `f64`, `String` |
+/// | `std::time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::Duration` | `DurationSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::Duration` | `DurationSecondsWithFrac` | `f64`, `String` |
+/// | `time::Duration` | `DurationSeconds` | `i64`, `f64`, `String` |
+/// | `time::Duration` | `DurationSecondsWithFrac` | `f64`, `String` |
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DurationSecondsWithFrac};
+/// use std::time::Duration;
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Durations {
+/// #[serde_as(as = "DurationSecondsWithFrac<f64>")]
+/// d_f64: Duration,
+/// #[serde_as(as = "DurationSecondsWithFrac<String>")]
+/// d_string: Duration,
+/// };
+///
+/// // Serialization
+/// // See how the values get rounded, since subsecond precision is not allowed.
+///
+/// let d = Durations {
+/// d_f64: Duration::new(12345, 500_000_000), // Create from seconds and nanoseconds
+/// d_string: Duration::new(12345, 999_999_000),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "d_f64": 12345.5,
+/// "d_string": "12345.999999",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&d).unwrap());
+///
+/// // Deserialization works too
+/// // Subsecond precision in numbers will be rounded away
+///
+/// let json = json!({
+/// "d_f64": 12345.5,
+/// "d_string": "12345.987654",
+/// });
+/// let expected = Durations {
+/// d_f64: Duration::new(12345, 500_000_000), // Create from seconds and nanoseconds
+/// d_string: Duration::new(12345, 987_654_000),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`chrono::Duration`] is also supported when using the `chrono` feature.
+/// It is a signed duration, thus can be de/serialized as an `i64` instead of a `u64`.
+///
+/// ```rust
+/// # #[cfg(all(feature = "macros", feature = "chrono"))] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DurationSecondsWithFrac};
+/// # use chrono_crate::Duration;
+/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate
+/// use chrono::Duration;
+/// # */
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Durations {
+/// #[serde_as(as = "DurationSecondsWithFrac<f64>")]
+/// d_f64: Duration,
+/// #[serde_as(as = "DurationSecondsWithFrac<String>")]
+/// d_string: Duration,
+/// };
+///
+/// // Serialization
+///
+/// let d = Durations {
+/// d_f64: Duration::seconds(-12345) + Duration::milliseconds(500),
+/// d_string: Duration::seconds(12345) + Duration::nanoseconds(999_999_000),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "d_f64": -12344.5,
+/// "d_string": "12345.999999",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&d).unwrap());
+///
+/// // Deserialization works too
+///
+/// let json = json!({
+/// "d_f64": -12344.5,
+/// "d_string": "12345.987",
+/// });
+/// let expected = Durations {
+/// d_f64: Duration::seconds(-12345) + Duration::milliseconds(500),
+/// d_string: Duration::seconds(12345) + Duration::milliseconds(987),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`chrono::Duration`]: chrono_crate::Duration
+/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`DurationSeconds`] with milli-seconds as base unit.
+///
+/// This type is equivalent to [`DurationSeconds`] except that each unit represents 1 milli-second instead of 1 second for [`DurationSeconds`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationMilliSeconds<
+ FORMAT: formats::Format = u64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`DurationSecondsWithFrac`] with milli-seconds as base unit.
+///
+/// This type is equivalent to [`DurationSecondsWithFrac`] except that each unit represents 1 milli-second instead of 1 second for [`DurationSecondsWithFrac`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationMilliSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`DurationSeconds`] with micro-seconds as base unit.
+///
+/// This type is equivalent to [`DurationSeconds`] except that each unit represents 1 micro-second instead of 1 second for [`DurationSeconds`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationMicroSeconds<
+ FORMAT: formats::Format = u64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`DurationSecondsWithFrac`] with micro-seconds as base unit.
+///
+/// This type is equivalent to [`DurationSecondsWithFrac`] except that each unit represents 1 micro-second instead of 1 second for [`DurationSecondsWithFrac`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationMicroSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`DurationSeconds`] with nano-seconds as base unit.
+///
+/// This type is equivalent to [`DurationSeconds`] except that each unit represents 1 nano-second instead of 1 second for [`DurationSeconds`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationNanoSeconds<
+ FORMAT: formats::Format = u64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`DurationSecondsWithFrac`] with nano-seconds as base unit.
+///
+/// This type is equivalent to [`DurationSecondsWithFrac`] except that each unit represents 1 nano-second instead of 1 second for [`DurationSecondsWithFrac`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct DurationNanoSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// De/Serialize timestamps as seconds since the UNIX epoch
+///
+/// De/serialize timestamps as seconds since the UNIX epoch.
+/// Subsecond precision is *only* supported for [`TimestampSecondsWithFrac`], but not for [`TimestampSeconds`].
+/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier.
+///
+/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`].
+/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `i64` deserialization from a `f64` will error.
+/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct timestamp and allows deserialization from any type.
+/// For example, deserializing `TimestampSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number.
+///
+/// This type also supports [`chrono::DateTime`][DateTime] with the `chrono`-[feature flag].
+/// This type also supports [`time::OffsetDateTime`][::time_0_3::OffsetDateTime] and [`time::PrimitiveDateTime`][::time_0_3::PrimitiveDateTime] with the `time_0_3`-[feature flag].
+///
+/// | Timestamp Type | Converter | Available `FORMAT`s |
+/// | ------------------------- | -------------------------- | ---------------------- |
+/// | `std::time::SystemTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `std::time::SystemTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::DateTime<Utc>` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::DateTime<Utc>` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::DateTime<Local>` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::DateTime<Local>` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `time::OffsetDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `time::OffsetDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `time::PrimitiveDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `time::PrimitiveDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, TimestampSeconds};
+/// use std::time::{Duration, SystemTime};
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Timestamps {
+/// #[serde_as(as = "TimestampSeconds<i64>")]
+/// st_i64: SystemTime,
+/// #[serde_as(as = "TimestampSeconds<f64>")]
+/// st_f64: SystemTime,
+/// #[serde_as(as = "TimestampSeconds<String>")]
+/// st_string: SystemTime,
+/// };
+///
+/// // Serialization
+/// // See how the values get rounded, since subsecond precision is not allowed.
+///
+/// let ts = Timestamps {
+/// st_i64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 0)).unwrap(),
+/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(),
+/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 999_999_999)).unwrap(),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "st_i64": 12345,
+/// "st_f64": 12346.0,
+/// "st_string": "12346",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&ts).unwrap());
+///
+/// // Deserialization works too
+/// // Subsecond precision in numbers will be rounded away
+///
+/// let json = json!({
+/// "st_i64": 12345,
+/// "st_f64": 12345.5,
+/// "st_string": "12346",
+/// });
+/// let expected = Timestamps {
+/// st_i64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 0)).unwrap(),
+/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12346, 0)).unwrap(),
+/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12346, 0)).unwrap(),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`chrono::DateTime<Utc>`][DateTime] and [`chrono::DateTime<Local>`][DateTime] are also supported when using the `chrono` feature.
+/// Like [`SystemTime`], it is a signed timestamp, thus can be de/serialized as an `i64`.
+///
+/// ```rust
+/// # #[cfg(all(feature = "macros", feature = "chrono"))] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, TimestampSeconds};
+/// # use chrono_crate::{DateTime, Local, TimeZone, Utc};
+/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate
+/// use chrono::{DateTime, Local, TimeZone, Utc};
+/// # */
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Timestamps {
+/// #[serde_as(as = "TimestampSeconds<i64>")]
+/// dt_i64: DateTime<Utc>,
+/// #[serde_as(as = "TimestampSeconds<f64>")]
+/// dt_f64: DateTime<Local>,
+/// #[serde_as(as = "TimestampSeconds<String>")]
+/// dt_string: DateTime<Utc>,
+/// };
+///
+/// // Serialization
+/// // See how the values get rounded, since subsecond precision is not allowed.
+///
+/// let ts = Timestamps {
+/// dt_i64: Utc.timestamp(-12345, 0),
+/// dt_f64: Local.timestamp(-12345, 500_000_000),
+/// dt_string: Utc.timestamp(12345, 999_999_999),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "dt_i64": -12345,
+/// "dt_f64": -12345.0,
+/// "dt_string": "12346",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&ts).unwrap());
+///
+/// // Deserialization works too
+/// // Subsecond precision in numbers will be rounded away
+///
+/// let json = json!({
+/// "dt_i64": -12345,
+/// "dt_f64": -12345.5,
+/// "dt_string": "12346",
+/// });
+/// let expected = Timestamps {
+/// dt_i64: Utc.timestamp(-12345, 0),
+/// dt_f64: Local.timestamp(-12346, 0),
+/// dt_string: Utc.timestamp(12346, 0),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`SystemTime`]: std::time::SystemTime
+/// [DateTime]: chrono_crate::DateTime
+/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampSeconds<
+ FORMAT: formats::Format = i64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// De/Serialize timestamps as seconds since the UNIX epoch
+///
+/// De/serialize timestamps as seconds since the UNIX epoch.
+/// Subsecond precision is *only* supported for [`TimestampSecondsWithFrac`], but not for [`TimestampSeconds`].
+/// You can configure the serialization format between integers, floats, and stringified numbers with the `FORMAT` specifier and configure the deserialization with the `STRICTNESS` specifier.
+///
+/// The `STRICTNESS` specifier can either be [`formats::Strict`] or [`formats::Flexible`] and defaults to [`formats::Strict`].
+/// [`formats::Strict`] means that deserialization only supports the type given in `FORMAT`, e.g., if `FORMAT` is `i64` deserialization from a `f64` will error.
+/// [`formats::Flexible`] means that deserialization will perform a best effort to extract the correct timestamp and allows deserialization from any type.
+/// For example, deserializing `TimestampSeconds<f64, Flexible>` will discard any subsecond precision during deserialization from `f64` and will parse a `String` as an integer number.
+///
+/// This type also supports [`chrono::DateTime`][DateTime] and [`chrono::NaiveDateTime`][NaiveDateTime] with the `chrono`-[feature flag].
+/// This type also supports [`time::OffsetDateTime`][::time_0_3::OffsetDateTime] and [`time::PrimitiveDateTime`][::time_0_3::PrimitiveDateTime] with the `time_0_3`-[feature flag].
+///
+/// | Timestamp Type | Converter | Available `FORMAT`s |
+/// | ------------------------- | -------------------------- | ---------------------- |
+/// | `std::time::SystemTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `std::time::SystemTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::DateTime<Utc>` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::DateTime<Utc>` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::DateTime<Local>` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::DateTime<Local>` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `chrono::NaiveDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `chrono::NaiveDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `time::OffsetDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `time::OffsetDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+/// | `time::PrimitiveDateTime` | `TimestampSeconds` | `i64`, `f64`, `String` |
+/// | `time::PrimitiveDateTime` | `TimestampSecondsWithFrac` | `f64`, `String` |
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, TimestampSecondsWithFrac};
+/// use std::time::{Duration, SystemTime};
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Timestamps {
+/// #[serde_as(as = "TimestampSecondsWithFrac<f64>")]
+/// st_f64: SystemTime,
+/// #[serde_as(as = "TimestampSecondsWithFrac<String>")]
+/// st_string: SystemTime,
+/// };
+///
+/// // Serialization
+/// // See how the values get rounded, since subsecond precision is not allowed.
+///
+/// let ts = Timestamps {
+/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(),
+/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 999_999_000)).unwrap(),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "st_f64": 12345.5,
+/// "st_string": "12345.999999",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&ts).unwrap());
+///
+/// // Deserialization works too
+/// // Subsecond precision in numbers will be rounded away
+///
+/// let json = json!({
+/// "st_f64": 12345.5,
+/// "st_string": "12345.987654",
+/// });
+/// let expected = Timestamps {
+/// st_f64: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 500_000_000)).unwrap(),
+/// st_string: SystemTime::UNIX_EPOCH.checked_add(Duration::new(12345, 987_654_000)).unwrap(),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`chrono::DateTime<Utc>`][DateTime] and [`chrono::DateTime<Local>`][DateTime] are also supported when using the `chrono` feature.
+/// Like [`SystemTime`], it is a signed timestamp, thus can be de/serialized as an `i64`.
+///
+/// ```rust
+/// # #[cfg(all(feature = "macros", feature = "chrono"))] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, TimestampSecondsWithFrac};
+/// # use chrono_crate::{DateTime, Local, TimeZone, Utc};
+/// # /* Ugliness to make the docs look nicer since I want to hide the rename of the chrono crate
+/// use chrono::{DateTime, Local, TimeZone, Utc};
+/// # */
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Timestamps {
+/// #[serde_as(as = "TimestampSecondsWithFrac<f64>")]
+/// dt_f64: DateTime<Utc>,
+/// #[serde_as(as = "TimestampSecondsWithFrac<String>")]
+/// dt_string: DateTime<Local>,
+/// };
+///
+/// // Serialization
+///
+/// let ts = Timestamps {
+/// dt_f64: Utc.timestamp(-12345, 500_000_000),
+/// dt_string: Local.timestamp(12345, 999_999_000),
+/// };
+/// // Observe the different data types
+/// let expected = json!({
+/// "dt_f64": -12344.5,
+/// "dt_string": "12345.999999",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&ts).unwrap());
+///
+/// // Deserialization works too
+///
+/// let json = json!({
+/// "dt_f64": -12344.5,
+/// "dt_string": "12345.987",
+/// });
+/// let expected = Timestamps {
+/// dt_f64: Utc.timestamp(-12345, 500_000_000),
+/// dt_string: Local.timestamp(12345, 987_000_000),
+/// };
+/// assert_eq!(expected, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+///
+/// [`SystemTime`]: std::time::SystemTime
+/// [DateTime]: chrono_crate::DateTime
+/// [NaiveDateTime]: chrono_crate::NaiveDateTime
+/// [feature flag]: https://docs.rs/serde_with/1.14.0/serde_with/guide/feature_flags/index.html
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`TimestampSeconds`] with milli-seconds as base unit.
+///
+/// This type is equivalent to [`TimestampSeconds`] except that each unit represents 1 milli-second instead of 1 second for [`TimestampSeconds`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampMilliSeconds<
+ FORMAT: formats::Format = i64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`TimestampSecondsWithFrac`] with milli-seconds as base unit.
+///
+/// This type is equivalent to [`TimestampSecondsWithFrac`] except that each unit represents 1 milli-second instead of 1 second for [`TimestampSecondsWithFrac`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampMilliSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`TimestampSeconds`] with micro-seconds as base unit.
+///
+/// This type is equivalent to [`TimestampSeconds`] except that each unit represents 1 micro-second instead of 1 second for [`TimestampSeconds`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampMicroSeconds<
+ FORMAT: formats::Format = i64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`TimestampSecondsWithFrac`] with micro-seconds as base unit.
+///
+/// This type is equivalent to [`TimestampSecondsWithFrac`] except that each unit represents 1 micro-second instead of 1 second for [`TimestampSecondsWithFrac`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampMicroSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`TimestampSeconds`] with nano-seconds as base unit.
+///
+/// This type is equivalent to [`TimestampSeconds`] except that each unit represents 1 nano-second instead of 1 second for [`TimestampSeconds`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampNanoSeconds<
+ FORMAT: formats::Format = i64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Equivalent to [`TimestampSecondsWithFrac`] with nano-seconds as base unit.
+///
+/// This type is equivalent to [`TimestampSecondsWithFrac`] except that each unit represents 1 nano-second instead of 1 second for [`TimestampSecondsWithFrac`].
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TimestampNanoSecondsWithFrac<
+ FORMAT: formats::Format = f64,
+ STRICTNESS: formats::Strictness = formats::Strict,
+>(PhantomData<(FORMAT, STRICTNESS)>);
+
+/// Optimized handling of owned and borrowed byte representations.
+///
+/// Serialization of byte sequences like `&[u8]` or `Vec<u8>` is quite inefficient since each value will be serialized individually.
+/// This converter type optimizes the serialization and deserialization.
+///
+/// This is a port of the [`serde_bytes`] crate making it compatible with the `serde_as`-annotation, which allows it to be used in more cases than provided by [`serde_bytes`].
+///
+/// The type provides de/serialization for these types:
+///
+/// * `[u8; N]`, not possible using `serde_bytes`
+/// * `&[u8; N]`, not possible using `serde_bytes`
+/// * `&[u8]`
+/// * `Box<[u8; N]>`, not possible using `serde_bytes`
+/// * `Box<[u8]>`
+/// * `Vec<u8>`
+/// * `Cow<'_, [u8]>`
+/// * `Cow<'_, [u8; N]>`, not possible using `serde_bytes`
+///
+/// [`serde_bytes`]: https://crates.io/crates/serde_bytes
+///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{serde_as, Bytes};
+/// # use std::borrow::Cow;
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Test<'a> {
+/// # #[cfg(FALSE)]
+/// #[serde_as(as = "Bytes")]
+/// array: [u8; 15],
+/// #[serde_as(as = "Bytes")]
+/// boxed: Box<[u8]>,
+/// #[serde_as(as = "Bytes")]
+/// #[serde(borrow)]
+/// cow: Cow<'a, [u8]>,
+/// # #[cfg(FALSE)]
+/// #[serde_as(as = "Bytes")]
+/// #[serde(borrow)]
+/// cow_array: Cow<'a, [u8; 15]>,
+/// #[serde_as(as = "Bytes")]
+/// vec: Vec<u8>,
+/// }
+///
+/// let value = Test {
+/// # #[cfg(FALSE)]
+/// array: b"0123456789ABCDE".clone(),
+/// boxed: b"...".to_vec().into_boxed_slice(),
+/// cow: Cow::Borrowed(b"FooBar"),
+/// # #[cfg(FALSE)]
+/// cow_array: Cow::Borrowed(&[42u8; 15]),
+/// vec: vec![0x41, 0x61, 0x21],
+/// };
+/// let expected = r#"(
+/// array: "MDEyMzQ1Njc4OUFCQ0RF",
+/// boxed: "Li4u",
+/// cow: "Rm9vQmFy",
+/// cow_array: "KioqKioqKioqKioqKioq",
+/// vec: "QWEh",
+/// )"#;
+/// # drop(expected);
+/// # // Create a fake expected value that doesn't use const generics
+/// # let expected = r#"(
+/// # boxed: "Li4u",
+/// # cow: "Rm9vQmFy",
+/// # vec: "QWEh",
+/// # )"#;
+///
+/// # let pretty_config = ron::ser::PrettyConfig::new()
+/// # .new_line("\n".into());
+/// assert_eq!(expected, ron::ser::to_string_pretty(&value, pretty_config).unwrap());
+/// assert_eq!(value, ron::from_str(&expected).unwrap());
+/// # }
+/// ```
+///
+/// Fully borrowed types can also be used but you'll need a Deserializer that
+/// supports Serde's 0-copy deserialization:
+///
+/// ```
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{serde_as, Bytes};
+/// # use std::borrow::Cow;
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct TestBorrows<'a> {
+/// # #[cfg(FALSE)]
+/// #[serde_as(as = "Bytes")]
+/// #[serde(borrow)]
+/// array_buf: &'a [u8; 15],
+/// #[serde_as(as = "Bytes")]
+/// #[serde(borrow)]
+/// buf: &'a [u8],
+/// }
+///
+/// let value = TestBorrows {
+/// # #[cfg(FALSE)]
+/// array_buf: &[10u8; 15],
+/// buf: &[20u8, 21u8, 22u8],
+/// };
+/// let expected = r#"(
+/// array_buf: "CgoKCgoKCgoKCgoKCgoK",
+/// buf: "FBUW",
+/// )"#;
+/// # drop(expected);
+/// # // Create a fake expected value that doesn't use const generics
+/// # let expected = r#"(
+/// # buf: "FBUW",
+/// # )"#;
+///
+/// # let pretty_config = ron::ser::PrettyConfig::new()
+/// # .new_line("\n".into());
+/// assert_eq!(expected, ron::ser::to_string_pretty(&value, pretty_config).unwrap());
+/// // RON doesn't support borrowed deserialization of byte arrays
+/// # }
+/// ```
+///
+/// ## Alternative to [`BytesOrString`]
+///
+/// The [`Bytes`] can replace [`BytesOrString`].
+/// [`Bytes`] is implemented for more types, which makes it better.
+/// The serialization behavior of [`Bytes`] differs from [`BytesOrString`], therefore only `deserialize_as` should be used.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, Bytes};
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, serde::Serialize)]
+/// struct Test {
+/// #[serde_as(deserialize_as = "Bytes")]
+/// from_bytes: Vec<u8>,
+/// #[serde_as(deserialize_as = "Bytes")]
+/// from_str: Vec<u8>,
+/// }
+///
+/// // Different serialized values ...
+/// let j = json!({
+/// "from_bytes": [70,111,111,45,66,97,114],
+/// "from_str": "Foo-Bar",
+/// });
+///
+/// // can be deserialized ...
+/// let test = Test {
+/// from_bytes: b"Foo-Bar".to_vec(),
+/// from_str: b"Foo-Bar".to_vec(),
+/// };
+/// assert_eq!(test, serde_json::from_value(j).unwrap());
+///
+/// // and serialization will always be a byte sequence
+/// # assert_eq!(json!(
+/// {
+/// "from_bytes": [70,111,111,45,66,97,114],
+/// "from_str": [70,111,111,45,66,97,114],
+/// }
+/// # ), serde_json::to_value(&test).unwrap());
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Bytes;
+
+/// Deserialize one or many elements
+///
+/// Sometimes it is desirable to have a shortcut in writing 1-element lists in a config file.
+/// Usually, this is done by either writing a list or the list element itself.
+/// This distinction is not semantically important on the Rust side, thus both forms should deserialize into the same `Vec`.
+///
+/// The `OneOrMany` adapter achieves exactly this use case.
+/// The serialization behavior can be tweaked to either always serialize as a list using `PreferMany` or to serialize as the inner element if possible using `PreferOne`.
+/// By default, `PreferOne` is assumed, which can also be omitted like `OneOrMany<_>`.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, OneOrMany};
+/// # use serde_with::formats::{PreferOne, PreferMany};
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, serde::Serialize)]
+/// struct Data {
+/// #[serde_as(deserialize_as = "OneOrMany<_, PreferOne>")]
+/// countries: Vec<String>,
+/// #[serde_as(deserialize_as = "OneOrMany<_, PreferMany>")]
+/// cities: Vec<String>,
+/// }
+///
+/// // The adapter allows deserializing a `Vec` from either
+/// // a single element
+/// let j = json!({
+/// "countries": "Spain",
+/// "cities": "Berlin",
+/// });
+/// assert!(serde_json::from_value::<Data>(j).is_ok());
+///
+/// // or from a list.
+/// let j = json!({
+/// "countries": ["Germany", "France"],
+/// "cities": ["Amsterdam"],
+/// });
+/// assert!(serde_json::from_value::<Data>(j).is_ok());
+///
+/// // For serialization you can choose how a single element should be encoded.
+/// // Either directly, with `PreferOne` (default), or as a list with `PreferMany`.
+/// let data = Data {
+/// countries: vec!["Spain".to_string()],
+/// cities: vec!["Berlin".to_string()],
+/// };
+/// let j = json!({
+/// "countries": "Spain",
+/// "cities": ["Berlin"],
+/// });
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct OneOrMany<T, FORMAT: formats::Format = formats::PreferOne>(PhantomData<(T, FORMAT)>);
+
+/// Try multiple deserialization options until one succeeds.
+///
+/// This adapter allows you to specify a list of deserialization options.
+/// They are tried in order and the first one working is applied.
+/// Serialization always picks the first option.
+///
+/// `PickFirst` has one type parameter which must be instantiated with a tuple of two, three, or four elements.
+/// For example, `PickFirst<(_, DisplayFromStr)>` on a field of type `u32` allows deserializing from a number or from a string via the `FromStr` trait.
+/// The value will be serialized as a number, since that is what the first type `_` indicates.
+///
+/// # Examples
+///
+/// Deserialize a number from either a number or a string.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, DisplayFromStr, PickFirst};
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Data {
+/// #[serde_as(as = "PickFirst<(_, DisplayFromStr)>")]
+/// as_number: u32,
+/// #[serde_as(as = "PickFirst<(DisplayFromStr, _)>")]
+/// as_string: u32,
+/// }
+/// let data = Data {
+/// as_number: 123,
+/// as_string: 456
+/// };
+///
+/// // Both fields can be deserialized from numbers:
+/// let j = json!({
+/// "as_number": 123,
+/// "as_string": 456,
+/// });
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+///
+/// // or from a string:
+/// let j = json!({
+/// "as_number": "123",
+/// "as_string": "456",
+/// });
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+///
+/// // For serialization the first type in the tuple determines the behavior.
+/// // The `as_number` field will use the normal `Serialize` behavior and produce a number,
+/// // while `as_string` used `Display` to produce a string.
+/// let expected = json!({
+/// "as_number": 123,
+/// "as_string": "456",
+/// });
+/// assert_eq!(expected, serde_json::to_value(&data).unwrap());
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct PickFirst<T>(PhantomData<T>);
+
+/// Serialize value by converting to/from a proxy type with serde support.
+///
+/// This adapter serializes a type `O` by converting it into a second type `T` and serializing `T`.
+/// Deserializing works analogue, by deserializing a `T` and then converting into `O`.
+///
+/// ```rust
+/// # #[cfg(FALSE)] {
+/// struct S {
+/// #[serde_as(as = "FromInto<T>")]
+/// value: O,
+/// }
+/// # }
+/// ```
+///
+/// For serialization `O` needs to be `O: Into<T> + Clone`.
+/// For deserialization the opposite `T: Into<O>` is required.
+/// The `Clone` bound is required since `serialize` operates on a reference but `Into` implementations on references are uncommon.
+///
+/// **Note**: [`TryFromInto`] is the more generalized version of this adapter which uses the [`TryInto`](std::convert::TryInto) trait instead.
+///
+/// # Example
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, FromInto};
+/// #
+/// #[derive(Clone, Debug, PartialEq)]
+/// struct Rgb {
+/// red: u8,
+/// green: u8,
+/// blue: u8,
+/// }
+///
+/// # /*
+/// impl From<(u8, u8, u8)> for Rgb { ... }
+/// impl From<Rgb> for (u8, u8, u8) { ... }
+/// # */
+/// #
+/// # impl From<(u8, u8, u8)> for Rgb {
+/// # fn from(v: (u8, u8, u8)) -> Self {
+/// # Rgb {
+/// # red: v.0,
+/// # green: v.1,
+/// # blue: v.2,
+/// # }
+/// # }
+/// # }
+/// #
+/// # impl From<Rgb> for (u8, u8, u8) {
+/// # fn from(v: Rgb) -> Self {
+/// # (v.red, v.green, v.blue)
+/// # }
+/// # }
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Color {
+/// #[serde_as(as = "FromInto<(u8, u8, u8)>")]
+/// rgb: Rgb,
+/// }
+/// let color = Color {
+/// rgb: Rgb {
+/// red: 128,
+/// green: 64,
+/// blue: 32,
+/// },
+/// };
+///
+/// // Define our expected JSON form
+/// let j = json!({
+/// "rgb": [128, 64, 32],
+/// });
+/// // Ensure serialization and deserialization produce the expected results
+/// assert_eq!(j, serde_json::to_value(&color).unwrap());
+/// assert_eq!(color, serde_json::from_value(j).unwrap());
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct FromInto<T>(PhantomData<T>);
+
+/// Serialize value by converting to/from a proxy type with serde support.
+///
+/// This adapter serializes a type `O` by converting it into a second type `T` and serializing `T`.
+/// Deserializing works analogue, by deserializing a `T` and then converting into `O`.
+///
+/// ```rust
+/// # #[cfg(FALSE)] {
+/// struct S {
+/// #[serde_as(as = "TryFromInto<T>")]
+/// value: O,
+/// }
+/// # }
+/// ```
+///
+/// For serialization `O` needs to be `O: TryInto<T> + Clone`.
+/// For deserialization the opposite `T: TryInto<O>` is required.
+/// The `Clone` bound is required since `serialize` operates on a reference but `TryInto` implementations on references are uncommon.
+/// In both cases the `TryInto::Error` type must implement [`Display`](std::fmt::Display).
+///
+/// **Note**: [`FromInto`] is the more specialized version of this adapter which uses the infallible [`Into`] trait instead.
+/// [`TryFromInto`] is strictly more general and can also be used where [`FromInto`] is applicable.
+/// The example shows a use case, when only the deserialization behavior is fallible, but not serializing.
+///
+/// # Example
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, TryFromInto};
+/// # use std::convert::TryFrom;
+/// #
+/// #[derive(Clone, Debug, PartialEq)]
+/// enum Boollike {
+/// True,
+/// False,
+/// }
+///
+/// # /*
+/// impl From<Boollike> for u8 { ... }
+/// # */
+/// #
+/// impl TryFrom<u8> for Boollike {
+/// type Error = String;
+/// fn try_from(v: u8) -> Result<Self, Self::Error> {
+/// match v {
+/// 0 => Ok(Boollike::False),
+/// 1 => Ok(Boollike::True),
+/// _ => Err(format!("Boolikes can only be constructed from 0 or 1 but found {}", v))
+/// }
+/// }
+/// }
+/// #
+/// # impl From<Boollike> for u8 {
+/// # fn from(v: Boollike) -> Self {
+/// # match v {
+/// # Boollike::True => 1,
+/// # Boollike::False => 0,
+/// # }
+/// # }
+/// # }
+///
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Data {
+/// #[serde_as(as = "TryFromInto<u8>")]
+/// b: Boollike,
+/// }
+/// let data = Data {
+/// b: Boollike::True,
+/// };
+///
+/// // Define our expected JSON form
+/// let j = json!({
+/// "b": 1,
+/// });
+/// // Ensure serialization and deserialization produce the expected results
+/// assert_eq!(j, serde_json::to_value(&data).unwrap());
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+///
+/// // Numbers besides 0 or 1 should be an error
+/// let j = json!({
+/// "b": 2,
+/// });
+/// assert_eq!("Boolikes can only be constructed from 0 or 1 but found 2", serde_json::from_value::<Data>(j).unwrap_err().to_string());
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct TryFromInto<T>(PhantomData<T>);
+
+/// Borrow `Cow` data during deserialization when possible.
+///
+/// The types `Cow<'a, [u8]>`, `Cow<'a, [u8; N]>`, and `Cow<'a, str>` can borrow from the input data during deserialization.
+/// serde supports this, by annotating the fields with `#[serde(borrow)]`. but does not support borrowing on nested types.
+/// This gap is filled by this `BorrowCow` adapter.
+///
+/// Using this adapter with `Cow<'a, [u8]>`/Cow<'a, [u8; N]>` will serialize the value as a sequence of `u8` values.
+/// This *might* not allow to borrow the data during deserialization.
+/// For a different format, which is also more efficient, use the [`Bytes`] adapter, which is also implemented for `Cow`.
+///
+/// When combined with the [`serde_as`] attribute, the `#[serde(borrow)]` annotation will be added automatically.
+/// If the annotation is wrong or too broad, for example because of multiple lifetime parameters, a manual annotation is required.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{serde_as, BorrowCow};
+/// # use std::borrow::Cow;
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Data<'a, 'b, 'c> {
+/// #[serde_as(as = "BorrowCow")]
+/// str: Cow<'a, str>,
+/// #[serde_as(as = "BorrowCow")]
+/// slice: Cow<'b, [u8]>,
+///
+/// #[serde_as(as = "Option<[BorrowCow; 1]>")]
+/// nested: Option<[Cow<'c, str>; 1]>,
+/// }
+/// let data = Data {
+/// str: "foobar".into(),
+/// slice: b"foobar"[..].into(),
+/// nested: Some(["HelloWorld".into()]),
+/// };
+///
+/// // Define our expected JSON form
+/// let j = r#"{
+/// "str": "foobar",
+/// "slice": [
+/// 102,
+/// 111,
+/// 111,
+/// 98,
+/// 97,
+/// 114
+/// ],
+/// "nested": [
+/// "HelloWorld"
+/// ]
+/// }"#;
+/// // Ensure serialization and deserialization produce the expected results
+/// assert_eq!(j, serde_json::to_string_pretty(&data).unwrap());
+/// assert_eq!(data, serde_json::from_str(j).unwrap());
+///
+/// // Cow borrows from the input data
+/// let deserialized: Data<'_, '_, '_> = serde_json::from_str(j).unwrap();
+/// assert!(matches!(deserialized.str, Cow::Borrowed(_)));
+/// assert!(matches!(deserialized.nested, Some([Cow::Borrowed(_)])));
+/// // JSON does not allow borrowing bytes, so `slice` does not borrow
+/// assert!(matches!(deserialized.slice, Cow::Owned(_)));
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct BorrowCow;
+
+/// Deserialize a sequence into `Vec<T>`, skipping elements which fail to deserialize.
+///
+/// The serialization behavior is identical to `Vec<T>`. This is an alternative to `Vec<T>`
+/// which is resilient against unexpected data.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::{serde_as, VecSkipError};
+/// #
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// # #[non_exhaustive]
+/// enum Color {
+/// Red,
+/// Green,
+/// Blue,
+/// }
+/// # use Color::*;
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Palette(#[serde_as(as = "VecSkipError<_>")] Vec<Color>);
+///
+/// let data = Palette(vec![Blue, Green,]);
+/// let source_json = r#"["Blue", "Yellow", "Green"]"#;
+/// let data_json = r#"["Blue","Green"]"#;
+/// // Ensure serialization and deserialization produce the expected results
+/// assert_eq!(data_json, serde_json::to_string(&data).unwrap());
+/// assert_eq!(data, serde_json::from_str(source_json).unwrap());
+/// # }
+/// ```
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct VecSkipError<T>(PhantomData<T>);
+
+/// Deserialize a boolean from a number
+///
+/// Deserialize a number (of `u8`) and turn it into a boolean.
+/// The adapter supports a [`Strict`](crate::formats::Strict) and [`Flexible`](crate::formats::Flexible) format.
+/// In `Strict` mode, the number must be `0` or `1`.
+/// All other values produce an error.
+/// In `Flexible` mode, the number any non-zero value is converted to `true`.
+///
+/// During serialization only `0` or `1` are ever emitted.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::{serde_as, BoolFromInt};
+/// #
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Data(#[serde_as(as = "BoolFromInt")] bool);
+///
+/// let data = Data(true);
+/// let j = json!(1);
+/// // Ensure serialization and deserialization produce the expected results
+/// assert_eq!(j, serde_json::to_value(&data).unwrap());
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+///
+/// // false maps to 0
+/// let data = Data(false);
+/// let j = json!(0);
+/// assert_eq!(j, serde_json::to_value(&data).unwrap());
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+//
+/// #[serde_as]
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Flexible(#[serde_as(as = "BoolFromInt<serde_with::formats::Flexible>")] bool);
+///
+/// // Flexible turns any non-zero number into true
+/// let data = Flexible(true);
+/// let j = json!(100);
+/// assert_eq!(data, serde_json::from_value(j).unwrap());
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, Default)]
+pub struct BoolFromInt<S: formats::Strictness = formats::Strict>(PhantomData<S>);
diff --git a/third_party/rust/serde_with/src/rust.rs b/third_party/rust/serde_with/src/rust.rs
new file mode 100644
index 0000000000..cb64f0da9f
--- /dev/null
+++ b/third_party/rust/serde_with/src/rust.rs
@@ -0,0 +1,1943 @@
+//! De/Serialization for Rust's builtin and std types
+
+use crate::{utils, Separator};
+#[cfg(doc)]
+use alloc::collections::BTreeMap;
+use alloc::{
+ string::{String, ToString},
+ vec::Vec,
+};
+use core::{
+ cmp::Eq,
+ fmt::{self, Display},
+ hash::Hash,
+ iter::FromIterator,
+ marker::PhantomData,
+ str::FromStr,
+};
+use serde::{
+ de::{Deserialize, DeserializeOwned, Deserializer, Error, MapAccess, SeqAccess, Visitor},
+ ser::{Serialize, Serializer},
+};
+#[cfg(doc)]
+use std::collections::HashMap;
+
+/// De/Serialize using [`Display`] and [`FromStr`] implementation
+///
+/// This allows deserializing a string as a number.
+/// It can be very useful for serialization formats like JSON, which do not support integer
+/// numbers and have to resort to strings to represent them.
+///
+/// If you control the type you want to de/serialize, you can instead use the two derive macros, [`SerializeDisplay`] and [`DeserializeFromStr`].
+/// They properly implement the traits [`Serialize`] and [`Deserialize`] such that user of the type no longer have to use the with-attribute.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed via [`DisplayFromStr`] and using the [`serde_as`] macro.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, DisplayFromStr};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde_as(as = "DisplayFromStr")]
+/// value: mime::Mime,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// ```rust
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::display_fromstr")]
+/// mime: mime::Mime,
+/// #[serde(with = "serde_with::rust::display_fromstr")]
+/// number: u32,
+/// }
+///
+/// let v: A = serde_json::from_str(r#"{
+/// "mime": "text/plain",
+/// "number": "159"
+/// }"#).unwrap();
+/// assert_eq!(mime::TEXT_PLAIN, v.mime);
+/// assert_eq!(159, v.number);
+///
+/// let x = A {
+/// mime: mime::STAR_STAR,
+/// number: 777,
+/// };
+/// assert_eq!(
+/// r#"{"mime":"*/*","number":"777"}"#,
+/// serde_json::to_string(&x).unwrap()
+/// );
+/// ```
+///
+/// [`DeserializeFromStr`]: serde_with_macros::DeserializeFromStr
+/// [`DisplayFromStr`]: crate::DisplayFromStr
+/// [`serde_as`]: crate::guide::serde_as
+/// [`SerializeDisplay`]: serde_with_macros::SerializeDisplay
+pub mod display_fromstr {
+ use super::*;
+
+ /// Deserialize T using [`FromStr`]
+ pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: FromStr,
+ T::Err: Display,
+ {
+ struct Helper<S>(PhantomData<S>);
+
+ impl<'de, S> Visitor<'de> for Helper<S>
+ where
+ S: FromStr,
+ <S as FromStr>::Err: Display,
+ {
+ type Value = S;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(formatter, "a string")
+ }
+
+ fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ value.parse::<Self::Value>().map_err(Error::custom)
+ }
+ }
+
+ deserializer.deserialize_str(Helper(PhantomData))
+ }
+
+ /// Serialize T using [Display]
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Display,
+ S: Serializer,
+ {
+ serializer.collect_str(&value)
+ }
+}
+
+/// De/Serialize sequences using [`FromIterator`] and [`IntoIterator`] implementation for it and [`Display`] and [`FromStr`] implementation for each element
+///
+/// This allows to serialize and deserialize collections with elements which can be represented as strings.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed via [`DisplayFromStr`] and using the [`serde_as`] macro.
+/// Instead of
+///
+/// ```rust,ignore
+/// #[serde(with = "serde_with::rust::seq_display_fromstr")]
+/// addresses: BTreeSet<Ipv4Addr>,
+/// ```
+/// you can write:
+/// ```rust,ignore
+/// #[serde_as(as = "BTreeSet<DisplayFromStr>")]
+/// addresses: BTreeSet<Ipv4Addr>,
+/// ```
+///
+/// This works for any container type, so also for `Vec`:
+/// ```rust,ignore
+/// #[serde_as(as = "Vec<DisplayFromStr>")]
+/// bs: Vec<bool>,
+/// ```
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// use std::collections::BTreeSet;
+/// use std::net::Ipv4Addr;
+///
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::seq_display_fromstr")]
+/// addresses: BTreeSet<Ipv4Addr>,
+/// #[serde(with = "serde_with::rust::seq_display_fromstr")]
+/// bs: Vec<bool>,
+/// }
+///
+/// let v: A = serde_json::from_str(r#"{
+/// "addresses": ["192.168.2.1", "192.168.2.2", "192.168.1.1", "192.168.2.2"],
+/// "bs": ["true", "false"]
+/// }"#).unwrap();
+/// assert_eq!(v.addresses.len(), 3);
+/// assert!(v.addresses.contains(&Ipv4Addr::new(192, 168, 2, 1)));
+/// assert!(v.addresses.contains(&Ipv4Addr::new(192, 168, 2, 2)));
+/// assert!(!v.addresses.contains(&Ipv4Addr::new(192, 168, 1, 2)));
+/// assert_eq!(v.bs.len(), 2);
+/// assert!(v.bs[0]);
+/// assert!(!v.bs[1]);
+///
+/// let x = A {
+/// addresses: vec![
+/// Ipv4Addr::new(127, 53, 0, 1),
+/// Ipv4Addr::new(127, 53, 1, 1),
+/// Ipv4Addr::new(127, 53, 0, 2)
+/// ].into_iter().collect(),
+/// bs: vec![false, true],
+/// };
+/// assert_eq!(
+/// r#"{"addresses":["127.53.0.1","127.53.0.2","127.53.1.1"],"bs":["false","true"]}"#,
+/// serde_json::to_string(&x).unwrap()
+/// );
+/// ```
+///
+/// [`DisplayFromStr`]: crate::DisplayFromStr
+/// [`serde_as`]: crate::guide::serde_as
+pub mod seq_display_fromstr {
+ use super::*;
+
+ /// Deserialize collection T using [FromIterator] and [FromStr] for each element
+ pub fn deserialize<'de, D, T, I>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: FromIterator<I> + Sized,
+ I: FromStr,
+ I::Err: Display,
+ {
+ struct Helper<S>(PhantomData<S>);
+
+ impl<'de, S> Visitor<'de> for Helper<S>
+ where
+ S: FromStr,
+ <S as FromStr>::Err: Display,
+ {
+ type Value = Vec<S>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(formatter, "a sequence")
+ }
+
+ fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ utils::SeqIter::new(seq)
+ .map(|res| {
+ res.and_then(|value: &str| value.parse::<S>().map_err(Error::custom))
+ })
+ .collect()
+ }
+ }
+
+ deserializer
+ .deserialize_seq(Helper(PhantomData))
+ .map(T::from_iter)
+ }
+
+ /// Serialize collection T using [IntoIterator] and [Display] for each element
+ pub fn serialize<S, T, I>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ for<'a> &'a T: IntoIterator<Item = &'a I>,
+ I: Display,
+ {
+ struct SerializeString<'a, I>(&'a I);
+
+ impl<'a, I> Serialize for SerializeString<'a, I>
+ where
+ I: Display,
+ {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_str(self.0)
+ }
+ }
+
+ serializer.collect_seq(value.into_iter().map(SerializeString))
+ }
+}
+
+/// De/Serialize a delimited collection using [`Display`] and [`FromStr`] implementation
+///
+/// You can define an arbitrary separator, by specifying a type which implements [`Separator`].
+/// Some common ones, like space and comma are already predefined and you can find them [here][Separator].
+///
+/// An empty string deserializes as an empty collection.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can also be expressed using the [`serde_as`] macro.
+/// The usage is slightly different.
+/// `StringWithSeparator` takes a second type, which needs to implement [`Display`]+[`FromStr`] and constitutes the inner type of the collection.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, SpaceSeparator, StringWithSeparator};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde_as(as = "StringWithSeparator::<SpaceSeparator, String>")]
+/// tags: Vec<String>,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// use serde_with::{CommaSeparator, SpaceSeparator};
+/// use std::collections::BTreeSet;
+///
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::StringWithSeparator::<SpaceSeparator>")]
+/// tags: Vec<String>,
+/// #[serde(with = "serde_with::rust::StringWithSeparator::<CommaSeparator>")]
+/// more_tags: BTreeSet<String>,
+/// }
+///
+/// let v: A = serde_json::from_str(r##"{
+/// "tags": "#hello #world",
+/// "more_tags": "foo,bar,bar"
+/// }"##).unwrap();
+/// assert_eq!(vec!["#hello", "#world"], v.tags);
+/// assert_eq!(2, v.more_tags.len());
+///
+/// let x = A {
+/// tags: vec!["1".to_string(), "2".to_string(), "3".to_string()],
+/// more_tags: BTreeSet::new(),
+/// };
+/// assert_eq!(
+/// r#"{"tags":"1 2 3","more_tags":""}"#,
+/// serde_json::to_string(&x).unwrap()
+/// );
+/// ```
+///
+/// [`serde_as`]: crate::guide::serde_as
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
+pub struct StringWithSeparator<Sep, T = ()>(PhantomData<(Sep, T)>);
+
+impl<Sep> StringWithSeparator<Sep>
+where
+ Sep: Separator,
+{
+ /// Serialize collection into a string with separator symbol
+ pub fn serialize<S, T, V>(values: T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ T: IntoIterator<Item = V>,
+ V: Display,
+ {
+ let mut s = String::new();
+ for v in values {
+ s.push_str(&*v.to_string());
+ s.push_str(Sep::separator());
+ }
+ serializer.serialize_str(if !s.is_empty() {
+ // remove trailing separator if present
+ &s[..s.len() - Sep::separator().len()]
+ } else {
+ &s[..]
+ })
+ }
+
+ /// Deserialize a collection from a string with separator symbol
+ pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: FromIterator<V>,
+ V: FromStr,
+ V::Err: Display,
+ {
+ let s = String::deserialize(deserializer)?;
+ if s.is_empty() {
+ Ok(None.into_iter().collect())
+ } else {
+ s.split(Sep::separator())
+ .map(FromStr::from_str)
+ .collect::<Result<_, _>>()
+ .map_err(Error::custom)
+ }
+ }
+}
+
+/// Makes a distinction between a missing, unset, or existing value
+///
+/// Some serialization formats make a distinction between missing fields, fields with a `null`
+/// value, and existing values. One such format is JSON. By default it is not easily possible to
+/// differentiate between a missing value and a field which is `null`, as they deserialize to the
+/// same value. This helper changes it, by using an `Option<Option<T>>` to deserialize into.
+///
+/// * `None`: Represents a missing value.
+/// * `Some(None)`: Represents a `null` value.
+/// * `Some(Some(value))`: Represents an existing value.
+///
+/// # Examples
+///
+/// ```rust
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// # #[derive(Debug, PartialEq, Eq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Doc {
+/// #[serde(
+/// default, // <- important for deserialization
+/// skip_serializing_if = "Option::is_none", // <- important for serialization
+/// with = "::serde_with::rust::double_option",
+/// )]
+/// a: Option<Option<u8>>,
+/// }
+/// // Missing Value
+/// let s = r#"{}"#;
+/// assert_eq!(Doc { a: None }, serde_json::from_str(s).unwrap());
+/// assert_eq!(s, serde_json::to_string(&Doc { a: None }).unwrap());
+///
+/// // Unset Value
+/// let s = r#"{"a":null}"#;
+/// assert_eq!(Doc { a: Some(None) }, serde_json::from_str(s).unwrap());
+/// assert_eq!(s, serde_json::to_string(&Doc { a: Some(None) }).unwrap());
+///
+/// // Existing Value
+/// let s = r#"{"a":5}"#;
+/// assert_eq!(Doc { a: Some(Some(5)) }, serde_json::from_str(s).unwrap());
+/// assert_eq!(s, serde_json::to_string(&Doc { a: Some(Some(5)) }).unwrap());
+/// ```
+#[allow(clippy::option_option)]
+pub mod double_option {
+ use super::*;
+
+ /// Deserialize potentially non-existing optional value
+ pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
+ where
+ T: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ Deserialize::deserialize(deserializer).map(Some)
+ }
+
+ /// Serialize optional value
+ pub fn serialize<S, T>(values: &Option<Option<T>>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ T: Serialize,
+ {
+ match values {
+ None => serializer.serialize_unit(),
+ Some(None) => serializer.serialize_none(),
+ Some(Some(v)) => serializer.serialize_some(&v),
+ }
+ }
+}
+
+/// Serialize inner value if [`Some`]`(T)`. If [`None`], serialize the unit struct `()`.
+///
+/// When used in conjunction with `skip_serializing_if = "Option::is_none"` and
+/// `default`, you can build an optional value by skipping if it is [`None`], or serializing its
+/// inner value if [`Some`]`(T)`.
+///
+/// Not all serialization formats easily support optional values.
+/// While JSON uses the [`Option`] type to represent optional values and only serializes the inner
+/// part of the [`Some`]`()`, other serialization formats, such as [RON][], choose to serialize the
+/// [`Some`] around a value.
+/// This helper helps building a truly optional value for such serializers.
+///
+/// [RON]: https://github.com/ron-rs/ron
+///
+/// # Example
+///
+/// ```rust
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// # #[derive(Debug, Eq, PartialEq)]
+/// #[derive(Deserialize, Serialize)]
+/// struct Doc {
+/// mandatory: usize,
+/// #[serde(
+/// default, // <- important for deserialization
+/// skip_serializing_if = "Option::is_none", // <- important for serialization
+/// with = "::serde_with::rust::unwrap_or_skip",
+/// )]
+/// optional: Option<usize>,
+/// }
+///
+/// // Transparently add/remove Some() wrapper
+/// # let pretty_config = ron::ser::PrettyConfig::new()
+/// # .new_line("\n".into());
+/// let s = r#"(
+/// mandatory: 1,
+/// optional: 2,
+/// )"#;
+/// let v = Doc {
+/// mandatory: 1,
+/// optional: Some(2),
+/// };
+/// assert_eq!(v, ron::de::from_str(s).unwrap());
+/// assert_eq!(s, ron::ser::to_string_pretty(&v, pretty_config).unwrap());
+///
+/// // Missing values are deserialized as `None`
+/// // while `None` values are skipped during serialization.
+/// # let pretty_config = ron::ser::PrettyConfig::new()
+/// # .new_line("\n".into());
+/// let s = r#"(
+/// mandatory: 1,
+/// )"#;
+/// let v = Doc {
+/// mandatory: 1,
+/// optional: None,
+/// };
+/// assert_eq!(v, ron::de::from_str(s).unwrap());
+/// assert_eq!(s, ron::ser::to_string_pretty(&v, pretty_config).unwrap());
+/// ```
+pub mod unwrap_or_skip {
+ use super::*;
+
+ /// Deserialize value wrapped in Some(T)
+ pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: DeserializeOwned,
+ {
+ T::deserialize(deserializer).map(Some)
+ }
+
+ /// Serialize value if Some(T), unit struct if None
+ pub fn serialize<T, S>(option: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ if let Some(value) = option {
+ value.serialize(serializer)
+ } else {
+ ().serialize(serializer)
+ }
+ }
+}
+
+/// Ensure no duplicate values exist in a set.
+///
+/// By default serde has a last-value-wins implementation, if duplicate values for a set exist.
+/// Sometimes it is desirable to know when such an event happens, as the first value is overwritten
+/// and it can indicate an error in the serialized data.
+///
+/// This helper returns an error if two identical values exist in a set.
+///
+/// The implementation supports both the [`HashSet`] and the [`BTreeSet`] from the standard library.
+///
+/// [`HashSet`]: std::collections::HashSet
+/// [`BTreeSet`]: std::collections::HashSet
+///
+/// # Example
+///
+/// ```rust
+/// # use std::{collections::HashSet, iter::FromIterator};
+/// # use serde::Deserialize;
+/// #
+/// # #[derive(Debug, Eq, PartialEq)]
+/// #[derive(Deserialize)]
+/// struct Doc {
+/// #[serde(with = "::serde_with::rust::sets_duplicate_value_is_error")]
+/// set: HashSet<usize>,
+/// }
+///
+/// // Sets are serialized normally,
+/// let s = r#"{"set": [1, 2, 3, 4]}"#;
+/// let v = Doc {
+/// set: HashSet::from_iter(vec![1, 2, 3, 4]),
+/// };
+/// assert_eq!(v, serde_json::from_str(s).unwrap());
+///
+/// // but create an error if duplicate values, like the `1`, exist.
+/// let s = r#"{"set": [1, 2, 3, 4, 1]}"#;
+/// let res: Result<Doc, _> = serde_json::from_str(s);
+/// assert!(res.is_err());
+/// ```
+pub mod sets_duplicate_value_is_error {
+ use super::*;
+ use crate::duplicate_key_impls::PreventDuplicateInsertsSet;
+
+ /// Deserialize a set and return an error on duplicate values
+ pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error>
+ where
+ T: PreventDuplicateInsertsSet<V>,
+ V: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ struct SeqVisitor<T, V> {
+ marker: PhantomData<T>,
+ set_item_type: PhantomData<V>,
+ }
+
+ impl<'de, T, V> Visitor<'de> for SeqVisitor<T, V>
+ where
+ T: PreventDuplicateInsertsSet<V>,
+ V: Deserialize<'de>,
+ {
+ type Value = T;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ #[inline]
+ fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let mut values = Self::Value::new(access.size_hint());
+
+ while let Some(value) = access.next_element()? {
+ if !values.insert(value) {
+ return Err(Error::custom("invalid entry: found duplicate value"));
+ };
+ }
+
+ Ok(values)
+ }
+ }
+
+ let visitor = SeqVisitor {
+ marker: PhantomData,
+ set_item_type: PhantomData,
+ };
+ deserializer.deserialize_seq(visitor)
+ }
+
+ /// Serialize the set with the default serializer
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// Ensure no duplicate keys exist in a map.
+///
+/// By default serde has a last-value-wins implementation, if duplicate keys for a map exist.
+/// Sometimes it is desirable to know when such an event happens, as the first value is overwritten
+/// and it can indicate an error in the serialized data.
+///
+/// This helper returns an error if two identical keys exist in a map.
+///
+/// The implementation supports both the [`HashMap`] and the [`BTreeMap`] from the standard library.
+///
+/// [`HashMap`]: std::collections::HashMap
+/// [`BTreeMap`]: std::collections::HashMap
+///
+/// # Example
+///
+/// ```rust
+/// # use serde::Deserialize;
+/// # use std::collections::HashMap;
+/// #
+/// # #[derive(Debug, Eq, PartialEq)]
+/// #[derive(Deserialize)]
+/// struct Doc {
+/// #[serde(with = "::serde_with::rust::maps_duplicate_key_is_error")]
+/// map: HashMap<usize, usize>,
+/// }
+///
+/// // Maps are serialized normally,
+/// let s = r#"{"map": {"1": 1, "2": 2, "3": 3}}"#;
+/// let mut v = Doc {
+/// map: HashMap::new(),
+/// };
+/// v.map.insert(1, 1);
+/// v.map.insert(2, 2);
+/// v.map.insert(3, 3);
+/// assert_eq!(v, serde_json::from_str(s).unwrap());
+///
+/// // but create an error if duplicate keys, like the `1`, exist.
+/// let s = r#"{"map": {"1": 1, "2": 2, "1": 3}}"#;
+/// let res: Result<Doc, _> = serde_json::from_str(s);
+/// assert!(res.is_err());
+/// ```
+pub mod maps_duplicate_key_is_error {
+ use super::*;
+ use crate::duplicate_key_impls::PreventDuplicateInsertsMap;
+
+ /// Deserialize a map and return an error on duplicate keys
+ pub fn deserialize<'de, D, T, K, V>(deserializer: D) -> Result<T, D::Error>
+ where
+ T: PreventDuplicateInsertsMap<K, V>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ struct MapVisitor<T, K, V> {
+ marker: PhantomData<T>,
+ map_key_type: PhantomData<K>,
+ map_value_type: PhantomData<V>,
+ }
+
+ impl<'de, T, K, V> Visitor<'de> for MapVisitor<T, K, V>
+ where
+ T: PreventDuplicateInsertsMap<K, V>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ {
+ type Value = T;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a map")
+ }
+
+ #[inline]
+ fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ let mut values = Self::Value::new(access.size_hint());
+
+ while let Some((key, value)) = access.next_entry()? {
+ if !values.insert(key, value) {
+ return Err(Error::custom("invalid entry: found duplicate key"));
+ };
+ }
+
+ Ok(values)
+ }
+ }
+
+ let visitor = MapVisitor {
+ marker: PhantomData,
+ map_key_type: PhantomData,
+ map_value_type: PhantomData,
+ };
+ deserializer.deserialize_map(visitor)
+ }
+
+ /// Serialize the map with the default serializer
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// *DEPRECATED* Ensure that the first value is taken, if duplicate values exist
+///
+/// This module implements the default behavior in serde.
+#[deprecated = "This module does nothing. Remove the attribute. Serde's default behavior is to use the first value when deserializing a set."]
+#[allow(deprecated)]
+pub mod sets_first_value_wins {
+ use super::*;
+ use crate::duplicate_key_impls::DuplicateInsertsFirstWinsSet;
+
+ /// Deserialize a set and keep the first of equal values
+ #[deprecated = "This function does nothing. Remove the attribute. Serde's default behavior is to use the first value when deserializing a set."]
+ pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error>
+ where
+ T: DuplicateInsertsFirstWinsSet<V>,
+ V: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ struct SeqVisitor<T, V> {
+ marker: PhantomData<T>,
+ set_item_type: PhantomData<V>,
+ }
+
+ impl<'de, T, V> Visitor<'de> for SeqVisitor<T, V>
+ where
+ T: DuplicateInsertsFirstWinsSet<V>,
+ V: Deserialize<'de>,
+ {
+ type Value = T;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ #[inline]
+ fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let mut values = Self::Value::new(access.size_hint());
+
+ while let Some(value) = access.next_element()? {
+ values.insert(value);
+ }
+
+ Ok(values)
+ }
+ }
+
+ let visitor = SeqVisitor {
+ marker: PhantomData,
+ set_item_type: PhantomData,
+ };
+ deserializer.deserialize_seq(visitor)
+ }
+
+ /// Serialize the set with the default serializer
+ #[deprecated = "This function does nothing. Remove the attribute. Serde's default behavior is to use the first value when deserializing a set."]
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// Ensure that the last value is taken, if duplicate values exist
+///
+/// By default serde has a first-value-wins implementation, if duplicate keys for a set exist.
+/// Sometimes the opposite strategy is desired. This helper implements a first-value-wins strategy.
+///
+/// The implementation supports both the [`HashSet`] and the [`BTreeSet`] from the standard library.
+///
+/// [`HashSet`]: std::collections::HashSet
+/// [`BTreeSet`]: std::collections::HashSet
+pub mod sets_last_value_wins {
+ use super::*;
+ use crate::duplicate_key_impls::DuplicateInsertsLastWinsSet;
+
+ /// Deserialize a set and keep the last of equal values
+ pub fn deserialize<'de, D, T, V>(deserializer: D) -> Result<T, D::Error>
+ where
+ T: DuplicateInsertsLastWinsSet<V>,
+ V: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ struct SeqVisitor<T, V> {
+ marker: PhantomData<T>,
+ set_item_type: PhantomData<V>,
+ }
+
+ impl<'de, T, V> Visitor<'de> for SeqVisitor<T, V>
+ where
+ T: DuplicateInsertsLastWinsSet<V>,
+ V: Deserialize<'de>,
+ {
+ type Value = T;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a sequence")
+ }
+
+ #[inline]
+ fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let mut values = Self::Value::new(access.size_hint());
+
+ while let Some(value) = access.next_element()? {
+ values.replace(value);
+ }
+
+ Ok(values)
+ }
+ }
+
+ let visitor = SeqVisitor {
+ marker: PhantomData,
+ set_item_type: PhantomData,
+ };
+ deserializer.deserialize_seq(visitor)
+ }
+
+ /// Serialize the set with the default serializer
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// Ensure that the first key is taken, if duplicate keys exist
+///
+/// By default serde has a last-key-wins implementation, if duplicate keys for a map exist.
+/// Sometimes the opposite strategy is desired. This helper implements a first-key-wins strategy.
+///
+/// The implementation supports both the [`HashMap`] and the [`BTreeMap`] from the standard library.
+///
+/// [`HashMap`]: std::collections::HashMap
+/// [`BTreeMap`]: std::collections::HashMap
+///
+/// # Example
+///
+/// ```rust
+/// # use serde::Deserialize;
+/// # use std::collections::HashMap;
+/// #
+/// # #[derive(Debug, Eq, PartialEq)]
+/// #[derive(Deserialize)]
+/// struct Doc {
+/// #[serde(with = "::serde_with::rust::maps_first_key_wins")]
+/// map: HashMap<usize, usize>,
+/// }
+///
+/// // Maps are serialized normally,
+/// let s = r#"{"map": {"1": 1, "2": 2, "3": 3}}"#;
+/// let mut v = Doc {
+/// map: HashMap::new(),
+/// };
+/// v.map.insert(1, 1);
+/// v.map.insert(2, 2);
+/// v.map.insert(3, 3);
+/// assert_eq!(v, serde_json::from_str(s).unwrap());
+///
+/// // but create an error if duplicate keys, like the `1`, exist.
+/// let s = r#"{"map": {"1": 1, "2": 2, "1": 3}}"#;
+/// let mut v = Doc {
+/// map: HashMap::new(),
+/// };
+/// v.map.insert(1, 1);
+/// v.map.insert(2, 2);
+/// assert_eq!(v, serde_json::from_str(s).unwrap());
+/// ```
+pub mod maps_first_key_wins {
+ use super::*;
+ use crate::duplicate_key_impls::DuplicateInsertsFirstWinsMap;
+
+ /// Deserialize a map and return an error on duplicate keys
+ pub fn deserialize<'de, D, T, K, V>(deserializer: D) -> Result<T, D::Error>
+ where
+ T: DuplicateInsertsFirstWinsMap<K, V>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ struct MapVisitor<T, K, V> {
+ marker: PhantomData<T>,
+ map_key_type: PhantomData<K>,
+ map_value_type: PhantomData<V>,
+ }
+
+ impl<'de, T, K, V> Visitor<'de> for MapVisitor<T, K, V>
+ where
+ T: DuplicateInsertsFirstWinsMap<K, V>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ {
+ type Value = T;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a map")
+ }
+
+ #[inline]
+ fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ let mut values = Self::Value::new(access.size_hint());
+
+ while let Some((key, value)) = access.next_entry()? {
+ values.insert(key, value);
+ }
+
+ Ok(values)
+ }
+ }
+
+ let visitor = MapVisitor {
+ marker: PhantomData,
+ map_key_type: PhantomData,
+ map_value_type: PhantomData,
+ };
+ deserializer.deserialize_map(visitor)
+ }
+
+ /// Serialize the map with the default serializer
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// De/Serialize a [`Option<String>`] type while transforming the empty string to [`None`]
+///
+/// Convert an [`Option<T>`] from/to string using [`FromStr`] and [`AsRef<str>`] implementations.
+/// An empty string is deserialized as [`None`] and a [`None`] vice versa.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed via [`NoneAsEmptyString`] and using the [`serde_as`] macro.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, NoneAsEmptyString};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde_as(as = "NoneAsEmptyString")]
+/// value: Option<String>,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use serde_with::rust::string_empty_as_none;
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "string_empty_as_none")]
+/// tags: Option<String>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({ "tags": "" })).unwrap();
+/// assert_eq!(None, v.tags);
+///
+/// let v: A = serde_json::from_value(json!({ "tags": "Hi" })).unwrap();
+/// assert_eq!(Some("Hi".to_string()), v.tags);
+///
+/// let x = A {
+/// tags: Some("This is text".to_string()),
+/// };
+/// assert_eq!(json!({ "tags": "This is text" }), serde_json::to_value(&x).unwrap());
+///
+/// let x = A {
+/// tags: None,
+/// };
+/// assert_eq!(json!({ "tags": "" }), serde_json::to_value(&x).unwrap());
+/// ```
+///
+/// [`NoneAsEmptyString`]: crate::NoneAsEmptyString
+/// [`serde_as`]: crate::guide::serde_as
+pub mod string_empty_as_none {
+ use super::*;
+
+ /// Deserialize an `Option<T>` from a string using `FromStr`
+ pub fn deserialize<'de, D, S>(deserializer: D) -> Result<Option<S>, D::Error>
+ where
+ D: Deserializer<'de>,
+ S: FromStr,
+ S::Err: Display,
+ {
+ struct OptionStringEmptyNone<S>(PhantomData<S>);
+ impl<'de, S> Visitor<'de> for OptionStringEmptyNone<S>
+ where
+ S: FromStr,
+ S::Err: Display,
+ {
+ type Value = Option<S>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("any string")
+ }
+
+ fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match value {
+ "" => Ok(None),
+ v => S::from_str(v).map(Some).map_err(Error::custom),
+ }
+ }
+
+ fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ match &*value {
+ "" => Ok(None),
+ v => S::from_str(v).map(Some).map_err(Error::custom),
+ }
+ }
+
+ // handles the `null` case
+ fn visit_unit<E>(self) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ Ok(None)
+ }
+ }
+
+ deserializer.deserialize_any(OptionStringEmptyNone(PhantomData))
+ }
+
+ /// Serialize a string from `Option<T>` using `AsRef<str>` or using the empty string if `None`.
+ pub fn serialize<T, S>(option: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: AsRef<str>,
+ S: Serializer,
+ {
+ if let Some(value) = option {
+ value.as_ref().serialize(serializer)
+ } else {
+ "".serialize(serializer)
+ }
+ }
+}
+
+/// De/Serialize a Map into a list of tuples
+///
+/// Some formats, like JSON, have limitations on the type of keys for maps.
+/// In case of JSON, keys are restricted to strings.
+/// Rust features more powerful keys, for example tuple, which can not be serialized to JSON.
+///
+/// This helper serializes the Map into a list of tuples, which does not have the same type restrictions.
+/// The module can be applied on any type implementing `IntoIterator<Item = (&'a K, &'a V)>` and `FromIterator<(K, V)>`, with `K` and `V` being the key and value types.
+/// From the standard library both [`HashMap`] and [`BTreeMap`] fullfil the condition and can be used here.
+///
+/// ## Converting to `serde_as`
+///
+/// If the map is of type [`HashMap`] or [`BTreeMap`] the same functionality can be expressed more clearly using the [`serde_as`] macro.
+/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::serde_as;
+/// # use std::collections::{BTreeMap, HashMap};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "Vec<(_, _)>")]
+/// hashmap: HashMap<(String, u32), u32>,
+/// #[serde_as(as = "Vec<(_, _)>")]
+/// btreemap: BTreeMap<(String, u32), u32>,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use std::collections::BTreeMap;
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::map_as_tuple_list")]
+/// s: BTreeMap<(String, u32), u32>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({
+/// "s": [
+/// [["Hello", 123], 0],
+/// [["World", 456], 1]
+/// ]
+/// })).unwrap();
+///
+/// assert_eq!(2, v.s.len());
+/// assert_eq!(1, v.s[&("World".to_string(), 456)]);
+/// ```
+///
+/// The helper is generic over the hasher type of the [`HashMap`] and works with different variants, such as `FnvHashMap`.
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// #
+/// use fnv::FnvHashMap;
+///
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::map_as_tuple_list")]
+/// s: FnvHashMap<u32, bool>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({
+/// "s": [
+/// [0, false],
+/// [1, true]
+/// ]
+/// })).unwrap();
+///
+/// assert_eq!(2, v.s.len());
+/// assert_eq!(true, v.s[&1]);
+/// ```
+///
+/// [`serde_as`]: crate::guide::serde_as
+pub mod map_as_tuple_list {
+ // Trait bounds based on this answer: https://stackoverflow.com/a/66600486/15470286
+ use super::*;
+
+ /// Serialize the map as a list of tuples
+ pub fn serialize<'a, T, K, V, S>(map: T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ T: IntoIterator<Item = (&'a K, &'a V)>,
+ T::IntoIter: ExactSizeIterator,
+ K: Serialize + 'a,
+ V: Serialize + 'a,
+ {
+ serializer.collect_seq(map)
+ }
+
+ /// Deserialize a map from a list of tuples
+ pub fn deserialize<'de, T, K, V, D>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: FromIterator<(K, V)>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ {
+ struct SeqVisitor<T, K, V>(PhantomData<(T, K, V)>);
+
+ impl<'de, T, K, V> Visitor<'de> for SeqVisitor<T, K, V>
+ where
+ T: FromIterator<(K, V)>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ {
+ type Value = T;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a list of key-value pairs")
+ }
+
+ fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ utils::SeqIter::new(seq).collect()
+ }
+ }
+
+ deserializer.deserialize_seq(SeqVisitor(PhantomData))
+ }
+}
+
+/// DEPRECATED De/Serialize a [`HashMap`] into a list of tuples
+///
+/// Use the [`map_as_tuple_list`] module which is more general than this.
+/// It should work with everything convertible to and from an `Iterator` including [`BTreeMap`] and [`HashMap`].
+///
+/// ---
+///
+/// Some formats, like JSON, have limitations on the type of keys for maps.
+/// In case of JSON, keys are restricted to strings.
+/// Rust features more powerful keys, for example tuple, which can not be serialized to JSON.
+///
+/// This helper serializes the [`HashMap`] into a list of tuples, which does not have the same type restrictions.
+///
+/// If you need to de/serialize a [`BTreeMap`] then use [`btreemap_as_tuple_list`].
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed using the [`serde_as`] macro.
+/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::serde_as;
+/// # use std::collections::HashMap;
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "Vec<(_, _)>")]
+/// s: HashMap<(String, u32), u32>,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use std::collections::HashMap;
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::hashmap_as_tuple_list")]
+/// s: HashMap<(String, u32), u32>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({
+/// "s": [
+/// [["Hello", 123], 0],
+/// [["World", 456], 1]
+/// ]
+/// })).unwrap();
+///
+/// assert_eq!(2, v.s.len());
+/// assert_eq!(1, v.s[&("World".to_string(), 456)]);
+/// ```
+///
+/// The helper is generic over the hasher type of the [`HashMap`] and works with different variants, such as `FnvHashMap`.
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// #
+/// use fnv::FnvHashMap;
+///
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::hashmap_as_tuple_list")]
+/// s: FnvHashMap<u32, bool>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({
+/// "s": [
+/// [0, false],
+/// [1, true]
+/// ]
+/// })).unwrap();
+///
+/// assert_eq!(2, v.s.len());
+/// assert_eq!(true, v.s[&1]);
+/// ```
+///
+/// [`serde_as`]: crate::guide::serde_as
+#[deprecated(
+ since = "1.8.0",
+ note = "Use the more general map_as_tuple_list module."
+)]
+pub mod hashmap_as_tuple_list {
+ #[doc(inline)]
+ #[deprecated(
+ since = "1.8.0",
+ note = "Use the more general map_as_tuple_list::deserialize function."
+ )]
+ pub use super::map_as_tuple_list::deserialize;
+ #[doc(inline)]
+ #[deprecated(
+ since = "1.8.0",
+ note = "Use the more general map_as_tuple_list::serialize function."
+ )]
+ pub use super::map_as_tuple_list::serialize;
+}
+
+/// DEPRECATED De/Serialize a [`BTreeMap`] into a list of tuples
+///
+/// Use the [`map_as_tuple_list`] module which is more general than this.
+/// It should work with everything convertible to and from an `Iterator` including [`BTreeMap`] and [`HashMap`].
+///
+/// ---
+///
+/// Some formats, like JSON, have limitations on the type of keys for maps.
+/// In case of JSON, keys are restricted to strings.
+/// Rust features more powerful keys, for example tuple, which can not be serialized to JSON.
+///
+/// This helper serializes the [`BTreeMap`] into a list of tuples, which does not have the same type restrictions.
+///
+/// If you need to de/serialize a [`HashMap`] then use [`hashmap_as_tuple_list`].
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed using the [`serde_as`] macro.
+/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::serde_as;
+/// # use std::collections::BTreeMap;
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde_as(as = "Vec<(_, _)>")]
+/// s: BTreeMap<(String, u32), u32>,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_json::json;
+/// # use std::collections::BTreeMap;
+/// #
+/// #[derive(Deserialize, Serialize)]
+/// struct A {
+/// #[serde(with = "serde_with::rust::btreemap_as_tuple_list")]
+/// s: BTreeMap<(String, u32), u32>,
+/// }
+///
+/// let v: A = serde_json::from_value(json!({
+/// "s": [
+/// [["Hello", 123], 0],
+/// [["World", 456], 1]
+/// ]
+/// })).unwrap();
+///
+/// assert_eq!(2, v.s.len());
+/// assert_eq!(1, v.s[&("World".to_string(), 456)]);
+/// ```
+///
+/// [`serde_as`]: crate::guide::serde_as
+#[deprecated(
+ since = "1.8.0",
+ note = "Use the more general map_as_tuple_list module."
+)]
+pub mod btreemap_as_tuple_list {
+ #[doc(inline)]
+ #[deprecated(
+ since = "1.8.0",
+ note = "Use the more general map_as_tuple_list::deserialize function."
+ )]
+ pub use super::map_as_tuple_list::deserialize;
+ #[doc(inline)]
+ #[deprecated(
+ since = "1.8.0",
+ note = "Use the more general map_as_tuple_list::serialize function."
+ )]
+ pub use super::map_as_tuple_list::serialize;
+}
+
+/// This serializes a list of tuples into a map and back
+///
+/// Normally, you want to use a [`HashMap`] or a [`BTreeMap`] when deserializing a map.
+/// However, sometimes this is not possible due to type contains, e.g., if the type implements neither [`Hash`] nor [`Ord`].
+/// Another use case is deserializing a map with duplicate keys.
+///
+/// The implementation is generic using the [`FromIterator`] and [`IntoIterator`] traits.
+/// Therefore, all of [`Vec`], [`VecDeque`](std::collections::VecDeque), and [`LinkedList`](std::collections::LinkedList) and anything which implements those are supported.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed using the [`serde_as`] macro.
+/// The `_` is a placeholder which works for any type which implements [`Serialize`]/[`Deserialize`], such as the tuple and `u32` type.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Deserialize, Serialize};
+/// # use serde_with::serde_as;
+/// # use std::collections::BTreeMap;
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize, Serialize)]
+/// struct S {
+/// #[serde_as(as = "BTreeMap<_, _>")] // HashMap will also work
+/// s: Vec<(i32, String)>,
+/// }
+/// # }
+/// ```
+///
+/// # Examples
+///
+/// `Wrapper` does not implement [`Hash`] nor [`Ord`], thus prohibiting the use [`HashMap`] or [`BTreeMap`].
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// #[derive(Debug, Deserialize, Serialize, Default)]
+/// struct S {
+/// #[serde(with = "serde_with::rust::tuple_list_as_map")]
+/// s: Vec<(Wrapper<i32>, Wrapper<String>)>,
+/// }
+///
+/// #[derive(Clone, Debug, Serialize, Deserialize)]
+/// #[serde(transparent)]
+/// struct Wrapper<T>(T);
+///
+/// let from = r#"{
+/// "s": {
+/// "1": "Hi",
+/// "2": "Cake",
+/// "99": "Lie"
+/// }
+/// }"#;
+/// let mut expected = S::default();
+/// expected.s.push((Wrapper(1), Wrapper("Hi".into())));
+/// expected.s.push((Wrapper(2), Wrapper("Cake".into())));
+/// expected.s.push((Wrapper(99), Wrapper("Lie".into())));
+///
+/// let res: S = serde_json::from_str(from).unwrap();
+/// for ((exp_k, exp_v), (res_k, res_v)) in expected.s.iter().zip(&res.s) {
+/// assert_eq!(exp_k.0, res_k.0);
+/// assert_eq!(exp_v.0, res_v.0);
+/// }
+/// assert_eq!(from, serde_json::to_string_pretty(&expected).unwrap());
+/// ```
+///
+/// In this example, the serialized format contains duplicate keys, which is not supported with [`HashMap`] or [`BTreeMap`].
+///
+/// ```
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// #[derive(Debug, Deserialize, Serialize, PartialEq, Default)]
+/// struct S {
+/// #[serde(with = "serde_with::rust::tuple_list_as_map")]
+/// s: Vec<(i32, String)>,
+/// }
+///
+/// let from = r#"{
+/// "s": {
+/// "1": "Hi",
+/// "1": "Cake",
+/// "1": "Lie"
+/// }
+/// }"#;
+/// let mut expected = S::default();
+/// expected.s.push((1, "Hi".into()));
+/// expected.s.push((1, "Cake".into()));
+/// expected.s.push((1, "Lie".into()));
+///
+/// let res: S = serde_json::from_str(from).unwrap();
+/// assert_eq!(3, res.s.len());
+/// assert_eq!(expected, res);
+/// assert_eq!(from, serde_json::to_string_pretty(&expected).unwrap());
+/// ```
+///
+/// [`serde_as`]: crate::guide::serde_as
+pub mod tuple_list_as_map {
+ use super::*;
+
+ /// Serialize any iteration of tuples into a map.
+ pub fn serialize<'a, I, K, V, S>(iter: I, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ I: IntoIterator<Item = &'a (K, V)>,
+ I::IntoIter: ExactSizeIterator,
+ K: Serialize + 'a,
+ V: Serialize + 'a,
+ S: Serializer,
+ {
+ // Convert &(K, V) to (&K, &V) for collect_map.
+ let iter = iter.into_iter().map(|(k, v)| (k, v));
+ serializer.collect_map(iter)
+ }
+
+ /// Deserialize a map into an iterator of tuples.
+ pub fn deserialize<'de, I, K, V, D>(deserializer: D) -> Result<I, D::Error>
+ where
+ I: FromIterator<(K, V)>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_map(MapVisitor(PhantomData))
+ }
+
+ #[allow(clippy::type_complexity)]
+ struct MapVisitor<I, K, V>(PhantomData<fn() -> (I, K, V)>);
+
+ impl<'de, I, K, V> Visitor<'de> for MapVisitor<I, K, V>
+ where
+ I: FromIterator<(K, V)>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+ {
+ type Value = I;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a map")
+ }
+
+ fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ utils::MapIter::new(map).collect()
+ }
+ }
+}
+
+/// Deserialize from bytes or string
+///
+/// Any Rust [`String`] can be converted into bytes, i.e., `Vec<u8>`.
+/// Accepting both as formats while deserializing can be helpful while interacting with language
+/// which have a looser definition of string than Rust.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed via [`BytesOrString`] and using the [`serde_as`] macro.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, BytesOrString};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde_as(as = "BytesOrString")]
+/// bos: Vec<u8>,
+/// }
+/// # }
+/// ```
+///
+/// # Example
+/// ```rust
+/// # use serde::{Deserialize, Serialize};
+/// #
+/// #[derive(Debug, Deserialize, Serialize, PartialEq, Default)]
+/// struct S {
+/// #[serde(deserialize_with = "serde_with::rust::bytes_or_string::deserialize")]
+/// bos: Vec<u8>,
+/// }
+///
+/// // Here we deserialize from a byte array ...
+/// let from = r#"{
+/// "bos": [
+/// 0,
+/// 1,
+/// 2,
+/// 3
+/// ]
+/// }"#;
+/// let expected = S {
+/// bos: vec![0, 1, 2, 3],
+/// };
+///
+/// let res: S = serde_json::from_str(from).unwrap();
+/// assert_eq!(expected, res);
+///
+/// // and serialization works too.
+/// assert_eq!(from, serde_json::to_string_pretty(&expected).unwrap());
+///
+/// // But we also support deserializing from a String
+/// let from = r#"{
+/// "bos": "✨Works!"
+/// }"#;
+/// let expected = S {
+/// bos: "✨Works!".as_bytes().to_vec(),
+/// };
+///
+/// let res: S = serde_json::from_str(from).unwrap();
+/// assert_eq!(expected, res);
+/// ```
+///
+/// [`BytesOrString`]: crate::BytesOrString
+/// [`serde_as`]: crate::guide::serde_as
+pub mod bytes_or_string {
+ use super::*;
+
+ /// Deserialize a [`Vec<u8>`] from either bytes or string
+ pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_any(BytesOrStringVisitor)
+ }
+
+ struct BytesOrStringVisitor;
+
+ impl<'de> Visitor<'de> for BytesOrStringVisitor {
+ type Value = Vec<u8>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a list of bytes or a string")
+ }
+
+ fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> {
+ Ok(v.to_vec())
+ }
+
+ fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> {
+ Ok(v)
+ }
+
+ fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> {
+ Ok(v.as_bytes().to_vec())
+ }
+
+ fn visit_string<E>(self, v: String) -> Result<Self::Value, E> {
+ Ok(v.into_bytes())
+ }
+
+ fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ utils::SeqIter::new(seq).collect()
+ }
+ }
+}
+
+/// Deserialize value and return [`Default`] on error
+///
+/// The main use case is ignoring error while deserializing.
+/// Instead of erroring, it simply deserializes the [`Default`] variant of the type.
+/// It is not possible to find the error location, i.e., which field had a deserialization error, with this method.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed via [`DefaultOnError`] and using the [`serde_as`] macro.
+/// It can be combined with other converts as shown.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, DefaultOnError, DisplayFromStr};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde_as(as = "DefaultOnError")]
+/// value: u32,
+/// #[serde_as(as = "DefaultOnError<DisplayFromStr>")]
+/// value2: u32,
+/// }
+/// # }
+/// ```
+///
+/// [`DefaultOnError`]: crate::DefaultOnError
+/// [`serde_as`]: crate::guide::serde_as
+///
+/// # Examples
+///
+/// ```
+/// # use serde::Deserialize;
+/// #
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde(deserialize_with = "serde_with::rust::default_on_error::deserialize")]
+/// value: u32,
+/// }
+///
+/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap();
+/// assert_eq!(123, a.value);
+///
+/// // null is of invalid type
+/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // String is of invalid type
+/// let a: A = serde_json::from_str(r#"{"value": "123"}"#).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // Map is of invalid type
+/// let a: A = serde_json::from_str(r#"{"value": {}}"#).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // Missing entries still cause errors
+/// assert!(serde_json::from_str::<A>(r#"{ }"#).is_err());
+/// ```
+///
+/// Deserializing missing values can be supported by adding the `default` field attribute:
+///
+/// ```
+/// # use serde::Deserialize;
+/// #
+/// #[derive(Deserialize)]
+/// struct B {
+/// #[serde(default, deserialize_with = "serde_with::rust::default_on_error::deserialize")]
+/// value: u32,
+/// }
+///
+/// let b: B = serde_json::from_str(r#"{ }"#).unwrap();
+/// assert_eq!(0, b.value);
+/// ```
+pub mod default_on_error {
+ use super::*;
+
+ /// Deserialize T and return the [`Default`] value on error
+ pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: Deserialize<'de> + Default,
+ {
+ #[derive(Debug, serde::Deserialize)]
+ #[serde(untagged)]
+ enum GoodOrError<T> {
+ Good(T),
+ // This consumes one "item" when `T` errors while deserializing.
+ // This is necessary to make this work, when instead of having a direct value
+ // like integer or string, the deserializer sees a list or map.
+ Error(serde::de::IgnoredAny),
+ }
+
+ Ok(match Deserialize::deserialize(deserializer) {
+ Ok(GoodOrError::Good(res)) => res,
+ _ => Default::default(),
+ })
+ }
+
+ /// Serialize value with the default serializer
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// Deserialize default value if encountering `null`.
+///
+/// One use case are JSON APIs in which the `null` value represents some default state.
+/// This adapter allows to turn the `null` directly into the [`Default`] value of the type.
+///
+/// ## Converting to `serde_as`
+///
+/// The same functionality can be more clearly expressed via [`DefaultOnNull`] and using the [`serde_as`] macro.
+/// It can be combined with other convertes as shown.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::Deserialize;
+/// # use serde_with::{serde_as, DefaultOnNull, DisplayFromStr};
+/// #
+/// #[serde_as]
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde_as(as = "DefaultOnNull")]
+/// value: u32,
+/// #[serde_as(as = "DefaultOnNull<DisplayFromStr>")]
+/// value2: u32,
+/// }
+/// # }
+/// ```
+///
+/// [`DefaultOnNull`]: crate::DefaultOnNull
+/// [`serde_as`]: crate::guide::serde_as
+///
+/// # Examples
+///
+/// ```
+/// # use serde::Deserialize;
+/// #
+/// #[derive(Deserialize)]
+/// struct A {
+/// #[serde(deserialize_with = "serde_with::rust::default_on_null::deserialize")]
+/// value: u32,
+/// }
+///
+/// let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap();
+/// assert_eq!(123, a.value);
+///
+/// let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap();
+/// assert_eq!(0, a.value);
+///
+/// // String is invalid type
+/// assert!(serde_json::from_str::<A>(r#"{"value": "123"}"#).is_err());
+/// ```
+pub mod default_on_null {
+ use super::*;
+
+ /// Deserialize T and return the [`Default`] value if original value is `null`
+ pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+ where
+ D: Deserializer<'de>,
+ T: Deserialize<'de> + Default,
+ {
+ Ok(Option::deserialize(deserializer)?.unwrap_or_default())
+ }
+
+ /// Serialize value with the default serializer
+ pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ value.serialize(serializer)
+ }
+}
+
+/// Deserialize any value, ignore it, and return the default value for the type being deserialized.
+///
+/// This function can be used in two different ways:
+///
+/// 1. It is useful for instance to create an enum with a catch-all variant that will accept any incoming data.
+/// 2. [`untagged`] enum representations do not allow the `other` annotation as the fallback enum variant.
+/// With this function you can emulate an `other` variant, which can deserialize any data carrying enum.
+///
+/// **Note:** Using this function will prevent deserializing data-less enum variants.
+/// If this is a problem depends on the data format.
+/// For example, deserializing `"Bar"` as an enum in JSON would fail, since it carries no data.
+///
+/// # Examples
+///
+/// ## Deserializing a heterogeneous collection of XML nodes
+///
+/// When [`serde-xml-rs`] deserializes an XML tag to an enum, it always maps the tag
+/// name to the enum variant name, and the tag attributes and children to the enum contents.
+/// This means that in order for an enum variant to accept any XML tag, it both has to use
+/// `#[serde(other)]` to accept any tag name, and `#[serde(deserialize_with = "deserialize_ignore_any")]`
+/// to accept any attributes and children.
+///
+/// ```rust
+/// # use serde::Deserialize;
+/// use serde_with::rust::deserialize_ignore_any;
+///
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize)]
+/// #[serde(rename_all = "lowercase")]
+/// enum Item {
+/// Foo(String),
+/// Bar(String),
+/// #[serde(other, deserialize_with = "deserialize_ignore_any")]
+/// Other,
+/// }
+///
+/// // Deserialize this XML
+/// # let items: Vec<Item> = serde_xml_rs::from_str(
+/// r"
+/// <foo>a</foo>
+/// <bar>b</bar>
+/// <foo>c</foo>
+/// <unknown>d</unknown>
+/// "
+/// # ).unwrap();
+///
+/// // into these Items
+/// # let expected =
+/// vec![
+/// Item::Foo(String::from("a")),
+/// Item::Bar(String::from("b")),
+/// Item::Foo(String::from("c")),
+/// Item::Other,
+/// ]
+/// # ;
+/// # assert_eq!(expected, items);
+/// ```
+///
+/// ## Simulating an `other` enum variant in an `untagged` enum
+///
+/// ```rust
+/// # use serde::Deserialize;
+/// # use serde_json::json;
+/// use serde_with::rust::deserialize_ignore_any;
+///
+/// # #[derive(Debug, PartialEq)]
+/// #[derive(Deserialize)]
+/// #[serde(untagged)]
+/// enum Item {
+/// Foo{x: u8},
+/// #[serde(deserialize_with = "deserialize_ignore_any")]
+/// Other,
+/// }
+///
+/// // Deserialize this JSON
+/// # let items: Vec<Item> = serde_json::from_value(
+/// json!([
+/// {"y": 1},
+/// {"x": 1},
+/// ])
+/// # ).unwrap();
+///
+/// // into these Items
+/// # let expected =
+/// vec![Item::Other, Item::Foo{x: 1}]
+/// # ;
+/// # assert_eq!(expected, items);
+/// ```
+///
+/// [`serde-xml-rs`]: https://docs.rs/serde-xml-rs
+/// [`untagged`]: https://serde.rs/enum-representations.html#untagged
+pub fn deserialize_ignore_any<'de, D: Deserializer<'de>, T: Default>(
+ deserializer: D,
+) -> Result<T, D::Error> {
+ serde::de::IgnoredAny::deserialize(deserializer).map(|_| T::default())
+}
diff --git a/third_party/rust/serde_with/src/ser/const_arrays.rs b/third_party/rust/serde_with/src/ser/const_arrays.rs
new file mode 100644
index 0000000000..b864f2b7e5
--- /dev/null
+++ b/third_party/rust/serde_with/src/ser/const_arrays.rs
@@ -0,0 +1,90 @@
+use super::*;
+use alloc::{borrow::Cow, boxed::Box, collections::BTreeMap};
+use std::collections::HashMap;
+
+impl<T, As, const N: usize> SerializeAs<[T; N]> for [As; N]
+where
+ As: SerializeAs<T>,
+{
+ fn serialize_as<S>(array: &[T; N], serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ use serde::ser::SerializeTuple;
+ let mut arr = serializer.serialize_tuple(N)?;
+ for elem in array {
+ arr.serialize_element(&SerializeAsWrap::<T, As>::new(elem))?;
+ }
+ arr.end()
+ }
+}
+
+macro_rules! tuple_seq_as_map_impl_intern {
+ ($tyorig:ty, $ty:ident <K, V>) => {
+ #[allow(clippy::implicit_hasher)]
+ impl<K, KAs, V, VAs, const N: usize> SerializeAs<$tyorig> for $ty<KAs, VAs>
+ where
+ KAs: SerializeAs<K>,
+ VAs: SerializeAs<V>,
+ {
+ fn serialize_as<S>(source: &$tyorig, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_map(source.iter().map(|(k, v)| {
+ (
+ SerializeAsWrap::<K, KAs>::new(k),
+ SerializeAsWrap::<V, VAs>::new(v),
+ )
+ }))
+ }
+ }
+ };
+}
+tuple_seq_as_map_impl_intern!([(K, V); N], BTreeMap<K, V>);
+tuple_seq_as_map_impl_intern!([(K, V); N], HashMap<K, V>);
+
+impl<const N: usize> SerializeAs<[u8; N]> for Bytes {
+ fn serialize_as<S>(bytes: &[u8; N], serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(bytes)
+ }
+}
+
+impl<const N: usize> SerializeAs<&[u8; N]> for Bytes {
+ fn serialize_as<S>(bytes: &&[u8; N], serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(*bytes)
+ }
+}
+
+impl<const N: usize> SerializeAs<Box<[u8; N]>> for Bytes {
+ fn serialize_as<S>(bytes: &Box<[u8; N]>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(&**bytes)
+ }
+}
+
+impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for Bytes {
+ fn serialize_as<S>(bytes: &Cow<'a, [u8; N]>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(bytes.as_ref())
+ }
+}
+
+impl<'a, const N: usize> SerializeAs<Cow<'a, [u8; N]>> for BorrowCow {
+ fn serialize_as<S>(value: &Cow<'a, [u8; N]>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_seq(value.iter())
+ }
+}
diff --git a/third_party/rust/serde_with/src/ser/impls.rs b/third_party/rust/serde_with/src/ser/impls.rs
new file mode 100644
index 0000000000..16a8fb913c
--- /dev/null
+++ b/third_party/rust/serde_with/src/ser/impls.rs
@@ -0,0 +1,739 @@
+use super::*;
+use crate::{
+ formats::Strictness, rust::StringWithSeparator, utils::duration::DurationSigned, Separator,
+};
+use alloc::{
+ borrow::Cow,
+ boxed::Box,
+ collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque},
+ rc::{Rc, Weak as RcWeak},
+ string::{String, ToString},
+ sync::{Arc, Weak as ArcWeak},
+ vec::Vec,
+};
+use core::{
+ cell::{Cell, RefCell},
+ convert::TryInto,
+ fmt::Display,
+ time::Duration,
+};
+#[cfg(feature = "indexmap")]
+use indexmap_crate::{IndexMap, IndexSet};
+use serde::ser::Error;
+use std::{
+ collections::{HashMap, HashSet},
+ sync::{Mutex, RwLock},
+ time::SystemTime,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// region: Simple Wrapper types (e.g., Box, Option)
+
+impl<'a, T, U> SerializeAs<&'a T> for &'a U
+where
+ U: SerializeAs<T>,
+ T: ?Sized,
+ U: ?Sized,
+{
+ fn serialize_as<S>(source: &&'a T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, U>::new(source).serialize(serializer)
+ }
+}
+
+impl<'a, T, U> SerializeAs<&'a mut T> for &'a mut U
+where
+ U: SerializeAs<T>,
+ T: ?Sized,
+ U: ?Sized,
+{
+ fn serialize_as<S>(source: &&'a mut T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, U>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<Box<T>> for Box<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, U>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<Option<T>> for Option<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match *source {
+ Some(ref value) => serializer.serialize_some(&SerializeAsWrap::<T, U>::new(value)),
+ None => serializer.serialize_none(),
+ }
+ }
+}
+
+impl<T, U> SerializeAs<Rc<T>> for Rc<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Rc<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, U>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<RcWeak<T>> for RcWeak<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &RcWeak<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<Option<Rc<T>>, Option<Rc<U>>>::new(&source.upgrade())
+ .serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<Arc<T>> for Arc<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Arc<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, U>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<ArcWeak<T>> for ArcWeak<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &ArcWeak<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<Option<Arc<T>>, Option<Arc<U>>>::new(&source.upgrade())
+ .serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<Cell<T>> for Cell<U>
+where
+ U: SerializeAs<T>,
+ T: Copy,
+{
+ fn serialize_as<S>(source: &Cell<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, U>::new(&source.get()).serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<RefCell<T>> for RefCell<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &RefCell<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match source.try_borrow() {
+ Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer),
+ Err(_) => Err(S::Error::custom("already mutably borrowed")),
+ }
+ }
+}
+
+impl<T, U> SerializeAs<Mutex<T>> for Mutex<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Mutex<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match source.lock() {
+ Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer),
+ Err(_) => Err(S::Error::custom("lock poison error while serializing")),
+ }
+ }
+}
+
+impl<T, U> SerializeAs<RwLock<T>> for RwLock<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &RwLock<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match source.read() {
+ Ok(source) => SerializeAsWrap::<T, U>::new(&*source).serialize(serializer),
+ Err(_) => Err(S::Error::custom("lock poison error while serializing")),
+ }
+ }
+}
+
+impl<T, TAs, E, EAs> SerializeAs<Result<T, E>> for Result<TAs, EAs>
+where
+ TAs: SerializeAs<T>,
+ EAs: SerializeAs<E>,
+{
+ fn serialize_as<S>(source: &Result<T, E>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source
+ .as_ref()
+ .map(SerializeAsWrap::<T, TAs>::new)
+ .map_err(SerializeAsWrap::<E, EAs>::new)
+ .serialize(serializer)
+ }
+}
+
+// endregion
+///////////////////////////////////////////////////////////////////////////////
+// region: Collection Types (e.g., Maps, Sets, Vec)
+
+macro_rules! seq_impl {
+ ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident )* >) => {
+ impl<T, U $(, $typaram)*> SerializeAs<$ty<T $(, $typaram)*>> for $ty<U $(, $typaram)*>
+ where
+ U: SerializeAs<T>,
+ $(T: ?Sized + $tbound1 $(+ $tbound2)*,)*
+ $($typaram: ?Sized + $bound,)*
+ {
+ fn serialize_as<S>(source: &$ty<T $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_seq(source.iter().map(|item| SerializeAsWrap::<T, U>::new(item)))
+ }
+ }
+ }
+}
+
+type BoxedSlice<T> = Box<[T]>;
+type Slice<T> = [T];
+seq_impl!(BinaryHeap<T>);
+seq_impl!(BoxedSlice<T>);
+seq_impl!(BTreeSet<T>);
+seq_impl!(HashSet<T, H: Sized>);
+seq_impl!(LinkedList<T>);
+seq_impl!(Slice<T>);
+seq_impl!(Vec<T>);
+seq_impl!(VecDeque<T>);
+#[cfg(feature = "indexmap")]
+seq_impl!(IndexSet<T, H: Sized>);
+
+macro_rules! map_impl {
+ ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => {
+ impl<K, KU, V, VU $(, $typaram)*> SerializeAs<$ty<K, V $(, $typaram)*>> for $ty<KU, VU $(, $typaram)*>
+ where
+ KU: SerializeAs<K>,
+ VU: SerializeAs<V>,
+ $(K: ?Sized + $kbound1 $(+ $kbound2)*,)*
+ $($typaram: ?Sized + $bound,)*
+ {
+ fn serialize_as<S>(source: &$ty<K, V $(, $typaram)*>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_map(source.iter().map(|(k, v)| (SerializeAsWrap::<K, KU>::new(k), SerializeAsWrap::<V, VU>::new(v))))
+ }
+ }
+ }
+}
+
+map_impl!(BTreeMap<K, V>);
+map_impl!(HashMap<K, V, H: Sized>);
+#[cfg(feature = "indexmap")]
+map_impl!(IndexMap<K, V, H: Sized>);
+
+macro_rules! tuple_impl {
+ ($len:literal $($n:tt $t:ident $tas:ident)+) => {
+ impl<$($t, $tas,)+> SerializeAs<($($t,)+)> for ($($tas,)+)
+ where
+ $($tas: SerializeAs<$t>,)+
+ {
+ fn serialize_as<S>(tuple: &($($t,)+), serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ use serde::ser::SerializeTuple;
+ let mut tup = serializer.serialize_tuple($len)?;
+ $(
+ tup.serialize_element(&SerializeAsWrap::<$t, $tas>::new(&tuple.$n))?;
+ )+
+ tup.end()
+ }
+ }
+ };
+}
+
+tuple_impl!(1 0 T0 As0);
+tuple_impl!(2 0 T0 As0 1 T1 As1);
+tuple_impl!(3 0 T0 As0 1 T1 As1 2 T2 As2);
+tuple_impl!(4 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3);
+tuple_impl!(5 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4);
+tuple_impl!(6 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5);
+tuple_impl!(7 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6);
+tuple_impl!(8 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7);
+tuple_impl!(9 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8);
+tuple_impl!(10 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9);
+tuple_impl!(11 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10);
+tuple_impl!(12 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11);
+tuple_impl!(13 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12);
+tuple_impl!(14 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13);
+tuple_impl!(15 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14);
+tuple_impl!(16 0 T0 As0 1 T1 As1 2 T2 As2 3 T3 As3 4 T4 As4 5 T5 As5 6 T6 As6 7 T7 As7 8 T8 As8 9 T9 As9 10 T10 As10 11 T11 As11 12 T12 As12 13 T13 As13 14 T14 As14 15 T15 As15);
+
+macro_rules! map_as_tuple_seq {
+ ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V >) => {
+ impl<K, KAs, V, VAs> SerializeAs<$ty<K, V>> for Vec<(KAs, VAs)>
+ where
+ KAs: SerializeAs<K>,
+ VAs: SerializeAs<V>,
+ {
+ fn serialize_as<S>(source: &$ty<K, V>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_seq(source.iter().map(|(k, v)| {
+ (
+ SerializeAsWrap::<K, KAs>::new(k),
+ SerializeAsWrap::<V, VAs>::new(v),
+ )
+ }))
+ }
+ }
+ };
+}
+map_as_tuple_seq!(BTreeMap<K, V>);
+// TODO HashMap with a custom hasher support would be better, but results in "unconstrained type parameter"
+map_as_tuple_seq!(HashMap<K, V>);
+#[cfg(feature = "indexmap")]
+map_as_tuple_seq!(IndexMap<K, V>);
+
+// endregion
+///////////////////////////////////////////////////////////////////////////////
+// region: Conversion types which cause different serialization behavior
+
+impl<T> SerializeAs<T> for Same
+where
+ T: Serialize + ?Sized,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source.serialize(serializer)
+ }
+}
+
+impl<T> SerializeAs<T> for DisplayFromStr
+where
+ T: Display,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ crate::rust::display_fromstr::serialize(source, serializer)
+ }
+}
+
+impl<T, U> SerializeAs<Vec<T>> for VecSkipError<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ Vec::<U>::serialize_as(source, serializer)
+ }
+}
+
+impl<AsRefStr> SerializeAs<Option<AsRefStr>> for NoneAsEmptyString
+where
+ AsRefStr: AsRef<str>,
+{
+ fn serialize_as<S>(source: &Option<AsRefStr>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ crate::rust::string_empty_as_none::serialize(source, serializer)
+ }
+}
+
+macro_rules! tuple_seq_as_map_impl_intern {
+ ($tyorig:ty, $ty:ident <K, V>) => {
+ #[allow(clippy::implicit_hasher)]
+ impl<K, KAs, V, VAs> SerializeAs<$tyorig> for $ty<KAs, VAs>
+ where
+ KAs: SerializeAs<K>,
+ VAs: SerializeAs<V>,
+ {
+ fn serialize_as<S>(source: &$tyorig, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_map(source.iter().map(|(k, v)| {
+ (
+ SerializeAsWrap::<K, KAs>::new(k),
+ SerializeAsWrap::<V, VAs>::new(v),
+ )
+ }))
+ }
+ }
+ };
+}
+macro_rules! tuple_seq_as_map_impl {
+ ($($ty:ty $(,)?)+) => {$(
+ tuple_seq_as_map_impl_intern!($ty, BTreeMap<K, V>);
+ tuple_seq_as_map_impl_intern!($ty, HashMap<K, V>);
+ )+}
+}
+
+tuple_seq_as_map_impl! {
+ BinaryHeap<(K, V)>,
+ BTreeSet<(K, V)>,
+ LinkedList<(K, V)>,
+ Option<(K, V)>,
+ Vec<(K, V)>,
+ VecDeque<(K, V)>,
+}
+tuple_seq_as_map_impl!(HashSet<(K, V)>);
+#[cfg(feature = "indexmap")]
+tuple_seq_as_map_impl!(IndexSet<(K, V)>);
+
+impl<T, TAs> SerializeAs<T> for DefaultOnError<TAs>
+where
+ TAs: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ TAs::serialize_as(source, serializer)
+ }
+}
+
+impl SerializeAs<Vec<u8>> for BytesOrString {
+ fn serialize_as<S>(source: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source.serialize(serializer)
+ }
+}
+
+impl<SEPARATOR, I, T> SerializeAs<I> for StringWithSeparator<SEPARATOR, T>
+where
+ SEPARATOR: Separator,
+ for<'a> &'a I: IntoIterator<Item = &'a T>,
+ T: ToString,
+{
+ fn serialize_as<S>(source: &I, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let mut s = String::new();
+ for v in source {
+ s.push_str(&*v.to_string());
+ s.push_str(SEPARATOR::separator());
+ }
+ serializer.serialize_str(if !s.is_empty() {
+ // remove trailing separator if present
+ &s[..s.len() - SEPARATOR::separator().len()]
+ } else {
+ &s[..]
+ })
+ }
+}
+
+macro_rules! use_signed_duration {
+ (
+ $main_trait:ident $internal_trait:ident =>
+ {
+ $ty:ty =>
+ $({
+ $format:ty, $strictness:ty =>
+ $($tbound:ident: $bound:ident $(,)?)*
+ })*
+ }
+ ) => {
+ $(
+ impl<$($tbound,)*> SerializeAs<$ty> for $main_trait<$format, $strictness>
+ where
+ $($tbound: $bound,)*
+ {
+ fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ $internal_trait::<$format, $strictness>::serialize_as(
+ &DurationSigned::from(source),
+ serializer,
+ )
+ }
+ }
+ )*
+ };
+ (
+ $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
+ ) => {
+ $( use_signed_duration!($main_trait $internal_trait => $rest); )+
+ };
+}
+
+use_signed_duration!(
+ DurationSeconds DurationSeconds,
+ DurationMilliSeconds DurationMilliSeconds,
+ DurationMicroSeconds DurationMicroSeconds,
+ DurationNanoSeconds DurationNanoSeconds,
+ => {
+ Duration =>
+ {u64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_signed_duration!(
+ DurationSecondsWithFrac DurationSecondsWithFrac,
+ DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ Duration =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+
+use_signed_duration!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ SystemTime =>
+ {i64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_signed_duration!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ SystemTime =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+
+impl<T, U> SerializeAs<T> for DefaultOnNull<U>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_some(&SerializeAsWrap::<T, U>::new(source))
+ }
+}
+
+impl SerializeAs<&[u8]> for Bytes {
+ fn serialize_as<S>(bytes: &&[u8], serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(bytes)
+ }
+}
+
+impl SerializeAs<Vec<u8>> for Bytes {
+ fn serialize_as<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(bytes)
+ }
+}
+
+impl SerializeAs<Box<[u8]>> for Bytes {
+ fn serialize_as<S>(bytes: &Box<[u8]>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(bytes)
+ }
+}
+
+impl<'a> SerializeAs<Cow<'a, [u8]>> for Bytes {
+ fn serialize_as<S>(bytes: &Cow<'a, [u8]>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_bytes(bytes)
+ }
+}
+
+impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, formats::PreferOne>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match source.len() {
+ 1 => SerializeAsWrap::<T, U>::new(source.iter().next().expect("Cannot be empty"))
+ .serialize(serializer),
+ _ => SerializeAsWrap::<Vec<T>, Vec<U>>::new(source).serialize(serializer),
+ }
+ }
+}
+
+impl<T, U> SerializeAs<Vec<T>> for OneOrMany<U, formats::PreferMany>
+where
+ U: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<Vec<T>, Vec<U>>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, TAs1> SerializeAs<T> for PickFirst<(TAs1,)>
+where
+ TAs1: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, TAs1, TAs2> SerializeAs<T> for PickFirst<(TAs1, TAs2)>
+where
+ TAs1: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, TAs1, TAs2, TAs3> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3)>
+where
+ TAs1: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, TAs1, TAs2, TAs3, TAs4> SerializeAs<T> for PickFirst<(TAs1, TAs2, TAs3, TAs4)>
+where
+ TAs1: SerializeAs<T>,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ SerializeAsWrap::<T, TAs1>::new(source).serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<T> for FromInto<U>
+where
+ T: Into<U> + Clone,
+ U: Serialize,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source.clone().into().serialize(serializer)
+ }
+}
+
+impl<T, U> SerializeAs<T> for TryFromInto<U>
+where
+ T: TryInto<U> + Clone,
+ <T as TryInto<U>>::Error: Display,
+ U: Serialize,
+{
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source
+ .clone()
+ .try_into()
+ .map_err(S::Error::custom)?
+ .serialize(serializer)
+ }
+}
+
+impl<'a> SerializeAs<Cow<'a, str>> for BorrowCow {
+ fn serialize_as<S>(source: &Cow<'a, str>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_str(source)
+ }
+}
+
+impl<'a> SerializeAs<Cow<'a, [u8]>> for BorrowCow {
+ fn serialize_as<S>(value: &Cow<'a, [u8]>, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_seq(value.iter())
+ }
+}
+
+impl<STRICTNESS: Strictness> SerializeAs<bool> for BoolFromInt<STRICTNESS> {
+ fn serialize_as<S>(source: &bool, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.serialize_u8(*source as u8)
+ }
+}
+
+// endregion
diff --git a/third_party/rust/serde_with/src/ser/legacy_arrays.rs b/third_party/rust/serde_with/src/ser/legacy_arrays.rs
new file mode 100644
index 0000000000..2c228ee640
--- /dev/null
+++ b/third_party/rust/serde_with/src/ser/legacy_arrays.rs
@@ -0,0 +1,34 @@
+use super::*;
+use alloc::collections::BTreeMap;
+use std::collections::HashMap;
+
+macro_rules! array_impl {
+ ($($len:literal)+) => {$(
+ impl<T, As> SerializeAs<[T; $len]> for [As; $len]
+ where
+ As: SerializeAs<T>,
+ {
+ fn serialize_as<S>(array: &[T; $len], serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ use serde::ser::SerializeTuple;
+ let mut arr = serializer.serialize_tuple($len)?;
+ for elem in array {
+ arr.serialize_element(&SerializeAsWrap::<T, As>::new(elem))?;
+ }
+ arr.end()
+ }
+ }
+ )+};
+}
+
+array_impl!(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32);
+
+tuple_seq_as_map_impl! {
+ [(K, V); 0], [(K, V); 1], [(K, V); 2], [(K, V); 3], [(K, V); 4], [(K, V); 5], [(K, V); 6],
+ [(K, V); 7], [(K, V); 8], [(K, V); 9], [(K, V); 10], [(K, V); 11], [(K, V); 12], [(K, V); 13],
+ [(K, V); 14], [(K, V); 15], [(K, V); 16], [(K, V); 17], [(K, V); 18], [(K, V); 19], [(K, V); 20],
+ [(K, V); 21], [(K, V); 22], [(K, V); 23], [(K, V); 24], [(K, V); 25], [(K, V); 26], [(K, V); 27],
+ [(K, V); 28], [(K, V); 29], [(K, V); 30], [(K, V); 31], [(K, V); 32],
+}
diff --git a/third_party/rust/serde_with/src/ser/mod.rs b/third_party/rust/serde_with/src/ser/mod.rs
new file mode 100644
index 0000000000..dda0891e89
--- /dev/null
+++ b/third_party/rust/serde_with/src/ser/mod.rs
@@ -0,0 +1,158 @@
+//! Module for [`SerializeAs`][] implementations
+//!
+//! The module contains the [`SerializeAs`][] trait and helper code.
+//! Additionally, it contains implementations of [`SerializeAs`][] for types defined in the Rust Standard Library or this crate.
+//!
+//! You can find more details on how to implement this trait for your types in the documentation of the [`SerializeAs`][] trait and details about the usage in the [user guide][].
+//!
+//! [user guide]: crate::guide
+
+mod const_arrays;
+#[macro_use]
+mod impls;
+
+use super::*;
+
+/// A **data structure** that can be serialized into any data format supported by Serde, analogue to [`Serialize`].
+///
+/// The trait is analogue to the [`serde::Serialize`][`Serialize`] trait, with the same meaning of input and output arguments.
+/// It can and should the implemented using the same code structure as the [`Serialize`] trait.
+/// As such, the same advice for [implementing `Serialize`][impl-serialize] applies here.
+///
+/// # Differences to [`Serialize`]
+///
+/// The trait is only required for container-like types or types implementing specific conversion functions.
+/// Container-like types are [`Vec`], [`BTreeMap`], but also [`Option`] and [`Box`].
+/// Conversion types serialize into a different serde data type.
+/// For example, [`DisplayFromStr`] uses the [`Display`] trait to serialize a String and [`DurationSeconds`] converts a [`Duration`] into either String or integer values.
+///
+/// This code shows how to implement [`Serialize`] for [`Box`]:
+///
+/// ```rust,ignore
+/// impl<T> Serialize for Box<T>
+/// where
+/// T: Serialize,
+/// {
+/// #[inline]
+/// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+/// where
+/// S: Serializer,
+/// {
+/// (**self).serialize(serializer)
+/// }
+/// }
+/// ```
+///
+/// and this code shows how to do the same using [`SerializeAs`][]:
+///
+/// ```rust,ignore
+/// impl<T, U> SerializeAs<Box<T>> for Box<U>
+/// where
+/// U: SerializeAs<T>,
+/// {
+/// fn serialize_as<S>(source: &Box<T>, serializer: S) -> Result<S::Ok, S::Error>
+/// where
+/// S: Serializer,
+/// {
+/// SerializeAsWrap::<T, U>::new(source).serialize(serializer)
+/// }
+/// }
+/// ```
+///
+/// It uses two type parameters, `T` and `U` instead of only one and performs the serialization step using the `SerializeAsWrap` type.
+/// The `T` type is the on the Rust side before serialization, whereas the `U` type determines how the value will be serialized.
+/// These two changes are usually enough to make a container type implement [`SerializeAs`][].
+///
+/// [`SerializeAsWrap`] is a piece of glue code which turns [`SerializeAs`] into a serde compatible datatype, by converting all calls to `serialize` into `serialize_as`.
+/// This allows us to implement [`SerializeAs`] such that it can be applied recursively throughout the whole data structure.
+/// This is mostly important for container types, such as `Vec` or `BTreeMap`.
+/// In a `BTreeMap` this allows us to specify two different serialization behaviors, one for key and one for value, using the [`SerializeAs`] trait.
+///
+/// ## Implementing a converter Type
+///
+/// This shows a simplified implementation for [`DisplayFromStr`].
+///
+/// ```rust
+/// # #[cfg(all(feature = "macros"))] {
+/// # use serde_with::SerializeAs;
+/// # use std::fmt::Display;
+/// struct DisplayFromStr;
+///
+/// impl<T> SerializeAs<T> for DisplayFromStr
+/// where
+/// T: Display,
+/// {
+/// fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+/// where
+/// S: serde::Serializer,
+/// {
+/// serializer.collect_str(&source)
+/// }
+/// }
+/// #
+/// # #[serde_with::serde_as]
+/// # #[derive(serde::Serialize)]
+/// # struct S (#[serde_as(as = "DisplayFromStr")] bool);
+/// #
+/// # assert_eq!(r#""false""#, serde_json::to_string(&S(false)).unwrap());
+/// # }
+/// ```
+///
+/// [`Box`]: std::boxed::Box
+/// [`BTreeMap`]: std::collections::BTreeMap
+/// [`Display`]: std::fmt::Display
+/// [`Duration`]: std::time::Duration
+/// [`Vec`]: std::vec::Vec
+/// [impl-serialize]: https://serde.rs/impl-serialize.html
+pub trait SerializeAs<T: ?Sized> {
+ /// Serialize this value into the given Serde serializer.
+ fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer;
+}
+
+/// Helper type to implement [`SerializeAs`] for container-like types.
+#[derive(Debug)]
+pub struct SerializeAsWrap<'a, T: ?Sized, U: ?Sized> {
+ value: &'a T,
+ marker: PhantomData<U>,
+}
+
+impl<'a, T, U> SerializeAsWrap<'a, T, U>
+where
+ T: ?Sized,
+ U: ?Sized,
+{
+ /// Create new instance with provided value.
+ pub fn new(value: &'a T) -> Self {
+ Self {
+ value,
+ marker: PhantomData,
+ }
+ }
+}
+
+impl<'a, T, U> Serialize for SerializeAsWrap<'a, T, U>
+where
+ T: ?Sized,
+ U: ?Sized,
+ U: SerializeAs<T>,
+{
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ U::serialize_as(self.value, serializer)
+ }
+}
+
+impl<'a, T, U> From<&'a T> for SerializeAsWrap<'a, T, U>
+where
+ T: ?Sized,
+ U: ?Sized,
+ U: SerializeAs<T>,
+{
+ fn from(value: &'a T) -> Self {
+ Self::new(value)
+ }
+}
diff --git a/third_party/rust/serde_with/src/serde_conv.rs b/third_party/rust/serde_with/src/serde_conv.rs
new file mode 100644
index 0000000000..c5659ebfda
--- /dev/null
+++ b/third_party/rust/serde_with/src/serde_conv.rs
@@ -0,0 +1,147 @@
+/// Create new conversion adapters from functions
+///
+/// The macro lets you create a new converter, which is usable for serde's with-attribute and `#[serde_as]`.
+/// Its main use case is to write simple converters for types, which are not serializable.
+/// Another use-case is to change the serialization behavior if the implemented `Serialize`/`Deserialize` trait is insufficient.
+///
+/// The macro takes four arguments:
+///
+/// 1. The name of the converter type.
+/// The type can be prefixed with a visibility modifies like `pub` or `pub(crate)`.
+/// By default, the type is not marked as public (`pub(self)`).
+/// 2. The type `T` we want to extend with custom behavior.
+/// 3. A function or macro taking a `&T` and returning a serializable type.
+/// 4. A function or macro taking a deserializable type and returning a `Result<T, E>`.
+/// The error type `E` must implement `Display`.
+///
+/// # Example
+///
+/// In this example, we write custom serialization behavior for a `Rgb` type.
+/// We want to serialize it as a `[u8; 3]`.
+///
+/// ```rust
+/// # #[cfg(feature = "macros")] {
+/// # use serde::{Serialize, Deserialize};
+///
+/// #[derive(Clone, Copy, Debug, PartialEq)]
+/// struct Rgb {
+/// red: u8,
+/// green: u8,
+/// blue: u8,
+/// }
+///
+/// serde_with::serde_conv!(
+/// RgbAsArray,
+/// Rgb,
+/// |rgb: &Rgb| [rgb.red, rgb.green, rgb.blue],
+/// |value: [u8; 3]| -> Result<_, std::convert::Infallible> {
+/// Ok(Rgb {
+/// red: value[0],
+/// green: value[1],
+/// blue: value[2],
+/// })
+/// }
+/// );
+///
+/// //////////////////////////////////////////////////
+///
+/// // We define some colors to be used later
+///
+/// let green = Rgb {red: 0, green: 255, blue: 0};
+/// let orange = Rgb {red: 255, green: 128, blue: 0};
+/// let pink = Rgb {red: 255, green: 0, blue: 255};
+///
+/// //////////////////////////////////////////////////
+///
+/// // We can now use the `RgbAsArray` adapter with `serde_as`.
+///
+/// #[serde_with::serde_as]
+/// #[derive(Debug, PartialEq, Serialize, Deserialize)]
+/// struct Colors {
+/// #[serde_as(as = "RgbAsArray")]
+/// one_rgb: Rgb,
+/// #[serde_as(as = "Vec<RgbAsArray>")]
+/// rgbs_in_vec: Vec<Rgb>,
+/// }
+///
+/// let data = Colors {
+/// one_rgb: orange,
+/// rgbs_in_vec: vec![green, pink],
+/// };
+/// let json = serde_json::json!({
+/// "one_rgb": [255, 128, 0],
+/// "rgbs_in_vec": [
+/// [0, 255, 0],
+/// [255, 0, 255]
+/// ]
+/// });
+///
+/// assert_eq!(json, serde_json::to_value(&data).unwrap());
+/// assert_eq!(data, serde_json::from_value(json).unwrap());
+///
+/// //////////////////////////////////////////////////
+///
+/// // The types generated by `serde_conv` is also compatible with serde's with attribute
+///
+/// #[derive(Debug, PartialEq, Serialize, Deserialize)]
+/// struct ColorsWith {
+/// #[serde(with = "RgbAsArray")]
+/// rgb_with: Rgb,
+/// }
+///
+/// let data = ColorsWith {
+/// rgb_with: pink,
+/// };
+/// let json = serde_json::json!({
+/// "rgb_with": [255, 0, 255]
+/// });
+///
+/// assert_eq!(json, serde_json::to_value(&data).unwrap());
+/// assert_eq!(data, serde_json::from_value(json).unwrap());
+/// # }
+/// ```
+#[macro_export]
+macro_rules! serde_conv {
+ ($m:ident, $t:ty, $ser:expr, $de:expr) => {$crate::serde_conv!(pub(self) $m, $t, $ser, $de);};
+ ($vis:vis $m:ident, $t:ty, $ser:expr, $de:expr) => {
+ #[allow(non_camel_case_types)]
+ $vis struct $m;
+
+ #[allow(clippy::ptr_arg)]
+ impl $m {
+ $vis fn serialize<S>(x: &$t, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
+ where
+ S: $crate::serde::Serializer,
+ {
+ let y = $ser(x);
+ $crate::serde::Serialize::serialize(&y, serializer)
+ }
+
+ $vis fn deserialize<'de, D>(deserializer: D) -> ::std::result::Result<$t, D::Error>
+ where
+ D: $crate::serde::Deserializer<'de>,
+ {
+ let y = $crate::serde::Deserialize::deserialize(deserializer)?;
+ $de(y).map_err($crate::serde::de::Error::custom)
+ }
+ }
+
+ impl $crate::SerializeAs<$t> for $m {
+ fn serialize_as<S>(x: &$t, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
+ where
+ S: $crate::serde::Serializer,
+ {
+ Self::serialize(x, serializer)
+ }
+ }
+
+ impl<'de> $crate::DeserializeAs<'de, $t> for $m {
+ fn deserialize_as<D>(deserializer: D) -> ::std::result::Result<$t, D::Error>
+ where
+ D: $crate::serde::Deserializer<'de>,
+ {
+ Self::deserialize(deserializer)
+ }
+ }
+ };
+}
diff --git a/third_party/rust/serde_with/src/time_0_3.rs b/third_party/rust/serde_with/src/time_0_3.rs
new file mode 100644
index 0000000000..76dca006d2
--- /dev/null
+++ b/third_party/rust/serde_with/src/time_0_3.rs
@@ -0,0 +1,382 @@
+//! De/Serialization of [time v0.3][time] types
+//!
+//! This modules is only available if using the `time_0_3` feature of the crate.
+//!
+//! [time]: https://docs.rs/time/0.3/
+
+use crate::{
+ de::DeserializeAs,
+ formats::{Flexible, Format, Strict, Strictness},
+ ser::SerializeAs,
+ utils::duration::{DurationSigned, Sign},
+ DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds,
+ DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac,
+ DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds, TimestampMicroSecondsWithFrac,
+ TimestampMilliSeconds, TimestampMilliSecondsWithFrac, TimestampNanoSeconds,
+ TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac,
+};
+use alloc::{format, string::String};
+use serde::{de, ser::Error as _, Deserializer, Serialize, Serializer};
+use std::{convert::TryInto, fmt, time::Duration as StdDuration};
+use time_0_3::{
+ format_description::well_known::{Rfc2822, Rfc3339},
+ Duration, OffsetDateTime, PrimitiveDateTime,
+};
+
+/// Create a [`PrimitiveDateTime`] for the Unix Epoch
+fn unix_epoch_primitive() -> PrimitiveDateTime {
+ PrimitiveDateTime::new(
+ time_0_3::Date::from_ordinal_date(1970, 1).unwrap(),
+ time_0_3::Time::from_hms_nano(0, 0, 0, 0).unwrap(),
+ )
+}
+
+/// Convert a [`time::Duration`][time_0_3::Duration] into a [`DurationSigned`]
+fn duration_into_duration_signed(dur: &Duration) -> DurationSigned {
+ let std_dur = StdDuration::new(
+ dur.whole_seconds().unsigned_abs(),
+ dur.subsec_nanoseconds().unsigned_abs(),
+ );
+
+ DurationSigned::with_duration(
+ // A duration of 0 is not positive, so check for negative value.
+ if dur.is_negative() {
+ Sign::Negative
+ } else {
+ Sign::Positive
+ },
+ std_dur,
+ )
+}
+
+/// Convert a [`DurationSigned`] into a [`time_0_3::Duration`]
+fn duration_from_duration_signed<'de, D>(sdur: DurationSigned) -> Result<Duration, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ let mut dur: Duration = match sdur.duration.try_into() {
+ Ok(dur) => dur,
+ Err(msg) => {
+ return Err(de::Error::custom(format!(
+ "Duration is outside of the representable range: {}",
+ msg
+ )))
+ }
+ };
+ if sdur.sign.is_negative() {
+ dur = -dur;
+ }
+ Ok(dur)
+}
+
+macro_rules! use_duration_signed_ser {
+ (
+ $main_trait:ident $internal_trait:ident =>
+ {
+ $ty:ty; $converter:ident =>
+ $({
+ $format:ty, $strictness:ty =>
+ $($tbound:ident: $bound:ident $(,)?)*
+ })*
+ }
+ ) => {
+ $(
+ impl<$($tbound ,)*> SerializeAs<$ty> for $main_trait<$format, $strictness>
+ where
+ $($tbound: $bound,)*
+ {
+ fn serialize_as<S>(source: &$ty, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let dur: DurationSigned = $converter(source);
+ $internal_trait::<$format, $strictness>::serialize_as(
+ &dur,
+ serializer,
+ )
+ }
+ }
+ )*
+ };
+ (
+ $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
+ ) => {
+ $( use_duration_signed_ser!($main_trait $internal_trait => $rest); )+
+ };
+}
+
+fn offset_datetime_to_duration(source: &OffsetDateTime) -> DurationSigned {
+ duration_into_duration_signed(&(*source - OffsetDateTime::UNIX_EPOCH))
+}
+
+fn primitive_datetime_to_duration(source: &PrimitiveDateTime) -> DurationSigned {
+ duration_into_duration_signed(&(*source - unix_epoch_primitive()))
+}
+
+use_duration_signed_ser!(
+ DurationSeconds DurationSeconds,
+ DurationMilliSeconds DurationMilliSeconds,
+ DurationMicroSeconds DurationMicroSeconds,
+ DurationNanoSeconds DurationNanoSeconds,
+ => {
+ Duration; duration_into_duration_signed =>
+ {i64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ OffsetDateTime; offset_datetime_to_duration =>
+ {i64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ PrimitiveDateTime; primitive_datetime_to_duration =>
+ {i64, STRICTNESS => STRICTNESS: Strictness}
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+
+// Duration/Timestamp WITH FRACTIONS
+use_duration_signed_ser!(
+ DurationSecondsWithFrac DurationSecondsWithFrac,
+ DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ Duration; duration_into_duration_signed =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ OffsetDateTime; offset_datetime_to_duration =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+use_duration_signed_ser!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ PrimitiveDateTime; primitive_datetime_to_duration =>
+ {f64, STRICTNESS => STRICTNESS: Strictness}
+ {String, STRICTNESS => STRICTNESS: Strictness}
+ }
+);
+
+macro_rules! use_duration_signed_de {
+ (
+ $main_trait:ident $internal_trait:ident =>
+ {
+ $ty:ty; $converter:ident =>
+ $({
+ $format:ty, $strictness:ty =>
+ $($tbound:ident: $bound:ident)*
+ })*
+ }
+ ) =>{
+ $(
+ impl<'de, $($tbound,)*> DeserializeAs<'de, $ty> for $main_trait<$format, $strictness>
+ where
+ $($tbound: $bound,)*
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<$ty, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let dur: DurationSigned = $internal_trait::<$format, $strictness>::deserialize_as(deserializer)?;
+ $converter::<D>(dur)
+ }
+ }
+ )*
+ };
+ (
+ $( $main_trait:ident $internal_trait:ident, )+ => $rest:tt
+ ) => {
+ $( use_duration_signed_de!($main_trait $internal_trait => $rest); )+
+ };
+}
+
+fn duration_to_offset_datetime<'de, D>(dur: DurationSigned) -> Result<OffsetDateTime, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ Ok(OffsetDateTime::UNIX_EPOCH + duration_from_duration_signed::<D>(dur)?)
+}
+
+fn duration_to_primitive_datetime<'de, D>(
+ dur: DurationSigned,
+) -> Result<PrimitiveDateTime, D::Error>
+where
+ D: Deserializer<'de>,
+{
+ Ok(unix_epoch_primitive() + duration_from_duration_signed::<D>(dur)?)
+}
+
+// No subsecond precision
+use_duration_signed_de!(
+ DurationSeconds DurationSeconds,
+ DurationMilliSeconds DurationMilliSeconds,
+ DurationMicroSeconds DurationMicroSeconds,
+ DurationNanoSeconds DurationNanoSeconds,
+ => {
+ Duration; duration_from_duration_signed =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ OffsetDateTime; duration_to_offset_datetime =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSeconds DurationSeconds,
+ TimestampMilliSeconds DurationMilliSeconds,
+ TimestampMicroSeconds DurationMicroSeconds,
+ TimestampNanoSeconds DurationNanoSeconds,
+ => {
+ PrimitiveDateTime; duration_to_primitive_datetime =>
+ {i64, Strict =>}
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+
+// Duration/Timestamp WITH FRACTIONS
+use_duration_signed_de!(
+ DurationSecondsWithFrac DurationSecondsWithFrac,
+ DurationMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ DurationMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ DurationNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ Duration; duration_from_duration_signed =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ OffsetDateTime; duration_to_offset_datetime =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+use_duration_signed_de!(
+ TimestampSecondsWithFrac DurationSecondsWithFrac,
+ TimestampMilliSecondsWithFrac DurationMilliSecondsWithFrac,
+ TimestampMicroSecondsWithFrac DurationMicroSecondsWithFrac,
+ TimestampNanoSecondsWithFrac DurationNanoSecondsWithFrac,
+ => {
+ PrimitiveDateTime; duration_to_primitive_datetime =>
+ {f64, Strict =>}
+ {String, Strict =>}
+ {FORMAT, Flexible => FORMAT: Format}
+ }
+);
+
+impl SerializeAs<OffsetDateTime> for Rfc2822 {
+ fn serialize_as<S>(datetime: &OffsetDateTime, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ datetime
+ .format(&Rfc2822)
+ .map_err(S::Error::custom)?
+ .serialize(serializer)
+ }
+}
+
+impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc2822 {
+ fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct Visitor;
+ impl<'de> de::Visitor<'de> for Visitor {
+ type Value = OffsetDateTime;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a RFC2822-formatted `OffsetDateTime`")
+ }
+
+ fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
+ Self::Value::parse(value, &Rfc2822).map_err(E::custom)
+ }
+ }
+
+ deserializer.deserialize_str(Visitor)
+ }
+}
+
+impl SerializeAs<OffsetDateTime> for Rfc3339 {
+ fn serialize_as<S>(datetime: &OffsetDateTime, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ datetime
+ .format(&Rfc3339)
+ .map_err(S::Error::custom)?
+ .serialize(serializer)
+ }
+}
+
+impl<'de> DeserializeAs<'de, OffsetDateTime> for Rfc3339 {
+ fn deserialize_as<D>(deserializer: D) -> Result<OffsetDateTime, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct Visitor;
+ impl<'de> de::Visitor<'de> for Visitor {
+ type Value = OffsetDateTime;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("a RFC3339-formatted `OffsetDateTime`")
+ }
+
+ fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
+ Self::Value::parse(value, &Rfc3339).map_err(E::custom)
+ }
+ }
+
+ deserializer.deserialize_str(Visitor)
+ }
+}
diff --git a/third_party/rust/serde_with/src/utils.rs b/third_party/rust/serde_with/src/utils.rs
new file mode 100644
index 0000000000..ccf99128e4
--- /dev/null
+++ b/third_party/rust/serde_with/src/utils.rs
@@ -0,0 +1,120 @@
+pub(crate) mod duration;
+
+use alloc::string::String;
+use core::marker::PhantomData;
+use serde::de::{Deserialize, MapAccess, SeqAccess};
+
+/// Re-Implementation of `serde::private::de::size_hint::cautious`
+#[inline]
+pub(crate) fn size_hint_cautious(hint: Option<usize>) -> usize {
+ core::cmp::min(hint.unwrap_or(0), 4096)
+}
+
+pub(crate) const NANOS_PER_SEC: u32 = 1_000_000_000;
+// pub(crate) const NANOS_PER_MILLI: u32 = 1_000_000;
+// pub(crate) const NANOS_PER_MICRO: u32 = 1_000;
+// pub(crate) const MILLIS_PER_SEC: u64 = 1_000;
+// pub(crate) const MICROS_PER_SEC: u64 = 1_000_000;
+
+pub(crate) struct MapIter<'de, A, K, V> {
+ pub(crate) access: A,
+ marker: PhantomData<(&'de (), K, V)>,
+}
+
+impl<'de, A, K, V> MapIter<'de, A, K, V> {
+ pub(crate) fn new(access: A) -> Self
+ where
+ A: MapAccess<'de>,
+ {
+ Self {
+ access,
+ marker: PhantomData,
+ }
+ }
+}
+
+impl<'de, A, K, V> Iterator for MapIter<'de, A, K, V>
+where
+ A: MapAccess<'de>,
+ K: Deserialize<'de>,
+ V: Deserialize<'de>,
+{
+ type Item = Result<(K, V), A::Error>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.access.next_entry().transpose()
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ match self.access.size_hint() {
+ Some(size) => (size, Some(size)),
+ None => (0, None),
+ }
+ }
+}
+
+pub(crate) struct SeqIter<'de, A, T> {
+ access: A,
+ marker: PhantomData<(&'de (), T)>,
+}
+
+impl<'de, A, T> SeqIter<'de, A, T> {
+ pub(crate) fn new(access: A) -> Self
+ where
+ A: SeqAccess<'de>,
+ {
+ Self {
+ access,
+ marker: PhantomData,
+ }
+ }
+}
+
+impl<'de, A, T> Iterator for SeqIter<'de, A, T>
+where
+ A: SeqAccess<'de>,
+ T: Deserialize<'de>,
+{
+ type Item = Result<T, A::Error>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.access.next_element().transpose()
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ match self.access.size_hint() {
+ Some(size) => (size, Some(size)),
+ None => (0, None),
+ }
+ }
+}
+
+pub(crate) fn duration_as_secs_f64(dur: &core::time::Duration) -> f64 {
+ (dur.as_secs() as f64) + (dur.subsec_nanos() as f64) / (NANOS_PER_SEC as f64)
+}
+
+pub(crate) fn duration_signed_from_secs_f64(
+ secs: f64,
+) -> Result<self::duration::DurationSigned, String> {
+ const MAX_NANOS_F64: f64 = ((u64::max_value() as u128 + 1) * (NANOS_PER_SEC as u128)) as f64;
+ // TODO why are the seconds converted to nanoseconds first?
+ // Does it make sense to just truncate the value?
+ let mut nanos = secs * (NANOS_PER_SEC as f64);
+ if !nanos.is_finite() {
+ return Err("got non-finite value when converting float to duration".into());
+ }
+ if nanos >= MAX_NANOS_F64 {
+ return Err("overflow when converting float to duration".into());
+ }
+ let mut sign = self::duration::Sign::Positive;
+ if nanos < 0.0 {
+ nanos = -nanos;
+ sign = self::duration::Sign::Negative;
+ }
+ let nanos = nanos as u128;
+ Ok(self::duration::DurationSigned::new(
+ sign,
+ (nanos / (NANOS_PER_SEC as u128)) as u64,
+ (nanos % (NANOS_PER_SEC as u128)) as u32,
+ ))
+}
diff --git a/third_party/rust/serde_with/src/utils/duration.rs b/third_party/rust/serde_with/src/utils/duration.rs
new file mode 100644
index 0000000000..2d5a27e87d
--- /dev/null
+++ b/third_party/rust/serde_with/src/utils/duration.rs
@@ -0,0 +1,559 @@
+//! Internal Helper types
+
+use crate::{
+ formats::{Flexible, Format, Strict, Strictness},
+ utils, DeserializeAs, DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds,
+ DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac,
+ DurationSeconds, DurationSecondsWithFrac, SerializeAs,
+};
+use alloc::{
+ format,
+ string::{String, ToString},
+ vec::Vec,
+};
+use core::{fmt, ops::Neg, time::Duration};
+use serde::{
+ de::{self, Unexpected, Visitor},
+ ser, Deserialize, Deserializer, Serialize, Serializer,
+};
+use std::time::SystemTime;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum Sign {
+ Positive,
+ Negative,
+}
+
+impl Sign {
+ #[allow(dead_code)]
+ pub(crate) fn is_positive(&self) -> bool {
+ *self == Sign::Positive
+ }
+
+ #[allow(dead_code)]
+ pub(crate) fn is_negative(&self) -> bool {
+ *self == Sign::Negative
+ }
+
+ pub(crate) fn apply<T>(&self, value: T) -> T
+ where
+ T: Neg<Output = T>,
+ {
+ match *self {
+ Sign::Positive => value,
+ Sign::Negative => value.neg(),
+ }
+ }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct DurationSigned {
+ pub(crate) sign: Sign,
+ pub(crate) duration: Duration,
+}
+
+impl DurationSigned {
+ pub(crate) fn new(sign: Sign, secs: u64, nanosecs: u32) -> Self {
+ Self {
+ sign,
+ duration: Duration::new(secs, nanosecs),
+ }
+ }
+
+ #[cfg(any(feature = "chrono", feature = "time_0_3"))]
+ pub(crate) fn with_duration(sign: Sign, duration: Duration) -> Self {
+ Self { sign, duration }
+ }
+
+ pub(crate) fn to_system_time<'de, D>(self) -> Result<SystemTime, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ match self.sign {
+ Sign::Positive => SystemTime::UNIX_EPOCH.checked_add(self.duration),
+ Sign::Negative => SystemTime::UNIX_EPOCH.checked_sub(self.duration),
+ }
+ .ok_or_else(|| {
+ de::Error::custom("timestamp is outside the range for std::time::SystemTime")
+ })
+ }
+
+ pub(crate) fn to_std_duration<'de, D>(self) -> Result<Duration, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ match self.sign {
+ Sign::Positive => Ok(self.duration),
+ Sign::Negative => Err(de::Error::custom("std::time::Duration cannot be negative")),
+ }
+ }
+}
+
+impl From<&Duration> for DurationSigned {
+ fn from(&duration: &Duration) -> Self {
+ Self {
+ sign: Sign::Positive,
+ duration,
+ }
+ }
+}
+
+impl From<&SystemTime> for DurationSigned {
+ fn from(time: &SystemTime) -> Self {
+ match time.duration_since(SystemTime::UNIX_EPOCH) {
+ Ok(dur) => DurationSigned {
+ sign: Sign::Positive,
+ duration: dur,
+ },
+ Err(err) => DurationSigned {
+ sign: Sign::Negative,
+ duration: err.duration(),
+ },
+ }
+ }
+}
+
+impl core::ops::Mul<u32> for DurationSigned {
+ type Output = DurationSigned;
+
+ fn mul(mut self, rhs: u32) -> Self::Output {
+ self.duration *= rhs;
+ self
+ }
+}
+
+impl core::ops::Div<u32> for DurationSigned {
+ type Output = DurationSigned;
+
+ fn div(mut self, rhs: u32) -> Self::Output {
+ self.duration /= rhs;
+ self
+ }
+}
+
+impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<u64, STRICTNESS>
+where
+ STRICTNESS: Strictness,
+{
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ if source.sign.is_negative() {
+ return Err(ser::Error::custom(
+ "cannot serialize a negative Duration as u64",
+ ));
+ }
+
+ let mut secs = source.duration.as_secs();
+
+ // Properly round the value
+ if source.duration.subsec_millis() >= 500 {
+ if source.sign.is_positive() {
+ secs += 1;
+ } else {
+ secs -= 1;
+ }
+ }
+ secs.serialize(serializer)
+ }
+}
+
+impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<i64, STRICTNESS>
+where
+ STRICTNESS: Strictness,
+{
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let mut secs = source.sign.apply(source.duration.as_secs() as i64);
+
+ // Properly round the value
+ if source.duration.subsec_millis() >= 500 {
+ if source.sign.is_positive() {
+ secs += 1;
+ } else {
+ secs -= 1;
+ }
+ }
+ secs.serialize(serializer)
+ }
+}
+
+impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<f64, STRICTNESS>
+where
+ STRICTNESS: Strictness,
+{
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let mut secs = source.sign.apply(source.duration.as_secs() as f64);
+
+ // Properly round the value
+ if source.duration.subsec_millis() >= 500 {
+ if source.sign.is_positive() {
+ secs += 1.;
+ } else {
+ secs -= 1.;
+ }
+ }
+ secs.serialize(serializer)
+ }
+}
+
+impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSeconds<String, STRICTNESS>
+where
+ STRICTNESS: Strictness,
+{
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let mut secs = source.sign.apply(source.duration.as_secs() as i64);
+
+ // Properly round the value
+ if source.duration.subsec_millis() >= 500 {
+ if source.sign.is_positive() {
+ secs += 1;
+ } else {
+ secs -= 1;
+ }
+ }
+ secs.to_string().serialize(serializer)
+ }
+}
+
+impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSecondsWithFrac<f64, STRICTNESS>
+where
+ STRICTNESS: Strictness,
+{
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source
+ .sign
+ .apply(utils::duration_as_secs_f64(&source.duration))
+ .serialize(serializer)
+ }
+}
+
+impl<STRICTNESS> SerializeAs<DurationSigned> for DurationSecondsWithFrac<String, STRICTNESS>
+where
+ STRICTNESS: Strictness,
+{
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ source
+ .sign
+ .apply(utils::duration_as_secs_f64(&source.duration))
+ .to_string()
+ .serialize(serializer)
+ }
+}
+
+macro_rules! duration_impls {
+ ($($inner:ident { $($factor:literal => $outer:ident,)+ })+) => {
+ $($(
+
+ impl<FORMAT, STRICTNESS> SerializeAs<DurationSigned> for $outer<FORMAT, STRICTNESS>
+ where
+ FORMAT: Format,
+ STRICTNESS: Strictness,
+ $inner<FORMAT, STRICTNESS>: SerializeAs<DurationSigned>
+ {
+ fn serialize_as<S>(source: &DurationSigned, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ $inner::<FORMAT, STRICTNESS>::serialize_as(&(*source * $factor), serializer)
+ }
+ }
+
+ impl<'de, FORMAT, STRICTNESS> DeserializeAs<'de, DurationSigned> for $outer<FORMAT, STRICTNESS>
+ where
+ FORMAT: Format,
+ STRICTNESS: Strictness,
+ $inner<FORMAT, STRICTNESS>: DeserializeAs<'de, DurationSigned>,
+ {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let dur = $inner::<FORMAT, STRICTNESS>::deserialize_as(deserializer)?;
+ Ok(dur / $factor)
+ }
+ }
+
+ )+)+ };
+}
+duration_impls!(
+ DurationSeconds {
+ 1000u32 => DurationMilliSeconds,
+ 1_000_000u32 => DurationMicroSeconds,
+ 1_000_000_000u32 => DurationNanoSeconds,
+ }
+ DurationSecondsWithFrac {
+ 1000u32 => DurationMilliSecondsWithFrac,
+ 1_000_000u32 => DurationMicroSecondsWithFrac,
+ 1_000_000_000u32 => DurationNanoSecondsWithFrac,
+ }
+);
+
+struct DurationVisitorFlexible;
+impl<'de> Visitor<'de> for DurationVisitorFlexible {
+ type Value = DurationSigned;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ formatter.write_str("an integer, a float, or a string containing a number")
+ }
+
+ fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ if value >= 0 {
+ Ok(DurationSigned::new(Sign::Positive, value as u64, 0))
+ } else {
+ Ok(DurationSigned::new(Sign::Negative, (-value) as u64, 0))
+ }
+ }
+
+ fn visit_u64<E>(self, secs: u64) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ Ok(DurationSigned::new(Sign::Positive, secs, 0))
+ }
+
+ fn visit_f64<E>(self, secs: f64) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ utils::duration_signed_from_secs_f64(secs).map_err(de::Error::custom)
+ }
+
+ fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ match parse_float_into_time_parts(value) {
+ Ok((sign, seconds, subseconds)) => Ok(DurationSigned::new(sign, seconds, subseconds)),
+ Err(ParseFloatError::InvalidValue) => {
+ Err(de::Error::invalid_value(Unexpected::Str(value), &self))
+ }
+ Err(ParseFloatError::Custom(msg)) => Err(de::Error::custom(msg)),
+ }
+ }
+}
+
+impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<u64, Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ u64::deserialize(deserializer).map(|secs: u64| DurationSigned::new(Sign::Positive, secs, 0))
+ }
+}
+
+impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<i64, Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ i64::deserialize(deserializer).map(|mut secs: i64| {
+ let mut sign = Sign::Positive;
+ if secs.is_negative() {
+ secs = -secs;
+ sign = Sign::Negative;
+ }
+ DurationSigned::new(sign, secs as u64, 0)
+ })
+ }
+}
+
+impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<f64, Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let val = f64::deserialize(deserializer)?.round();
+ utils::duration_signed_from_secs_f64(val).map_err(de::Error::custom)
+ }
+}
+
+impl<'de> DeserializeAs<'de, DurationSigned> for DurationSeconds<String, Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct DurationDeserializationVisitor;
+
+ impl<'de> Visitor<'de> for DurationDeserializationVisitor {
+ type Value = DurationSigned;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(formatter, "a string containing a number")
+ }
+
+ fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ let mut secs: i64 = value.parse().map_err(de::Error::custom)?;
+ let mut sign = Sign::Positive;
+ if secs.is_negative() {
+ secs = -secs;
+ sign = Sign::Negative;
+ }
+ Ok(DurationSigned::new(sign, secs as u64, 0))
+ }
+ }
+
+ deserializer.deserialize_str(DurationDeserializationVisitor)
+ }
+}
+
+impl<'de, FORMAT> DeserializeAs<'de, DurationSigned> for DurationSeconds<FORMAT, Flexible>
+where
+ FORMAT: Format,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_any(DurationVisitorFlexible)
+ }
+}
+
+impl<'de> DeserializeAs<'de, DurationSigned> for DurationSecondsWithFrac<f64, Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let val = f64::deserialize(deserializer)?;
+ utils::duration_signed_from_secs_f64(val).map_err(de::Error::custom)
+ }
+}
+
+impl<'de> DeserializeAs<'de, DurationSigned> for DurationSecondsWithFrac<String, Strict> {
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ let value = String::deserialize(deserializer)?;
+ match parse_float_into_time_parts(&value) {
+ Ok((sign, seconds, subseconds)) => Ok(DurationSigned {
+ sign,
+ duration: Duration::new(seconds, subseconds),
+ }),
+ Err(ParseFloatError::InvalidValue) => Err(de::Error::invalid_value(
+ Unexpected::Str(&value),
+ &"a string containing an integer or float",
+ )),
+ Err(ParseFloatError::Custom(msg)) => Err(de::Error::custom(msg)),
+ }
+ }
+}
+
+impl<'de, FORMAT> DeserializeAs<'de, DurationSigned> for DurationSecondsWithFrac<FORMAT, Flexible>
+where
+ FORMAT: Format,
+{
+ fn deserialize_as<D>(deserializer: D) -> Result<DurationSigned, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_any(DurationVisitorFlexible)
+ }
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) enum ParseFloatError {
+ InvalidValue,
+ Custom(String),
+}
+
+fn parse_float_into_time_parts(mut value: &str) -> Result<(Sign, u64, u32), ParseFloatError> {
+ let sign = match value.chars().next() {
+ // Advance by the size of the parsed char
+ Some('+') => {
+ value = &value[1..];
+ Sign::Positive
+ }
+ Some('-') => {
+ value = &value[1..];
+ Sign::Negative
+ }
+ _ => Sign::Positive,
+ };
+
+ let parts: Vec<_> = value.split('.').collect();
+ match *parts.as_slice() {
+ [seconds] => {
+ if let Ok(seconds) = seconds.parse() {
+ Ok((sign, seconds, 0))
+ } else {
+ Err(ParseFloatError::InvalidValue)
+ }
+ }
+ [seconds, subseconds] => {
+ if let Ok(seconds) = seconds.parse() {
+ let subseclen = subseconds.chars().count() as u32;
+ if subseclen > 9 {
+ return Err(ParseFloatError::Custom(format!(
+ "Duration and Timestamps with no more than 9 digits precision, but '{}' has more",
+ value
+ )));
+ }
+
+ if let Ok(mut subseconds) = subseconds.parse() {
+ // convert subseconds to nanoseconds (10^-9), require 9 places for nanoseconds
+ subseconds *= 10u32.pow(9 - subseclen);
+ Ok((sign, seconds, subseconds))
+ } else {
+ Err(ParseFloatError::InvalidValue)
+ }
+ } else {
+ Err(ParseFloatError::InvalidValue)
+ }
+ }
+
+ _ => Err(ParseFloatError::InvalidValue),
+ }
+}
+
+#[test]
+fn test_parse_float_into_time_parts() {
+ // Test normal behavior
+ assert_eq!(
+ Ok((Sign::Positive, 123, 456_000_000)),
+ parse_float_into_time_parts("+123.456")
+ );
+ assert_eq!(
+ Ok((Sign::Negative, 123, 987_000)),
+ parse_float_into_time_parts("-123.000987")
+ );
+ assert_eq!(
+ Ok((Sign::Positive, 18446744073709551615, 123_456_789)),
+ parse_float_into_time_parts("18446744073709551615.123456789")
+ );
+
+ // Test behavior around 0
+ assert_eq!(
+ Ok((Sign::Positive, 0, 456_000_000)),
+ parse_float_into_time_parts("+0.456")
+ );
+ assert_eq!(
+ Ok((Sign::Negative, 0, 987_000)),
+ parse_float_into_time_parts("-0.000987")
+ );
+ assert_eq!(
+ Ok((Sign::Positive, 0, 123_456_789)),
+ parse_float_into_time_parts("0.123456789")
+ );
+}
diff --git a/third_party/rust/serde_with/src/with_prefix.rs b/third_party/rust/serde_with/src/with_prefix.rs
new file mode 100644
index 0000000000..b4b483c983
--- /dev/null
+++ b/third_party/rust/serde_with/src/with_prefix.rs
@@ -0,0 +1,612 @@
+use alloc::string::String;
+use core::fmt;
+use serde::{
+ de::{self, DeserializeSeed, Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor},
+ forward_to_deserialize_any,
+ ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer},
+};
+
+/// Serialize with an added prefix on every field name and deserialize by
+/// trimming away the prefix.
+///
+/// You can set the visibility of the generated module by prefixing the module name with a module visibility.
+/// `with_prefix!(pub(crate) prefix_foo "foo_");` creates a module with `pub(crate)` visibility.
+/// The visibility is optional and by default `pub(self)`, i.e., private visibility is assumed.
+///
+/// **Note:** Use of this macro is incompatible with applying the [`deny_unknown_fields`] attribute
+/// on the container.
+/// While deserializing, it will always warn about unknown fields, even though they are processed
+/// by the `with_prefix` wrapper.
+/// More details can be found in [this issue][issue-with_prefix-deny_unknown_fields].
+///
+/// # Example
+///
+/// The [Challonge REST API] likes to use prefixes to group related fields. In
+/// simplified form, their JSON may resemble the following:
+///
+/// [Challonge REST API]: https://api.challonge.com/v1/documents/matches/show
+///
+/// ```json
+/// {
+/// "player1_name": "name1",
+/// "player1_votes": 1,
+/// "player2_name": "name2",
+/// "player2_votes": 2
+/// }
+/// ```
+///
+/// In Rust, we would ideally like to model this data as a pair of `Player`
+/// structs, rather than repeating the fields of `Player` for each prefix.
+///
+/// ```rust
+/// # #[allow(dead_code)]
+/// struct Match {
+/// player1: Player,
+/// player2: Player,
+/// }
+///
+/// # #[allow(dead_code)]
+/// struct Player {
+/// name: String,
+/// votes: u64,
+/// }
+/// ```
+///
+/// This `with_prefix!` macro produces an adapter that adds a prefix onto field
+/// names during serialization and trims away the prefix during deserialization.
+/// An implementation of the Challonge API would use `with_prefix!` like this:
+///
+/// ```rust
+/// use serde::{Deserialize, Serialize};
+/// use serde_with::with_prefix;
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Match {
+/// #[serde(flatten, with = "prefix_player1")]
+/// player1: Player,
+/// #[serde(flatten, with = "prefix_player2")]
+/// player2: Player,
+/// }
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Player {
+/// name: String,
+/// votes: u64,
+/// }
+///
+/// with_prefix!(prefix_player1 "player1_");
+/// // You can also set the visibility of the generated prefix module, the default is private.
+/// with_prefix!(pub prefix_player2 "player2_");
+/// #
+/// # const EXPECTED: &str = r#"{
+/// # "player1_name": "name1",
+/// # "player1_votes": 1,
+/// # "player2_name": "name2",
+/// # "player2_votes": 2
+/// # }"#;
+///
+/// fn main() {
+/// let m = Match {
+/// player1: Player {
+/// name: "name1".to_owned(),
+/// votes: 1,
+/// },
+/// player2: Player {
+/// name: "name2".to_owned(),
+/// votes: 2,
+/// },
+/// };
+///
+/// let j = serde_json::to_string_pretty(&m).unwrap();
+/// println!("{}", j);
+/// #
+/// # assert_eq!(j, EXPECTED);
+/// }
+/// ```
+///
+/// [`deny_unknown_fields`]: https://serde.rs/container-attrs.html#deny_unknown_fields
+/// [issue-with_prefix-deny_unknown_fields]: https://github.com/jonasbb/serde_with/issues/57
+#[macro_export]
+macro_rules! with_prefix {
+ ($module:ident $prefix:expr) => {$crate::with_prefix!(pub(self) $module $prefix);};
+ ($vis:vis $module:ident $prefix:expr) => {
+ $vis mod $module {
+ use $crate::serde::{Deserialize, Deserializer, Serialize, Serializer};
+ use $crate::with_prefix::WithPrefix;
+
+ #[allow(dead_code)]
+ pub fn serialize<T, S>(object: &T, serializer: S) -> ::std::result::Result<S::Ok, S::Error>
+ where
+ T: Serialize,
+ S: Serializer,
+ {
+ object.serialize(WithPrefix {
+ delegate: serializer,
+ prefix: $prefix,
+ })
+ }
+
+ #[allow(dead_code)]
+ pub fn deserialize<'de, T, D>(deserializer: D) -> ::std::result::Result<T, D::Error>
+ where
+ T: Deserialize<'de>,
+ D: Deserializer<'de>,
+ {
+ T::deserialize(WithPrefix {
+ delegate: deserializer,
+ prefix: $prefix,
+ })
+ }
+ }
+ };
+}
+
+#[allow(missing_debug_implementations)]
+pub struct WithPrefix<'a, T> {
+ pub delegate: T,
+ pub prefix: &'a str,
+}
+
+impl<'a, T> Serialize for WithPrefix<'a, T>
+where
+ T: Serialize,
+{
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ self.delegate.serialize(WithPrefix {
+ delegate: serializer,
+ prefix: self.prefix,
+ })
+ }
+}
+
+impl<'a, S> Serializer for WithPrefix<'a, S>
+where
+ S: Serializer,
+{
+ type Ok = S::Ok;
+ type Error = S::Error;
+ type SerializeSeq = Impossible<Self::Ok, Self::Error>;
+ type SerializeTuple = Impossible<Self::Ok, Self::Error>;
+ type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
+ type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
+ type SerializeMap = WithPrefix<'a, S::SerializeMap>;
+ type SerializeStruct = WithPrefix<'a, S::SerializeMap>;
+ type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
+
+ fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
+ self.delegate
+ .collect_str(&format_args!("{}{}", self.prefix, v))
+ }
+
+ fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+ self.delegate.serialize_none()
+ }
+
+ fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
+ where
+ T: ?Sized + Serialize,
+ {
+ self.delegate.serialize_some(&WithPrefix {
+ delegate: value,
+ prefix: self.prefix,
+ })
+ }
+
+ fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ ) -> Result<Self::Ok, Self::Error> {
+ self.serialize_str(variant)
+ }
+
+ fn serialize_newtype_struct<T>(
+ self,
+ _name: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: ?Sized + Serialize,
+ {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_newtype_variant<T>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: ?Sized + Serialize,
+ {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+
+ fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+ Ok(WithPrefix {
+ delegate: self.delegate.serialize_map(len)?,
+ prefix: self.prefix,
+ })
+ }
+
+ fn serialize_struct(
+ self,
+ _name: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeStruct, Self::Error> {
+ self.serialize_map(Some(len))
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant, Self::Error> {
+ Err(ser::Error::custom("wrong type for with_prefix"))
+ }
+}
+
+impl<'a, S> SerializeMap for WithPrefix<'a, S>
+where
+ S: SerializeMap,
+{
+ type Ok = S::Ok;
+ type Error = S::Error;
+
+ fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
+ where
+ T: ?Sized + Serialize,
+ {
+ self.delegate.serialize_key(&WithPrefix {
+ delegate: key,
+ prefix: self.prefix,
+ })
+ }
+
+ fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
+ where
+ T: ?Sized + Serialize,
+ {
+ self.delegate.serialize_value(value)
+ }
+
+ fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
+ where
+ K: ?Sized + Serialize,
+ V: ?Sized + Serialize,
+ {
+ self.delegate.serialize_entry(
+ &WithPrefix {
+ delegate: key,
+ prefix: self.prefix,
+ },
+ value,
+ )
+ }
+
+ fn end(self) -> Result<Self::Ok, Self::Error> {
+ self.delegate.end()
+ }
+}
+
+impl<'a, S> SerializeStruct for WithPrefix<'a, S>
+where
+ S: SerializeMap,
+{
+ type Ok = S::Ok;
+ type Error = S::Error;
+
+ fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
+ where
+ T: ?Sized + Serialize,
+ {
+ let mut prefixed_key = String::with_capacity(self.prefix.len() + key.len());
+ prefixed_key.push_str(self.prefix);
+ prefixed_key.push_str(key);
+ self.delegate.serialize_entry(&prefixed_key, value)
+ }
+
+ fn end(self) -> Result<Self::Ok, Self::Error> {
+ self.delegate.end()
+ }
+}
+
+impl<'de, 'a, T> DeserializeSeed<'de> for WithPrefix<'a, T>
+where
+ T: DeserializeSeed<'de>,
+{
+ type Value = T::Value;
+
+ fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ self.delegate.deserialize(WithPrefix {
+ delegate: deserializer,
+ prefix: self.prefix,
+ })
+ }
+}
+
+impl<'de, 'a, D> Deserializer<'de> for WithPrefix<'a, D>
+where
+ D: Deserializer<'de>,
+{
+ type Error = D::Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.delegate.deserialize_map(WithPrefix {
+ delegate: visitor,
+ prefix: self.prefix,
+ })
+ }
+
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.delegate.deserialize_any(WithPrefixOption {
+ first_key: None,
+ delegate: visitor,
+ prefix: self.prefix,
+ })
+ }
+
+ fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.delegate.deserialize_identifier(WithPrefix {
+ delegate: visitor,
+ prefix: self.prefix,
+ })
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
+ map struct enum ignored_any
+ }
+}
+
+impl<'de, 'a, V> Visitor<'de> for WithPrefix<'a, V>
+where
+ V: Visitor<'de>,
+{
+ type Value = V::Value;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.delegate.expecting(formatter)
+ }
+
+ fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ self.delegate.visit_map(WithPrefix {
+ delegate: map,
+ prefix: self.prefix,
+ })
+ }
+}
+
+impl<'de, 'a, A> MapAccess<'de> for WithPrefix<'a, A>
+where
+ A: MapAccess<'de>,
+{
+ type Error = A::Error;
+
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+ where
+ K: DeserializeSeed<'de>,
+ {
+ while let Some(s) = self.delegate.next_key::<String>()? {
+ if let Some(without_prefix) = s.strip_prefix(self.prefix) {
+ return seed
+ .deserialize(without_prefix.into_deserializer())
+ .map(Some);
+ }
+ self.delegate.next_value::<IgnoredAny>()?;
+ }
+ Ok(None)
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+ where
+ V: DeserializeSeed<'de>,
+ {
+ self.delegate.next_value_seed(seed)
+ }
+}
+
+#[allow(missing_debug_implementations)]
+pub struct WithPrefixOption<'a, T> {
+ first_key: Option<String>,
+ delegate: T,
+ prefix: &'a str,
+}
+
+impl<'de, 'a, V> Visitor<'de> for WithPrefixOption<'a, V>
+where
+ V: Visitor<'de>,
+{
+ type Value = V::Value;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.delegate.expecting(formatter)
+ }
+
+ fn visit_unit<E>(self) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ self.delegate.visit_none()
+ }
+
+ fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+ where
+ A: MapAccess<'de>,
+ {
+ while let Some(s) = map.next_key::<String>()? {
+ if s.starts_with(self.prefix) {
+ return self.delegate.visit_some(WithPrefixOption {
+ first_key: Some(s),
+ delegate: map,
+ prefix: self.prefix,
+ });
+ }
+ map.next_value::<IgnoredAny>()?;
+ }
+ self.delegate.visit_none()
+ }
+}
+
+impl<'de, 'a, A> Deserializer<'de> for WithPrefixOption<'a, A>
+where
+ A: MapAccess<'de>,
+{
+ type Error = A::Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_map(self)
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+impl<'de, 'a, A> MapAccess<'de> for WithPrefixOption<'a, A>
+where
+ A: MapAccess<'de>,
+{
+ type Error = A::Error;
+
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+ where
+ K: DeserializeSeed<'de>,
+ {
+ if let Some(s) = self.first_key.take() {
+ let without_prefix = s[self.prefix.len()..].into_deserializer();
+ return seed.deserialize(without_prefix).map(Some);
+ }
+ while let Some(s) = self.delegate.next_key::<String>()? {
+ if let Some(without_prefix) = s.strip_prefix(self.prefix) {
+ return seed
+ .deserialize(without_prefix.into_deserializer())
+ .map(Some);
+ }
+ self.delegate.next_value::<IgnoredAny>()?;
+ }
+ Ok(None)
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+ where
+ V: DeserializeSeed<'de>,
+ {
+ self.delegate.next_value_seed(seed)
+ }
+}
diff --git a/third_party/rust/serde_with/tests/base64.rs b/third_party/rust/serde_with/tests/base64.rs
new file mode 100644
index 0000000000..5b84c0c6f0
--- /dev/null
+++ b/third_party/rust/serde_with/tests/base64.rs
@@ -0,0 +1,144 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+ // This allows the tests to be written more uniform and not have to special case the last clone().
+ clippy::redundant_clone,
+)]
+
+mod utils;
+
+use crate::utils::{check_deserialization, check_error_deserialization, is_equal};
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::{
+ base64::{Base64, Bcrypt, BinHex, Crypt, ImapMutf7, Standard, UrlSafe},
+ formats::{Padded, Unpadded},
+ serde_as,
+};
+
+#[test]
+fn base64_vec() {
+ let check_equal = vec![vec![0, 1, 2, 13], vec![14, 5, 6, 7]];
+ let check_deser = vec![vec![0xaa, 0xbc, 0xff], vec![0xe0, 0x7d], vec![0xe0, 0x7d]];
+ let check_deser_from = r#"["qrz/","4H0=","4H0"]"#;
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct BDefault(#[serde_as(as = "Vec<Base64>")] Vec<Vec<u8>>);
+
+ is_equal(
+ BDefault(check_equal.clone()),
+ expect![[r#"
+ [
+ "AAECDQ==",
+ "DgUGBw=="
+ ]"#]],
+ );
+
+ // Check mixed padding deserialization
+ check_deserialization(BDefault(check_deser.clone()), check_deser_from);
+
+ check_error_deserialization::<BDefault>(
+ r#"["0"]"#,
+ expect![[r#"Encoded text cannot have a 6-bit remainder. at line 1 column 5"#]],
+ );
+ check_error_deserialization::<BDefault>(
+ r#"["zz"]"#,
+ expect![[r#"Invalid last symbol 122, offset 1. at line 1 column 6"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct BPadded(#[serde_as(as = "Vec<Base64<Standard, Padded>>")] Vec<Vec<u8>>);
+
+ is_equal(
+ BPadded(check_equal.clone()),
+ expect![[r#"
+ [
+ "AAECDQ==",
+ "DgUGBw=="
+ ]"#]],
+ );
+ check_deserialization(BPadded(check_deser.clone()), check_deser_from);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct BUnpadded(#[serde_as(as = "Vec<Base64<Standard, Unpadded>>")] Vec<Vec<u8>>);
+
+ is_equal(
+ BUnpadded(check_equal.clone()),
+ expect![[r#"
+ [
+ "AAECDQ",
+ "DgUGBw"
+ ]"#]],
+ );
+ check_deserialization(BUnpadded(check_deser.clone()), check_deser_from);
+}
+
+#[test]
+fn base64_different_charsets() {
+ let bytes = [
+ 0x69_u8, 0xb7, 0x1d, 0x79, 0xf8, 0x21, 0x8a, 0x39, 0x25, 0x9a, 0x7a, 0x29, 0xaa, 0xbb,
+ 0x2d, 0xba, 0xfc, 0x31, 0xcb, 0x30, 0x01, 0x08, 0x31, 0x05, 0x18, 0x72, 0x09, 0x28, 0xb3,
+ 0x0d, 0x38, 0xf4, 0x11, 0x49, 0x35, 0x15, 0x59, 0x76, 0x19, 0xd3, 0x5d, 0xb7, 0xe3, 0x9e,
+ 0xbb, 0xf3, 0xdf, 0xbf, 0x00,
+ ];
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B64Standard(#[serde_as(as = "Base64<Standard, Padded>")] Vec<u8>);
+
+ is_equal(
+ B64Standard(bytes.to_vec()),
+ expect![[r#""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/AA==""#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B64UrlSafe(#[serde_as(as = "Base64<UrlSafe, Padded>")] Vec<u8>);
+
+ is_equal(
+ B64UrlSafe(bytes.to_vec()),
+ expect![[r#""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_AA==""#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B64Crypt(#[serde_as(as = "Base64<Crypt, Padded>")] Vec<u8>);
+
+ is_equal(
+ B64Crypt(bytes.to_vec()),
+ expect![[r#""OPQRSTUVWXYZabcdefghijklmn./0123456789ABCDEFGHIJKLMNopqrstuvwxyz..==""#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B64Bcrypt(#[serde_as(as = "Base64<Bcrypt, Padded>")] Vec<u8>);
+
+ is_equal(
+ B64Bcrypt(bytes.to_vec()),
+ expect![[r#""YZabcdefghijklmnopqrstuvwx./ABCDEFGHIJKLMNOPQRSTUVWXyz0123456789..==""#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B64ImapMutf7(#[serde_as(as = "Base64<ImapMutf7, Padded>")] Vec<u8>);
+
+ is_equal(
+ B64ImapMutf7(bytes.to_vec()),
+ expect![[r#""abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+,AA==""#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B64BinHex(#[serde_as(as = "Base64<BinHex, Padded>")] Vec<u8>);
+
+ is_equal(
+ B64BinHex(bytes.to_vec()),
+ expect![[r##""CDEFGHIJKLMNPQRSTUVXYZ[`ab!\"#$%&'()*+,-0123456789@ABcdehijklmpqr!!==""##]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/chrono.rs b/third_party/rust/serde_with/tests/chrono.rs
new file mode 100644
index 0000000000..4bcb778a89
--- /dev/null
+++ b/third_party/rust/serde_with/tests/chrono.rs
@@ -0,0 +1,740 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+extern crate alloc;
+
+mod utils;
+
+use crate::utils::{
+ check_deserialization, check_error_deserialization, check_serialization, is_equal,
+};
+use alloc::collections::BTreeMap;
+use chrono_crate::{DateTime, Duration, Local, NaiveDateTime, Utc};
+use core::{iter::FromIterator, str::FromStr};
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::{
+ formats::Flexible, serde_as, DurationMicroSeconds, DurationMicroSecondsWithFrac,
+ DurationMilliSeconds, DurationMilliSecondsWithFrac, DurationNanoSeconds,
+ DurationNanoSecondsWithFrac, DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds,
+ TimestampMicroSecondsWithFrac, TimestampMilliSeconds, TimestampMilliSecondsWithFrac,
+ TimestampNanoSeconds, TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac,
+};
+
+fn new_datetime(secs: i64, nsecs: u32) -> DateTime<Utc> {
+ DateTime::from_utc(NaiveDateTime::from_timestamp(secs, nsecs), Utc)
+}
+
+#[test]
+fn json_datetime_from_any_to_string_deserialization() {
+ #[derive(Debug, PartialEq, Deserialize)]
+ struct S(#[serde(with = "serde_with::chrono::datetime_utc_ts_seconds_from_any")] DateTime<Utc>);
+
+ // just integers
+ check_deserialization(
+ vec![
+ S(new_datetime(1_478_563_200, 0)),
+ S(new_datetime(0, 0)),
+ S(new_datetime(-86000, 0)),
+ ],
+ r#"[
+ 1478563200,
+ 0,
+ -86000
+ ]"#,
+ );
+
+ // floats, shows precision errors in subsecond part
+ check_deserialization(
+ vec![
+ S(new_datetime(1_478_563_200, 122_999_906)),
+ S(new_datetime(0, 0)),
+ S(new_datetime(-86000, 998_999_999)),
+ ],
+ r#"[
+ 1478563200.123,
+ 0.000,
+ -86000.999
+ ]"#,
+ );
+
+ // string representation of floats
+ check_deserialization(
+ vec![
+ S(new_datetime(1_478_563_200, 123_000_000)),
+ S(new_datetime(0, 0)),
+ S(new_datetime(-86000, 999_000_000)),
+ ],
+ r#"[
+ "1478563200.123",
+ "0.000",
+ "-86000.999"
+ ]"#,
+ );
+}
+
+#[test]
+fn test_chrono_naive_date_time() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct S(#[serde_as(as = "DateTime<Utc>")] NaiveDateTime);
+
+ is_equal(
+ S(NaiveDateTime::from_str("1994-11-05T08:15:30").unwrap()),
+ expect![[r#""1994-11-05T08:15:30Z""#]],
+ );
+}
+
+#[test]
+fn test_chrono_option_naive_date_time() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct S(#[serde_as(as = "Option<DateTime<Utc>>")] Option<NaiveDateTime>);
+
+ is_equal(
+ S(NaiveDateTime::from_str("1994-11-05T08:15:30").ok()),
+ expect![[r#""1994-11-05T08:15:30Z""#]],
+ );
+}
+
+#[test]
+fn test_chrono_vec_option_naive_date_time() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct S(#[serde_as(as = "Vec<Option<DateTime<Utc>>>")] Vec<Option<NaiveDateTime>>);
+
+ is_equal(
+ S(vec![
+ NaiveDateTime::from_str("1994-11-05T08:15:30").ok(),
+ NaiveDateTime::from_str("1994-11-05T08:15:31").ok(),
+ ]),
+ expect![[r#"
+ [
+ "1994-11-05T08:15:30Z",
+ "1994-11-05T08:15:31Z"
+ ]"#]],
+ );
+}
+
+#[test]
+fn test_chrono_btreemap_naive_date_time() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct S(#[serde_as(as = "BTreeMap<_, DateTime<Utc>>")] BTreeMap<i32, NaiveDateTime>);
+
+ is_equal(
+ S(BTreeMap::from_iter(vec![
+ (1, NaiveDateTime::from_str("1994-11-05T08:15:30").unwrap()),
+ (2, NaiveDateTime::from_str("1994-11-05T08:15:31").unwrap()),
+ ])),
+ expect![[r#"
+ {
+ "1": "1994-11-05T08:15:30Z",
+ "2": "1994-11-05T08:15:31Z"
+ }"#]],
+ );
+}
+
+#[test]
+fn test_chrono_duration_seconds() {
+ let zero = Duration::zero();
+ let one_second = Duration::seconds(1);
+ let half_second = Duration::nanoseconds(500_000_000);
+ let minus_one_second = zero - one_second;
+ let minus_half_second = zero - half_second;
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructIntStrict(#[serde_as(as = "DurationSeconds<i64>")] Duration);
+
+ is_equal(StructIntStrict(zero), expect![[r#"0"#]]);
+ is_equal(StructIntStrict(one_second), expect![[r#"1"#]]);
+ is_equal(StructIntStrict(minus_one_second), expect![[r#"-1"#]]);
+ check_serialization(StructIntStrict(half_second), expect![[r#"1"#]]);
+ check_serialization(StructIntStrict(minus_half_second), expect![[r#"-1"#]]);
+ check_error_deserialization::<StructIntStrict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected i64 at line 1 column 3"#]],
+ );
+ check_error_deserialization::<StructIntStrict>(
+ r#"9223372036854775808"#,
+ expect![[
+ r#"invalid value: integer `9223372036854775808`, expected i64 at line 1 column 19"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructIntFlexible(#[serde_as(as = "DurationSeconds<i64, Flexible>")] Duration);
+
+ is_equal(StructIntFlexible(zero), expect![[r#"0"#]]);
+ is_equal(StructIntFlexible(one_second), expect![[r#"1"#]]);
+ check_serialization(StructIntFlexible(half_second), expect![[r#"1"#]]);
+ check_serialization(StructIntFlexible(minus_half_second), expect![[r#"-1"#]]);
+ check_deserialization(StructIntFlexible(half_second), r#""0.5""#);
+ check_deserialization(StructIntFlexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(StructIntFlexible(one_second), r#""1""#);
+ check_deserialization(StructIntFlexible(minus_one_second), r#""-1""#);
+ check_deserialization(StructIntFlexible(zero), r#""0""#);
+ check_error_deserialization::<StructIntFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Strict(#[serde_as(as = "DurationSeconds<f64>")] Duration);
+
+ is_equal(Structf64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Strict(minus_one_second), expect![[r#"-1.0"#]]);
+ check_serialization(Structf64Strict(half_second), expect![[r#"1.0"#]]);
+ check_serialization(Structf64Strict(minus_half_second), expect![[r#"-1.0"#]]);
+ check_deserialization(Structf64Strict(one_second), r#"0.5"#);
+ check_deserialization(Structf64Strict(minus_one_second), r#"-0.5"#);
+ check_error_deserialization::<Structf64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Flexible(#[serde_as(as = "DurationSeconds<f64, Flexible>")] Duration);
+
+ is_equal(Structf64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Flexible(minus_one_second), expect![[r#"-1.0"#]]);
+ check_serialization(Structf64Flexible(half_second), expect![[r#"1.0"#]]);
+ check_serialization(Structf64Flexible(minus_half_second), expect![[r#"-1.0"#]]);
+ check_deserialization(Structf64Flexible(half_second), r#""0.5""#);
+ check_deserialization(Structf64Flexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(Structf64Flexible(one_second), r#""1""#);
+ check_deserialization(Structf64Flexible(minus_one_second), r#""-1""#);
+ check_deserialization(Structf64Flexible(zero), r#""0""#);
+ check_error_deserialization::<Structf64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringStrict(#[serde_as(as = "DurationSeconds<String>")] Duration);
+
+ is_equal(StructStringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StructStringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringStrict(minus_one_second), expect![[r#""-1""#]]);
+ check_serialization(StructStringStrict(half_second), expect![[r#""1""#]]);
+ check_serialization(StructStringStrict(minus_half_second), expect![[r#""-1""#]]);
+ check_error_deserialization::<StructStringStrict>(
+ r#"1"#,
+ expect![[
+ r#"invalid type: integer `1`, expected a string containing a number at line 1 column 1"#
+ ]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"-1"#,
+ expect![[
+ r#"invalid type: integer `-1`, expected a string containing a number at line 1 column 2"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringFlexible(#[serde_as(as = "DurationSeconds<String, Flexible>")] Duration);
+
+ is_equal(StructStringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StructStringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringFlexible(minus_one_second), expect![[r#""-1""#]]);
+ check_serialization(StructStringFlexible(half_second), expect![[r#""1""#]]);
+ check_deserialization(StructStringFlexible(half_second), r#""0.5""#);
+ check_deserialization(StructStringFlexible(one_second), r#""1""#);
+ check_deserialization(StructStringFlexible(zero), r#""0""#);
+ check_error_deserialization::<StructStringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+}
+
+#[test]
+fn test_chrono_duration_seconds_with_frac() {
+ let zero = Duration::zero();
+ let one_second = Duration::seconds(1);
+ let half_second = Duration::nanoseconds(500_000_000);
+ let minus_one_second = zero - one_second;
+ let minus_half_second = zero - half_second;
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Strict(#[serde_as(as = "DurationSecondsWithFrac<f64>")] Duration);
+
+ is_equal(Structf64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Strict(minus_one_second), expect![[r#"-1.0"#]]);
+ is_equal(Structf64Strict(half_second), expect![[r#"0.5"#]]);
+ is_equal(Structf64Strict(minus_half_second), expect![[r#"-0.5"#]]);
+ check_error_deserialization::<Structf64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Flexible(#[serde_as(as = "DurationSecondsWithFrac<f64, Flexible>")] Duration);
+
+ is_equal(Structf64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Flexible(minus_one_second), expect![[r#"-1.0"#]]);
+ is_equal(Structf64Flexible(minus_half_second), expect![[r#"-0.5"#]]);
+ check_deserialization(Structf64Flexible(one_second), r#""1""#);
+ check_deserialization(Structf64Flexible(minus_one_second), r#""-1""#);
+ check_deserialization(Structf64Flexible(half_second), r#""0.5""#);
+ check_deserialization(Structf64Flexible(zero), r#""0""#);
+ check_error_deserialization::<Structf64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringStrict(#[serde_as(as = "DurationSecondsWithFrac<String>")] Duration);
+
+ is_equal(StructStringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StructStringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringStrict(minus_one_second), expect![[r#""-1""#]]);
+ is_equal(StructStringStrict(half_second), expect![[r#""0.5""#]]);
+ is_equal(
+ StructStringStrict(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ is_equal(
+ StructStringStrict(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"1"#,
+ expect![[r#"invalid type: integer `1`, expected a string at line 1 column 1"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"-1"#,
+ expect![[r#"invalid type: integer `-1`, expected a string at line 1 column 2"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringFlexible(
+ #[serde_as(as = "DurationSecondsWithFrac<String, Flexible>")] Duration,
+ );
+
+ is_equal(StructStringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StructStringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringFlexible(minus_one_second), expect![[r#""-1""#]]);
+ is_equal(StructStringFlexible(half_second), expect![[r#""0.5""#]]);
+ is_equal(
+ StructStringFlexible(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ check_deserialization(StructStringFlexible(one_second), r#""1""#);
+ check_deserialization(StructStringFlexible(zero), r#""0""#);
+ check_error_deserialization::<StructStringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+}
+
+#[test]
+fn test_chrono_timestamp_seconds() {
+ let zero = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc);
+ let one_second = zero + Duration::seconds(1);
+ let half_second = zero + Duration::nanoseconds(500_000_000);
+ let minus_one_second = zero - Duration::seconds(1);
+ let minus_half_second = zero - Duration::nanoseconds(500_000_000);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructIntStrict(#[serde_as(as = "TimestampSeconds")] DateTime<Utc>);
+
+ is_equal(StructIntStrict(zero), expect![[r#"0"#]]);
+ is_equal(StructIntStrict(one_second), expect![[r#"1"#]]);
+ is_equal(StructIntStrict(minus_one_second), expect![[r#"-1"#]]);
+ check_serialization(StructIntStrict(half_second), expect![[r#"1"#]]);
+ check_serialization(StructIntStrict(minus_half_second), expect![[r#"-1"#]]);
+ check_error_deserialization::<StructIntStrict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected i64 at line 1 column 3"#]],
+ );
+ check_error_deserialization::<StructIntStrict>(
+ r#"0.123"#,
+ expect![[r#"invalid type: floating point `0.123`, expected i64 at line 1 column 5"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructIntFlexible(#[serde_as(as = "TimestampSeconds<i64, Flexible>")] DateTime<Utc>);
+
+ is_equal(StructIntFlexible(zero), expect![[r#"0"#]]);
+ is_equal(StructIntFlexible(one_second), expect![[r#"1"#]]);
+ is_equal(StructIntFlexible(minus_one_second), expect![[r#"-1"#]]);
+ check_serialization(StructIntFlexible(half_second), expect![[r#"1"#]]);
+ check_serialization(StructIntFlexible(minus_half_second), expect![[r#"-1"#]]);
+ check_deserialization(StructIntFlexible(one_second), r#""1""#);
+ check_deserialization(StructIntFlexible(one_second), r#"1.0"#);
+ check_deserialization(StructIntFlexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(StructIntFlexible(half_second), r#"0.5"#);
+ check_error_deserialization::<StructIntFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Strict(#[serde_as(as = "TimestampSeconds<f64>")] DateTime<Utc>);
+
+ is_equal(Structf64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Strict(minus_one_second), expect![[r#"-1.0"#]]);
+ check_serialization(Structf64Strict(half_second), expect![[r#"1.0"#]]);
+ check_serialization(Structf64Strict(minus_half_second), expect![[r#"-1.0"#]]);
+ check_deserialization(Structf64Strict(one_second), r#"0.5"#);
+ check_error_deserialization::<Structf64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Flexible(#[serde_as(as = "TimestampSeconds<f64, Flexible>")] DateTime<Utc>);
+
+ is_equal(Structf64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Flexible(minus_one_second), expect![[r#"-1.0"#]]);
+ check_serialization(Structf64Flexible(half_second), expect![[r#"1.0"#]]);
+ check_serialization(Structf64Flexible(minus_half_second), expect![[r#"-1.0"#]]);
+ check_deserialization(Structf64Flexible(one_second), r#""1""#);
+ check_deserialization(Structf64Flexible(one_second), r#"1.0"#);
+ check_deserialization(Structf64Flexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(Structf64Flexible(half_second), r#"0.5"#);
+ check_error_deserialization::<Structf64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringStrict(#[serde_as(as = "TimestampSeconds<String>")] DateTime<Utc>);
+
+ is_equal(StructStringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StructStringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringStrict(minus_one_second), expect![[r#""-1""#]]);
+ check_serialization(StructStringStrict(half_second), expect![[r#""1""#]]);
+ check_serialization(StructStringStrict(minus_half_second), expect![[r#""-1""#]]);
+ check_deserialization(StructStringStrict(one_second), r#""1""#);
+ check_error_deserialization::<StructStringStrict>(
+ r#""0.5""#,
+ expect![[r#"invalid digit found in string at line 1 column 5"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#""-0.5""#,
+ expect![[r#"invalid digit found in string at line 1 column 6"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"1"#,
+ expect![[
+ r#"invalid type: integer `1`, expected a string containing a number at line 1 column 1"#
+ ]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"0.0"#,
+ expect![[
+ r#"invalid type: floating point `0`, expected a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringFlexible(
+ #[serde_as(as = "TimestampSeconds<String, Flexible>")] DateTime<Utc>,
+ );
+
+ is_equal(StructStringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StructStringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringFlexible(minus_one_second), expect![[r#""-1""#]]);
+ check_serialization(StructStringFlexible(half_second), expect![[r#""1""#]]);
+ check_serialization(
+ StructStringFlexible(minus_half_second),
+ expect![[r#""-1""#]],
+ );
+ check_deserialization(StructStringFlexible(one_second), r#"1"#);
+ check_deserialization(StructStringFlexible(one_second), r#"1.0"#);
+ check_deserialization(StructStringFlexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(StructStringFlexible(half_second), r#"0.5"#);
+ check_error_deserialization::<StructStringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+}
+
+#[test]
+fn test_chrono_timestamp_seconds_with_frac() {
+ let zero = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc);
+ let one_second = zero + Duration::seconds(1);
+ let half_second = zero + Duration::nanoseconds(500_000_000);
+ let minus_one_second = zero - Duration::seconds(1);
+ let minus_half_second = zero - Duration::nanoseconds(500_000_000);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Strict(#[serde_as(as = "TimestampSecondsWithFrac<f64>")] DateTime<Utc>);
+
+ is_equal(Structf64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Strict(minus_one_second), expect![[r#"-1.0"#]]);
+ is_equal(Structf64Strict(half_second), expect![[r#"0.5"#]]);
+ is_equal(Structf64Strict(minus_half_second), expect![[r#"-0.5"#]]);
+ check_error_deserialization::<Structf64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Flexible(
+ #[serde_as(as = "TimestampSecondsWithFrac<f64, Flexible>")] DateTime<Utc>,
+ );
+
+ is_equal(Structf64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Flexible(minus_one_second), expect![[r#"-1.0"#]]);
+ is_equal(Structf64Flexible(half_second), expect![[r#"0.5"#]]);
+ is_equal(Structf64Flexible(minus_half_second), expect![[r#"-0.5"#]]);
+ check_deserialization(Structf64Flexible(one_second), r#""1""#);
+ check_deserialization(Structf64Flexible(minus_half_second), r#""-0.5""#);
+ check_error_deserialization::<Structf64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringStrict(#[serde_as(as = "TimestampSecondsWithFrac<String>")] DateTime<Utc>);
+
+ is_equal(StructStringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StructStringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringStrict(minus_one_second), expect![[r#""-1""#]]);
+ is_equal(StructStringStrict(half_second), expect![[r#""0.5""#]]);
+ is_equal(
+ StructStringStrict(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"1"#,
+ expect![[r#"invalid type: integer `1`, expected a string at line 1 column 1"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"0.0"#,
+ expect![[r#"invalid type: floating point `0`, expected a string at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringFlexible(
+ #[serde_as(as = "TimestampSecondsWithFrac<String, Flexible>")] DateTime<Utc>,
+ );
+
+ is_equal(StructStringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StructStringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringFlexible(minus_one_second), expect![[r#""-1""#]]);
+ is_equal(StructStringFlexible(half_second), expect![[r#""0.5""#]]);
+ is_equal(
+ StructStringFlexible(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ check_deserialization(StructStringFlexible(one_second), r#"1"#);
+ check_deserialization(StructStringFlexible(one_second), r#"1.0"#);
+ check_deserialization(StructStringFlexible(half_second), r#"0.5"#);
+ check_error_deserialization::<StructStringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+}
+
+macro_rules! smoketest {
+ ($($valuety:ty, $adapter:literal, $value:expr, $expect:tt;)*) => {
+ $({
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = $adapter)] $valuety);
+ #[allow(unused_braces)]
+ is_equal(S($value), $expect);
+ })*
+ };
+}
+
+#[test]
+fn test_duration_smoketest() {
+ let zero = Duration::seconds(0);
+ let one_second = Duration::seconds(1);
+
+ smoketest! {
+ Duration, "DurationSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ Duration, "DurationSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ Duration, "DurationMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ Duration, "DurationMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ Duration, "DurationMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ Duration, "DurationMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ Duration, "DurationNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ Duration, "DurationNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ Duration, "DurationSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ Duration, "DurationSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ Duration, "DurationMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ Duration, "DurationMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ Duration, "DurationMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ Duration, "DurationMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ Duration, "DurationNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ Duration, "DurationNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ Duration, "DurationSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ Duration, "DurationSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ Duration, "DurationSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ Duration, "DurationSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ Duration, "DurationSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
+
+#[test]
+fn test_datetime_utc_smoketest() {
+ let zero = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc);
+ let one_second = zero + Duration::seconds(1);
+
+ smoketest! {
+ DateTime<Utc>, "TimestampSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ DateTime<Utc>, "TimestampSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ DateTime<Utc>, "TimestampMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ DateTime<Utc>, "TimestampMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ DateTime<Utc>, "TimestampMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ DateTime<Utc>, "TimestampMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ DateTime<Utc>, "TimestampNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ DateTime<Utc>, "TimestampNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ DateTime<Utc>, "TimestampSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ DateTime<Utc>, "TimestampSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ DateTime<Utc>, "TimestampMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ DateTime<Utc>, "TimestampMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ DateTime<Utc>, "TimestampMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ DateTime<Utc>, "TimestampMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ DateTime<Utc>, "TimestampNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ DateTime<Utc>, "TimestampNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ DateTime<Utc>, "TimestampSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ DateTime<Utc>, "TimestampSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ DateTime<Utc>, "TimestampSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ DateTime<Utc>, "TimestampSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ DateTime<Utc>, "TimestampSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
+
+#[test]
+fn test_datetime_local_smoketest() {
+ let zero =
+ DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(0, 0), Utc).with_timezone(&Local);
+ let one_second = zero + Duration::seconds(1);
+
+ smoketest! {
+ DateTime<Local>, "TimestampSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ DateTime<Local>, "TimestampSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ DateTime<Local>, "TimestampMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ DateTime<Local>, "TimestampMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ DateTime<Local>, "TimestampMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ DateTime<Local>, "TimestampMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ DateTime<Local>, "TimestampNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ DateTime<Local>, "TimestampNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ DateTime<Local>, "TimestampSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ DateTime<Local>, "TimestampSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ DateTime<Local>, "TimestampMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ DateTime<Local>, "TimestampMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ DateTime<Local>, "TimestampMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ DateTime<Local>, "TimestampMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ DateTime<Local>, "TimestampNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ DateTime<Local>, "TimestampNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ DateTime<Local>, "TimestampSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ DateTime<Local>, "TimestampSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ DateTime<Local>, "TimestampSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ DateTime<Local>, "TimestampSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ DateTime<Local>, "TimestampSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
+
+#[test]
+fn test_naive_datetime_smoketest() {
+ let zero = NaiveDateTime::from_timestamp(0, 0);
+ let one_second = zero + Duration::seconds(1);
+
+ smoketest! {
+ NaiveDateTime, "TimestampSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ NaiveDateTime, "TimestampSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ NaiveDateTime, "TimestampMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ NaiveDateTime, "TimestampMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ NaiveDateTime, "TimestampMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ NaiveDateTime, "TimestampMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ NaiveDateTime, "TimestampNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ NaiveDateTime, "TimestampNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ NaiveDateTime, "TimestampSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ NaiveDateTime, "TimestampSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ NaiveDateTime, "TimestampMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ NaiveDateTime, "TimestampMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ NaiveDateTime, "TimestampMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ NaiveDateTime, "TimestampMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ NaiveDateTime, "TimestampNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ NaiveDateTime, "TimestampNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ NaiveDateTime, "TimestampSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ NaiveDateTime, "TimestampSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ NaiveDateTime, "TimestampSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ NaiveDateTime, "TimestampSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ NaiveDateTime, "TimestampSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
diff --git a/third_party/rust/serde_with/tests/derives/deserialize_fromstr.rs b/third_party/rust/serde_with/tests/derives/deserialize_fromstr.rs
new file mode 100644
index 0000000000..26d60bf08f
--- /dev/null
+++ b/third_party/rust/serde_with/tests/derives/deserialize_fromstr.rs
@@ -0,0 +1,96 @@
+use super::*;
+use core::{
+ num::ParseIntError,
+ str::{FromStr, ParseBoolError},
+};
+use pretty_assertions::assert_eq;
+use serde_with::DeserializeFromStr;
+
+#[derive(Debug, PartialEq, DeserializeFromStr)]
+struct A {
+ a: u32,
+ b: bool,
+}
+
+impl FromStr for A {
+ type Err = String;
+
+ /// Parse a value like `123<>true`
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ let mut parts = s.split("<>");
+ let number = parts
+ .next()
+ .ok_or_else(|| "Missing first value".to_string())?
+ .parse()
+ .map_err(|err: ParseIntError| err.to_string())?;
+ let bool = parts
+ .next()
+ .ok_or_else(|| "Missing second value".to_string())?
+ .parse()
+ .map_err(|err: ParseBoolError| err.to_string())?;
+ Ok(Self { a: number, b: bool })
+ }
+}
+
+#[test]
+fn test_deserialize_fromstr() {
+ check_deserialization(A { a: 159, b: true }, "\"159<>true\"");
+ check_deserialization(A { a: 999, b: false }, "\"999<>false\"");
+ check_deserialization(A { a: 0, b: true }, "\"0<>true\"");
+}
+
+#[test]
+fn test_deserialize_from_bytes() {
+ use serde::de::{value::Error, Deserialize, Deserializer, Visitor};
+
+ // Unfortunately serde_json is too clever (i.e. handles bytes gracefully)
+ // so instead create a custom deserializer which can only deserialize bytes.
+ // All other deserialize_* fns are forwarded to deserialize_bytes
+ struct ByteDeserializer(&'static [u8]);
+
+ impl<'de> Deserializer<'de> for ByteDeserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_bytes(visitor)
+ }
+
+ fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_bytes(self.0)
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+ }
+
+ // callstack: A::deserialize -> deserialize_str -> deserialize_any ->
+ // deserialize_bytes -> visit_bytes -> visit_str -> success!
+ let a = A::deserialize(ByteDeserializer(b"159<>true")).unwrap();
+
+ assert_eq!(A { a: 159, b: true }, a);
+}
+
+#[test]
+fn test_deserialize_fromstr_in_vec() {
+ check_deserialization(
+ vec![
+ A { a: 123, b: false },
+ A { a: 0, b: true },
+ A { a: 999, b: true },
+ ],
+ r#"[
+ "123<>false",
+ "0<>true",
+ "999<>true"
+ ]"#,
+ );
+}
diff --git a/third_party/rust/serde_with/tests/derives/lib.rs b/third_party/rust/serde_with/tests/derives/lib.rs
new file mode 100644
index 0000000000..a43a3c3535
--- /dev/null
+++ b/third_party/rust/serde_with/tests/derives/lib.rs
@@ -0,0 +1,15 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+mod deserialize_fromstr;
+mod serialize_display;
+#[path = "../utils.rs"]
+mod utils;
+
+use expect_test::expect;
+use utils::*;
diff --git a/third_party/rust/serde_with/tests/derives/serialize_display.rs b/third_party/rust/serde_with/tests/derives/serialize_display.rs
new file mode 100644
index 0000000000..e660fa7535
--- /dev/null
+++ b/third_party/rust/serde_with/tests/derives/serialize_display.rs
@@ -0,0 +1,39 @@
+use super::*;
+use core::fmt;
+use serde_with::SerializeDisplay;
+
+#[derive(Debug, SerializeDisplay)]
+struct A {
+ a: u32,
+ b: bool,
+}
+
+impl fmt::Display for A {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "->{} <> {}<-", self.a, self.b)
+ }
+}
+
+#[test]
+fn test_serialize_display() {
+ check_serialization(A { a: 123, b: false }, expect![[r#""->123 <> false<-""#]]);
+ check_serialization(A { a: 0, b: true }, expect![[r#""->0 <> true<-""#]]);
+ check_serialization(A { a: 999, b: true }, expect![[r#""->999 <> true<-""#]]);
+}
+
+#[test]
+fn test_serialize_display_in_vec() {
+ check_serialization(
+ vec![
+ A { a: 123, b: false },
+ A { a: 0, b: true },
+ A { a: 999, b: true },
+ ],
+ expect![[r#"
+ [
+ "->123 <> false<-",
+ "->0 <> true<-",
+ "->999 <> true<-"
+ ]"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/hex.rs b/third_party/rust/serde_with/tests/hex.rs
new file mode 100644
index 0000000000..2994ae475e
--- /dev/null
+++ b/third_party/rust/serde_with/tests/hex.rs
@@ -0,0 +1,93 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+mod utils;
+
+use crate::utils::{check_deserialization, check_error_deserialization, is_equal};
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::{
+ formats::{Lowercase, Uppercase},
+ hex::Hex,
+ serde_as,
+};
+
+#[test]
+fn hex_vec() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B(#[serde_as(as = "Vec<Hex>")] Vec<Vec<u8>>);
+
+ is_equal(
+ B(vec![vec![0, 1, 2, 13], vec![14, 5, 6, 7]]),
+ expect![[r#"
+ [
+ "0001020d",
+ "0e050607"
+ ]"#]],
+ );
+
+ // Check mixed case deserialization
+ check_deserialization(
+ B(vec![vec![0xaa, 0xbc, 0xff], vec![0xe0, 0x7d]]),
+ r#"["aaBCff","E07d"]"#,
+ );
+
+ check_error_deserialization::<B>(
+ r#"["0"]"#,
+ expect![[r#"Odd number of digits at line 1 column 5"#]],
+ );
+ check_error_deserialization::<B>(
+ r#"["zz"]"#,
+ expect![[r#"Invalid character 'z' at position 0 at line 1 column 6"#]],
+ );
+}
+
+#[test]
+fn hex_vec_lowercase() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B(#[serde_as(as = "Vec<Hex<Lowercase>>")] Vec<Vec<u8>>);
+
+ is_equal(
+ B(vec![vec![0, 1, 2, 13], vec![14, 5, 6, 7]]),
+ expect![[r#"
+ [
+ "0001020d",
+ "0e050607"
+ ]"#]],
+ );
+
+ // Check mixed case deserialization
+ check_deserialization(
+ B(vec![vec![0xaa, 0xbc, 0xff], vec![0xe0, 0x7d]]),
+ r#"["aaBCff","E07d"]"#,
+ );
+}
+
+#[test]
+fn hex_vec_uppercase() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ pub struct B(#[serde_as(as = "Vec<Hex<Uppercase>>")] Vec<Vec<u8>>);
+
+ is_equal(
+ B(vec![vec![0, 1, 2, 13], vec![14, 5, 6, 7]]),
+ expect![[r#"
+ [
+ "0001020D",
+ "0E050607"
+ ]"#]],
+ );
+
+ // Check mixed case deserialization
+ check_deserialization(
+ B(vec![vec![0xaa, 0xbc, 0xff], vec![0xe0, 0x7d]]),
+ r#"["aaBCff","E07d"]"#,
+ );
+}
diff --git a/third_party/rust/serde_with/tests/indexmap.rs b/third_party/rust/serde_with/tests/indexmap.rs
new file mode 100644
index 0000000000..7e46b9c5c5
--- /dev/null
+++ b/third_party/rust/serde_with/tests/indexmap.rs
@@ -0,0 +1,285 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+mod utils;
+
+use crate::utils::{check_deserialization, check_error_deserialization, is_equal};
+use core::iter::FromIterator;
+use expect_test::expect;
+use indexmap_crate::{IndexMap, IndexSet};
+use serde::{Deserialize, Serialize};
+use serde_with::{serde_as, DisplayFromStr, Same};
+use std::net::IpAddr;
+
+#[test]
+fn test_indexmap() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "IndexMap<DisplayFromStr, DisplayFromStr>")] IndexMap<u8, u32>);
+
+ // Normal
+ is_equal(
+ S([(1, 1), (3, 3), (111, 111)].iter().cloned().collect()),
+ expect![[r#"
+ {
+ "1": "1",
+ "3": "3",
+ "111": "111"
+ }"#]],
+ );
+ is_equal(S(IndexMap::default()), expect![[r#"{}"#]]);
+}
+
+#[test]
+fn test_indexset() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "IndexSet<DisplayFromStr>")] IndexSet<u32>);
+
+ // Normal
+ is_equal(
+ S([1, 2, 3, 4, 5].iter().cloned().collect()),
+ expect![[r#"
+ [
+ "1",
+ "2",
+ "3",
+ "4",
+ "5"
+ ]"#]],
+ );
+ is_equal(S(IndexSet::default()), expect![[r#"[]"#]]);
+}
+
+#[test]
+fn test_map_as_tuple_list() {
+ let ip = "1.2.3.4".parse().unwrap();
+ let ip2 = "255.255.255.255".parse().unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SI(#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr)>")] IndexMap<u32, IpAddr>);
+
+ let map: IndexMap<_, _> = vec![(1, ip), (10, ip), (200, ip2)].into_iter().collect();
+ is_equal(
+ SI(map.clone()),
+ expect![[r#"
+ [
+ [
+ "1",
+ "1.2.3.4"
+ ],
+ [
+ "10",
+ "1.2.3.4"
+ ],
+ [
+ "200",
+ "255.255.255.255"
+ ]
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SI2(#[serde_as(as = "Vec<(Same, DisplayFromStr)>")] IndexMap<u32, IpAddr>);
+
+ is_equal(
+ SI2(map),
+ expect![[r#"
+ [
+ [
+ 1,
+ "1.2.3.4"
+ ],
+ [
+ 10,
+ "1.2.3.4"
+ ],
+ [
+ 200,
+ "255.255.255.255"
+ ]
+ ]"#]],
+ );
+}
+
+#[test]
+fn test_tuple_list_as_map() {
+ let ip = "1.2.3.4".parse().unwrap();
+ let ip2 = "255.255.255.255".parse().unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SI(
+ #[serde_as(as = "std::collections::HashMap<DisplayFromStr, DisplayFromStr>")]
+ IndexSet<(u32, IpAddr)>,
+ );
+
+ is_equal(
+ SI(IndexSet::from_iter(vec![(1, ip), (10, ip), (200, ip2)])),
+ expect![[r#"
+ {
+ "1": "1.2.3.4",
+ "10": "1.2.3.4",
+ "200": "255.255.255.255"
+ }"#]],
+ );
+}
+
+#[test]
+fn duplicate_key_first_wins_indexmap() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::maps_first_key_wins")] IndexMap<usize, usize>);
+
+ // Different value and key always works
+ is_equal(
+ S(IndexMap::from_iter(vec![(1, 1), (2, 2), (3, 3)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 2,
+ "3": 3
+ }"#]],
+ );
+
+ // Same value for different keys is ok
+ is_equal(
+ S(IndexMap::from_iter(vec![(1, 1), (2, 1), (3, 1)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 1,
+ "3": 1
+ }"#]],
+ );
+
+ // Duplicate keys, the first one is used
+ check_deserialization(
+ S(IndexMap::from_iter(vec![(1, 1), (2, 2)])),
+ r#"{"1": 1, "2": 2, "1": 3}"#,
+ );
+}
+
+#[test]
+fn prohibit_duplicate_key_indexmap() {
+ #[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "::serde_with::rust::maps_duplicate_key_is_error")] IndexMap<usize, usize>,
+ );
+
+ // Different value and key always works
+ is_equal(
+ S(IndexMap::from_iter(vec![(1, 1), (2, 2), (3, 3)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 2,
+ "3": 3
+ }"#]],
+ );
+
+ // Same value for different keys is ok
+ is_equal(
+ S(IndexMap::from_iter(vec![(1, 1), (2, 1), (3, 1)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 1,
+ "3": 1
+ }"#]],
+ );
+
+ // Duplicate keys are an error
+ check_error_deserialization::<S>(
+ r#"{"1": 1, "2": 2, "1": 3}"#,
+ expect![[r#"invalid entry: found duplicate key at line 1 column 24"#]],
+ );
+}
+
+#[test]
+fn duplicate_value_last_wins_indexset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::sets_last_value_wins")] IndexSet<W>);
+
+ #[derive(Debug, Eq, Deserialize, Serialize)]
+ struct W(i32, bool);
+ impl PartialEq for W {
+ fn eq(&self, other: &Self) -> bool {
+ self.0 == other.0
+ }
+ }
+ impl std::hash::Hash for W {
+ fn hash<H>(&self, state: &mut H)
+ where
+ H: std::hash::Hasher,
+ {
+ self.0.hash(state)
+ }
+ }
+
+ // Different values always work
+ is_equal(
+ S(IndexSet::from_iter(vec![
+ W(1, true),
+ W(2, false),
+ W(3, true),
+ ])),
+ expect![[r#"
+ [
+ [
+ 1,
+ true
+ ],
+ [
+ 2,
+ false
+ ],
+ [
+ 3,
+ true
+ ]
+ ]"#]],
+ );
+
+ let value: S = serde_json::from_str(
+ r#"[
+ [1, false],
+ [1, true],
+ [2, true],
+ [2, false]
+ ]"#,
+ )
+ .unwrap();
+ let entries: Vec<_> = value.0.into_iter().collect();
+ assert_eq!(1, entries[0].0);
+ assert!(entries[0].1);
+ assert_eq!(2, entries[1].0);
+ assert!(!entries[1].1);
+}
+
+#[test]
+fn prohibit_duplicate_value_indexset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::sets_duplicate_value_is_error")] IndexSet<usize>);
+
+ is_equal(
+ S(IndexSet::from_iter(vec![1, 2, 3, 4])),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 4
+ ]"#]],
+ );
+ check_error_deserialization::<S>(
+ r#"[1, 2, 3, 4, 1]"#,
+ expect![[r#"invalid entry: found duplicate value at line 1 column 15"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/json.rs b/third_party/rust/serde_with/tests/json.rs
new file mode 100644
index 0000000000..53c0baa146
--- /dev/null
+++ b/third_party/rust/serde_with/tests/json.rs
@@ -0,0 +1,41 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+mod utils;
+
+use crate::utils::is_equal;
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::{json::JsonString, serde_as, DisplayFromStr};
+
+#[test]
+fn test_nested_json() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Struct {
+ #[serde_as(as = "JsonString")]
+ value: Nested,
+ }
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Nested {
+ #[serde_as(as = "DisplayFromStr")]
+ value: u32,
+ }
+
+ is_equal(
+ Struct {
+ value: Nested { value: 444 },
+ },
+ expect![[r#"
+ {
+ "value": "{\"value\":\"444\"}"
+ }"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/rust.rs b/third_party/rust/serde_with/tests/rust.rs
new file mode 100644
index 0000000000..14accdb157
--- /dev/null
+++ b/third_party/rust/serde_with/tests/rust.rs
@@ -0,0 +1,676 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+extern crate alloc;
+
+mod utils;
+
+use crate::utils::{check_deserialization, check_error_deserialization, is_equal};
+use alloc::collections::{BTreeMap, BTreeSet, LinkedList, VecDeque};
+use core::{cmp, iter::FromIterator as _};
+use expect_test::expect;
+use fnv::{FnvHashMap as HashMap, FnvHashSet as HashSet};
+use pretty_assertions::assert_eq;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_with::CommaSeparator;
+
+#[test]
+fn string_collection() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "serde_with::rust::StringWithSeparator::<CommaSeparator>")] Vec<String>,
+ );
+
+ is_equal(S(vec![]), expect![[r#""""#]]);
+ is_equal(
+ S(vec![
+ "A".to_string(),
+ "B".to_string(),
+ "c".to_string(),
+ "D".to_string(),
+ ]),
+ expect![[r#""A,B,c,D""#]],
+ );
+ is_equal(
+ S(vec!["".to_string(), "".to_string(), "".to_string()]),
+ expect![[r#"",,""#]],
+ );
+ is_equal(
+ S(vec!["AVeryLongString".to_string()]),
+ expect![[r#""AVeryLongString""#]],
+ );
+}
+
+#[test]
+fn prohibit_duplicate_value_hashset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::sets_duplicate_value_is_error")] HashSet<usize>);
+
+ is_equal(
+ S(HashSet::from_iter(vec![1, 2, 3, 4])),
+ expect![[r#"
+ [
+ 4,
+ 1,
+ 3,
+ 2
+ ]"#]],
+ );
+ check_error_deserialization::<S>(
+ r#"[1, 2, 3, 4, 1]"#,
+ expect![[r#"invalid entry: found duplicate value at line 1 column 15"#]],
+ );
+}
+
+#[test]
+fn prohibit_duplicate_value_btreeset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::sets_duplicate_value_is_error")] BTreeSet<usize>);
+
+ is_equal(
+ S(BTreeSet::from_iter(vec![1, 2, 3, 4])),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 4
+ ]"#]],
+ );
+ check_error_deserialization::<S>(
+ r#"[1, 2, 3, 4, 1]"#,
+ expect![[r#"invalid entry: found duplicate value at line 1 column 15"#]],
+ );
+}
+
+#[test]
+fn prohibit_duplicate_key_hashmap() {
+ #[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "::serde_with::rust::maps_duplicate_key_is_error")] HashMap<usize, usize>,
+ );
+
+ // Different value and key always works
+ is_equal(
+ S(HashMap::from_iter(vec![(1, 1), (2, 2), (3, 3)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "3": 3,
+ "2": 2
+ }"#]],
+ );
+
+ // Same value for different keys is ok
+ is_equal(
+ S(HashMap::from_iter(vec![(1, 1), (2, 1), (3, 1)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "3": 1,
+ "2": 1
+ }"#]],
+ );
+
+ // Duplicate keys are an error
+ check_error_deserialization::<S>(
+ r#"{"1": 1, "2": 2, "1": 3}"#,
+ expect![[r#"invalid entry: found duplicate key at line 1 column 24"#]],
+ );
+}
+
+#[test]
+fn prohibit_duplicate_key_btreemap() {
+ #[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "::serde_with::rust::maps_duplicate_key_is_error")] BTreeMap<usize, usize>,
+ );
+
+ // Different value and key always works
+ is_equal(
+ S(BTreeMap::from_iter(vec![(1, 1), (2, 2), (3, 3)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 2,
+ "3": 3
+ }"#]],
+ );
+
+ // Same value for different keys is ok
+ is_equal(
+ S(BTreeMap::from_iter(vec![(1, 1), (2, 1), (3, 1)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 1,
+ "3": 1
+ }"#]],
+ );
+
+ // Duplicate keys are an error
+ check_error_deserialization::<S>(
+ r#"{"1": 1, "2": 2, "1": 3}"#,
+ expect![[r#"invalid entry: found duplicate key at line 1 column 24"#]],
+ );
+}
+
+#[test]
+fn duplicate_key_first_wins_hashmap() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::maps_first_key_wins")] HashMap<usize, usize>);
+
+ // Different value and key always works
+ is_equal(
+ S(HashMap::from_iter(vec![(1, 1), (2, 2), (3, 3)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "3": 3,
+ "2": 2
+ }"#]],
+ );
+
+ // Same value for different keys is ok
+ is_equal(
+ S(HashMap::from_iter(vec![(1, 1), (2, 1), (3, 1)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "3": 1,
+ "2": 1
+ }"#]],
+ );
+
+ // Duplicate keys, the first one is used
+ check_deserialization(
+ S(HashMap::from_iter(vec![(1, 1), (2, 2)])),
+ r#"{"1": 1, "2": 2, "1": 3}"#,
+ );
+}
+
+#[test]
+fn duplicate_key_first_wins_btreemap() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::maps_first_key_wins")] BTreeMap<usize, usize>);
+
+ // Different value and key always works
+ is_equal(
+ S(BTreeMap::from_iter(vec![(1, 1), (2, 2), (3, 3)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 2,
+ "3": 3
+ }"#]],
+ );
+
+ // Same value for different keys is ok
+ is_equal(
+ S(BTreeMap::from_iter(vec![(1, 1), (2, 1), (3, 1)])),
+ expect![[r#"
+ {
+ "1": 1,
+ "2": 1,
+ "3": 1
+ }"#]],
+ );
+
+ // Duplicate keys, the first one is used
+ check_deserialization(
+ S(BTreeMap::from_iter(vec![(1, 1), (2, 2)])),
+ r#"{"1": 1, "2": 2, "1": 3}"#,
+ );
+}
+
+#[test]
+fn duplicate_value_first_wins_hashset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(HashSet<W>);
+ // struct S(#[serde(with = "::serde_with::rust::sets_first_value_wins")] HashSet<W>);
+
+ #[derive(Debug, Eq, Deserialize, Serialize)]
+ struct W(i32, bool);
+ impl PartialEq for W {
+ fn eq(&self, other: &Self) -> bool {
+ self.0 == other.0
+ }
+ }
+ impl std::hash::Hash for W {
+ fn hash<H>(&self, state: &mut H)
+ where
+ H: std::hash::Hasher,
+ {
+ self.0.hash(state)
+ }
+ }
+
+ // Different values always work
+ is_equal(
+ S(HashSet::from_iter(vec![
+ W(1, true),
+ W(2, false),
+ W(3, true),
+ ])),
+ expect![[r#"
+ [
+ [
+ 1,
+ true
+ ],
+ [
+ 3,
+ true
+ ],
+ [
+ 2,
+ false
+ ]
+ ]"#]],
+ );
+
+ let value: S = serde_json::from_str(
+ r#"[
+ [1, false],
+ [1, true],
+ [2, true],
+ [2, false]
+ ]"#,
+ )
+ .unwrap();
+ let entries: Vec<_> = value.0.into_iter().collect();
+ assert_eq!(1, entries[0].0);
+ assert!(!entries[0].1);
+ assert_eq!(2, entries[1].0);
+ assert!(entries[1].1);
+}
+
+#[test]
+fn duplicate_value_last_wins_hashset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::sets_last_value_wins")] HashSet<W>);
+
+ #[derive(Debug, Eq, Deserialize, Serialize)]
+ struct W(i32, bool);
+ impl PartialEq for W {
+ fn eq(&self, other: &Self) -> bool {
+ self.0 == other.0
+ }
+ }
+ impl std::hash::Hash for W {
+ fn hash<H>(&self, state: &mut H)
+ where
+ H: std::hash::Hasher,
+ {
+ self.0.hash(state)
+ }
+ }
+
+ // Different values always work
+ is_equal(
+ S(HashSet::from_iter(vec![
+ W(1, true),
+ W(2, false),
+ W(3, true),
+ ])),
+ expect![[r#"
+ [
+ [
+ 1,
+ true
+ ],
+ [
+ 3,
+ true
+ ],
+ [
+ 2,
+ false
+ ]
+ ]"#]],
+ );
+
+ let value: S = serde_json::from_str(
+ r#"[
+ [1, false],
+ [1, true],
+ [2, true],
+ [2, false]
+ ]"#,
+ )
+ .unwrap();
+ let entries: Vec<_> = value.0.into_iter().collect();
+ assert_eq!(1, entries[0].0);
+ assert!(entries[0].1);
+ assert_eq!(2, entries[1].0);
+ assert!(!entries[1].1);
+}
+
+#[test]
+fn duplicate_value_last_wins_btreeset() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "::serde_with::rust::sets_last_value_wins")] BTreeSet<W>);
+ #[derive(Debug, Eq, Deserialize, Serialize)]
+ struct W(i32, bool);
+ impl PartialEq for W {
+ fn eq(&self, other: &Self) -> bool {
+ self.0 == other.0
+ }
+ }
+ impl Ord for W {
+ fn cmp(&self, other: &Self) -> cmp::Ordering {
+ self.0.cmp(&other.0)
+ }
+ }
+ impl PartialOrd for W {
+ fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+ Some(self.cmp(other))
+ }
+ }
+
+ // Different values always work
+ is_equal(
+ S(BTreeSet::from_iter(vec![
+ W(1, true),
+ W(2, false),
+ W(3, true),
+ ])),
+ expect![[r#"
+ [
+ [
+ 1,
+ true
+ ],
+ [
+ 2,
+ false
+ ],
+ [
+ 3,
+ true
+ ]
+ ]"#]],
+ );
+
+ let value: S = serde_json::from_str(
+ r#"[
+ [1, false],
+ [1, true],
+ [2, true],
+ [2, false]
+ ]"#,
+ )
+ .unwrap();
+ let entries: Vec<_> = value.0.into_iter().collect();
+ assert_eq!(1, entries[0].0);
+ assert!(entries[0].1);
+ assert_eq!(2, entries[1].0);
+ assert!(!entries[1].1);
+}
+
+#[test]
+fn test_map_as_tuple_list() {
+ #[derive(Debug, Deserialize, Serialize, PartialEq)]
+ struct Hash(#[serde(with = "serde_with::rust::map_as_tuple_list")] HashMap<String, u8>);
+
+ is_equal(
+ Hash(HashMap::from_iter(vec![
+ ("ABC".to_string(), 1),
+ ("Hello".to_string(), 0),
+ ("World".to_string(), 20),
+ ])),
+ expect![[r#"
+ [
+ [
+ "ABC",
+ 1
+ ],
+ [
+ "Hello",
+ 0
+ ],
+ [
+ "World",
+ 20
+ ]
+ ]"#]],
+ );
+ is_equal(
+ Hash(HashMap::from_iter(vec![("Hello".to_string(), 0)])),
+ expect![[r#"
+ [
+ [
+ "Hello",
+ 0
+ ]
+ ]"#]],
+ );
+ is_equal(Hash(HashMap::default()), expect![[r#"[]"#]]);
+
+ // Test parse error, only single element instead of tuple
+ check_error_deserialization::<Hash>(
+ r#"[ [1] ]"#,
+ expect![[r#"invalid type: integer `1`, expected a string at line 1 column 4"#]],
+ );
+
+ #[derive(Debug, Deserialize, Serialize, PartialEq)]
+ struct BTree(#[serde(with = "serde_with::rust::map_as_tuple_list")] BTreeMap<String, u8>);
+
+ is_equal(
+ BTree(BTreeMap::from_iter(vec![
+ ("ABC".to_string(), 1),
+ ("Hello".to_string(), 0),
+ ("World".to_string(), 20),
+ ])),
+ expect![[r#"
+ [
+ [
+ "ABC",
+ 1
+ ],
+ [
+ "Hello",
+ 0
+ ],
+ [
+ "World",
+ 20
+ ]
+ ]"#]],
+ );
+ is_equal(
+ BTree(BTreeMap::from_iter(vec![("Hello".to_string(), 0)])),
+ expect![[r#"
+ [
+ [
+ "Hello",
+ 0
+ ]
+ ]"#]],
+ );
+ is_equal(BTree(BTreeMap::default()), expect![[r#"[]"#]]);
+
+ // Test parse error, only single element instead of tuple
+ check_error_deserialization::<BTree>(
+ r#"[ [1] ]"#,
+ expect![[r#"invalid type: integer `1`, expected a string at line 1 column 4"#]],
+ );
+}
+
+#[test]
+fn tuple_list_as_map_vec() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "serde_with::rust::tuple_list_as_map")] Vec<(Wrapper<i32>, Wrapper<String>)>,
+ );
+ #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+ #[serde(transparent)]
+ struct Wrapper<T>(T);
+
+ is_equal(
+ S(vec![
+ (Wrapper(1), Wrapper("Hi".into())),
+ (Wrapper(2), Wrapper("Cake".into())),
+ (Wrapper(99), Wrapper("Lie".into())),
+ ]),
+ expect![[r#"
+ {
+ "1": "Hi",
+ "2": "Cake",
+ "99": "Lie"
+ }"#]],
+ );
+ is_equal(S(Vec::new()), expect![[r#"{}"#]]);
+ check_error_deserialization::<S>(
+ r#"[]"#,
+ expect![[r#"invalid type: sequence, expected a map at line 1 column 0"#]],
+ );
+ check_error_deserialization::<S>(
+ r#"null"#,
+ expect![[r#"invalid type: null, expected a map at line 1 column 4"#]],
+ );
+}
+
+#[test]
+fn tuple_list_as_map_linkedlist() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "serde_with::rust::tuple_list_as_map")]
+ LinkedList<(Wrapper<i32>, Wrapper<String>)>,
+ );
+ #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+ #[serde(transparent)]
+ struct Wrapper<T>(T);
+
+ is_equal(
+ S(LinkedList::from_iter(vec![
+ (Wrapper(1), Wrapper("Hi".into())),
+ (Wrapper(2), Wrapper("Cake".into())),
+ (Wrapper(99), Wrapper("Lie".into())),
+ ])),
+ expect![[r#"
+ {
+ "1": "Hi",
+ "2": "Cake",
+ "99": "Lie"
+ }"#]],
+ );
+ is_equal(S(LinkedList::new()), expect![[r#"{}"#]]);
+ check_error_deserialization::<S>(
+ r#"[]"#,
+ expect![[r#"invalid type: sequence, expected a map at line 1 column 0"#]],
+ );
+ check_error_deserialization::<S>(
+ r#"null"#,
+ expect![[r#"invalid type: null, expected a map at line 1 column 4"#]],
+ );
+}
+
+#[test]
+fn tuple_list_as_map_vecdeque() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(
+ #[serde(with = "serde_with::rust::tuple_list_as_map")]
+ VecDeque<(Wrapper<i32>, Wrapper<String>)>,
+ );
+ #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+ #[serde(transparent)]
+ struct Wrapper<T>(T);
+
+ is_equal(
+ S(VecDeque::from_iter(vec![
+ (Wrapper(1), Wrapper("Hi".into())),
+ (Wrapper(2), Wrapper("Cake".into())),
+ (Wrapper(99), Wrapper("Lie".into())),
+ ])),
+ expect![[r#"
+ {
+ "1": "Hi",
+ "2": "Cake",
+ "99": "Lie"
+ }"#]],
+ );
+ is_equal(S(VecDeque::new()), expect![[r#"{}"#]]);
+ check_error_deserialization::<S>(
+ r#"[]"#,
+ expect![[r#"invalid type: sequence, expected a map at line 1 column 0"#]],
+ );
+ check_error_deserialization::<S>(
+ r#"null"#,
+ expect![[r#"invalid type: null, expected a map at line 1 column 4"#]],
+ );
+}
+
+#[test]
+fn test_string_empty_as_none() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde(with = "serde_with::rust::string_empty_as_none")] Option<String>);
+
+ is_equal(S(Some("str".to_string())), expect![[r#""str""#]]);
+ check_deserialization(S(None), r#""""#);
+ check_deserialization(S(None), r#"null"#);
+}
+
+#[test]
+fn test_default_on_error() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S<T>(#[serde(with = "serde_with::rust::default_on_error")] T)
+ where
+ T: Default + Serialize + DeserializeOwned;
+
+ is_equal(S(123), expect![[r#"123"#]]);
+ is_equal(S("Hello World".to_string()), expect![[r#""Hello World""#]]);
+ is_equal(
+ S(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#]],
+ );
+
+ check_deserialization(S(0), r#"{}"#);
+ check_deserialization(S(0), r#"[]"#);
+ check_deserialization(S(0), r#"null"#);
+ check_deserialization(S(0), r#""A""#);
+
+ check_deserialization(S("".to_string()), r#"{}"#);
+ check_deserialization(S("".to_string()), r#"[]"#);
+ check_deserialization(S("".to_string()), r#"null"#);
+ check_deserialization(S("".to_string()), r#"0"#);
+
+ check_deserialization(S::<Vec<i32>>(vec![]), r#"{}"#);
+ check_deserialization(S::<Vec<i32>>(vec![]), r#"null"#);
+ check_deserialization(S::<Vec<i32>>(vec![]), r#"0"#);
+ check_deserialization(S::<Vec<i32>>(vec![]), r#""A""#);
+}
+
+#[test]
+fn test_default_on_null() {
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S<T>(#[serde(with = "serde_with::rust::default_on_null")] T)
+ where
+ T: Default + Serialize + DeserializeOwned;
+
+ is_equal(S(123), expect![[r#"123"#]]);
+ is_equal(S("Hello World".to_string()), expect![[r#""Hello World""#]]);
+ is_equal(
+ S(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#]],
+ );
+
+ check_deserialization(S(0), r#"null"#);
+ check_deserialization(S("".to_string()), r#"null"#);
+ check_deserialization(S::<Vec<i32>>(vec![]), r#"null"#);
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/collections.rs b/third_party/rust/serde_with/tests/serde_as/collections.rs
new file mode 100644
index 0000000000..dad84c4978
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/collections.rs
@@ -0,0 +1,44 @@
+use super::*;
+use fnv::{FnvHashMap, FnvHashSet};
+
+/// Test that HashSets are also supported with non-default hashers.
+#[test]
+fn test_fnv_hashset() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "FnvHashSet<DisplayFromStr>")] FnvHashSet<u32>);
+
+ // Normal
+ is_equal(
+ S([1, 2, 3, 4, 5].iter().cloned().collect()),
+ expect![[r#"
+ [
+ "5",
+ "4",
+ "1",
+ "3",
+ "2"
+ ]"#]],
+ );
+ is_equal(S(FnvHashSet::default()), expect![[r#"[]"#]]);
+}
+
+/// Test that HashSets are also supported with non-default hashers.
+#[test]
+fn test_fnv_hashmap() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "FnvHashMap<DisplayFromStr, DisplayFromStr>")] FnvHashMap<u8, u32>);
+
+ // Normal
+ is_equal(
+ S([(1, 1), (3, 3), (111, 111)].iter().cloned().collect()),
+ expect![[r#"
+ {
+ "1": "1",
+ "3": "3",
+ "111": "111"
+ }"#]],
+ );
+ is_equal(S(FnvHashMap::default()), expect![[r#"{}"#]]);
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/default_on.rs b/third_party/rust/serde_with/tests/serde_as/default_on.rs
new file mode 100644
index 0000000000..ea3678b166
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/default_on.rs
@@ -0,0 +1,130 @@
+use super::*;
+use serde_with::{DefaultOnError, DefaultOnNull};
+
+#[test]
+fn test_default_on_error() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "DefaultOnError<DisplayFromStr>")] u32);
+
+ // Normal
+ is_equal(S(123), expect![[r#""123""#]]);
+ is_equal(S(0), expect![[r#""0""#]]);
+ // Error cases
+ check_deserialization(S(0), r#""""#);
+ check_deserialization(S(0), r#""12+3""#);
+ check_deserialization(S(0), r#""abc""#);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2(#[serde_as(as = "DefaultOnError<Vec<DisplayFromStr>>")] Vec<u32>);
+
+ // Normal
+ is_equal(
+ S2(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#]],
+ );
+ is_equal(S2(vec![]), expect![[r#"[]"#]]);
+ // Error cases
+ check_deserialization(S2(vec![]), r#"2"#);
+ check_deserialization(S2(vec![]), r#""not_a_list""#);
+ check_deserialization(S2(vec![]), r#"{}"#);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Struct2 {
+ #[serde_as(as = "DefaultOnError<Vec<DisplayFromStr>>")]
+ value: Vec<u32>,
+ }
+ check_deserialization(Struct2 { value: vec![] }, r#"{"value":}"#);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S3(#[serde_as(as = "Vec<DefaultOnError<DisplayFromStr>>")] Vec<u32>);
+
+ // Normal
+ is_equal(
+ S3(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#]],
+ );
+ is_equal(S3(vec![]), expect![[r#"[]"#]]);
+ // Error cases
+ check_deserialization(S3(vec![0, 3, 0]), r#"[2,"3",4]"#);
+ check_deserialization(S3(vec![0, 0]), r#"["AA",5]"#);
+}
+
+#[test]
+fn test_default_on_null() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "DefaultOnNull<DisplayFromStr>")] u32);
+
+ // Normal
+ is_equal(S(123), expect![[r#""123""#]]);
+ is_equal(S(0), expect![[r#""0""#]]);
+ // Null case
+ check_deserialization(S(0), r#"null"#);
+ // Error cases
+ check_error_deserialization::<S>(
+ r#""12+3""#,
+ expect![[r#"invalid digit found in string at line 1 column 6"#]],
+ );
+ check_error_deserialization::<S>(
+ r#""abc""#,
+ expect![[r#"invalid digit found in string at line 1 column 5"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2(#[serde_as(as = "Vec<DefaultOnNull>")] Vec<u32>);
+
+ // Normal
+ is_equal(
+ S2(vec![1, 2, 0, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 0,
+ 3
+ ]"#]],
+ );
+ is_equal(S2(vec![]), expect![[r#"[]"#]]);
+ // Null cases
+ check_deserialization(S2(vec![1, 0, 2]), r#"[1, null, 2]"#);
+ check_error_deserialization::<S2>(
+ r#"["not_a_number"]"#,
+ expect![[r#"invalid type: string "not_a_number", expected u32 at line 1 column 15"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S3(#[serde_as(as = "Vec<DefaultOnNull<DisplayFromStr>>")] Vec<u32>);
+
+ // Normal
+ is_equal(
+ S3(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#]],
+ );
+ // Null case
+ check_deserialization(S3(vec![0, 3, 0]), r#"[null,"3",null]"#);
+ check_error_deserialization::<S3>(
+ r#"[null,3,null]"#,
+ expect![[r#"invalid type: integer `3`, expected a string at line 1 column 7"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/enum_map.rs b/third_party/rust/serde_with/tests/serde_as/enum_map.rs
new file mode 100644
index 0000000000..57a0b8ade4
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/enum_map.rs
@@ -0,0 +1,459 @@
+use super::*;
+use core::{fmt::Write as _, str::FromStr};
+use serde_test::Configure;
+use serde_with::EnumMap;
+use std::net::IpAddr;
+
+fn bytes_debug_readable(bytes: &[u8]) -> String {
+ let mut result = String::with_capacity(bytes.len() * 2);
+ for &byte in bytes {
+ match byte {
+ non_printable if !(0x20..0x7f).contains(&non_printable) => {
+ write!(result, "\\x{:02x}", byte).unwrap();
+ }
+ b'\\' => result.push_str("\\\\"),
+ _ => {
+ result.push(byte as char);
+ }
+ }
+ }
+ result
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+enum EnumValue {
+ Int(i32),
+ String(String),
+ Unit,
+ Tuple(i32, String, bool),
+ Struct {
+ a: i32,
+ b: String,
+ c: bool,
+ },
+ Ip(IpAddr, IpAddr),
+ #[serde(rename = "$value")]
+ Extra(serde_json::Value),
+}
+
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+struct VecEnumValues {
+ #[serde_as(as = "EnumMap")]
+ vec: Vec<EnumValue>,
+}
+
+#[test]
+fn json_round_trip() {
+ let values = VecEnumValues {
+ vec: 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,
+ },
+ ],
+ };
+
+ let json = serde_json::to_string_pretty(&values).unwrap();
+ expect_test::expect![[r#"
+ {
+ "vec": {
+ "Int": 123,
+ "String": "FooBar",
+ "Int": 456,
+ "String": "XXX",
+ "Unit": null,
+ "Tuple": [
+ 1,
+ "Middle",
+ false
+ ],
+ "Struct": {
+ "a": 666,
+ "b": "BBB",
+ "c": true
+ }
+ }
+ }"#]]
+ .assert_eq(&json);
+ let deser_values: VecEnumValues = serde_json::from_str(&json).unwrap();
+ assert_eq!(values, deser_values);
+}
+
+#[test]
+fn ron_serialize() {
+ let values = VecEnumValues {
+ vec: 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,
+ },
+ ],
+ };
+
+ let pretty_config = ron::ser::PrettyConfig::new().new_line("\n".into());
+ let ron = ron::ser::to_string_pretty(&values, pretty_config).unwrap();
+ expect_test::expect![[r#"
+ (
+ vec: {
+ "Int": 123,
+ "String": "FooBar",
+ "Int": 456,
+ "String": "XXX",
+ "Unit": (),
+ "Tuple": (1, "Middle", false),
+ "Struct": (
+ a: 666,
+ b: "BBB",
+ c: true,
+ ),
+ },
+ )"#]]
+ .assert_eq(&ron);
+ // TODO deserializing a Strings as an Identifier seems unsupported
+ let deser_values: ron::Value = ron::de::from_str(&ron).unwrap();
+ expect_test::expect![[r#"
+ Map(
+ Map(
+ {
+ String(
+ "vec",
+ ): Map(
+ Map(
+ {
+ String(
+ "Int",
+ ): Number(
+ Integer(
+ 456,
+ ),
+ ),
+ String(
+ "String",
+ ): String(
+ "XXX",
+ ),
+ String(
+ "Struct",
+ ): Map(
+ Map(
+ {
+ String(
+ "a",
+ ): Number(
+ Integer(
+ 666,
+ ),
+ ),
+ String(
+ "b",
+ ): String(
+ "BBB",
+ ),
+ String(
+ "c",
+ ): Bool(
+ true,
+ ),
+ },
+ ),
+ ),
+ String(
+ "Tuple",
+ ): Seq(
+ [
+ Number(
+ Integer(
+ 1,
+ ),
+ ),
+ String(
+ "Middle",
+ ),
+ Bool(
+ false,
+ ),
+ ],
+ ),
+ String(
+ "Unit",
+ ): Unit,
+ },
+ ),
+ ),
+ },
+ ),
+ )
+ "#]]
+ .assert_debug_eq(&deser_values);
+}
+
+#[test]
+fn xml_round_trip() {
+ let values = VecEnumValues {
+ vec: vec![
+ EnumValue::Int(123),
+ EnumValue::String("FooBar".to_string()),
+ EnumValue::Int(456),
+ EnumValue::String("XXX".to_string()),
+ EnumValue::Unit,
+ // serialize_tuple and variants are not supported by XML
+ // EnumValue::Tuple(1, "Middle".to_string(), false),
+ // Cannot be deserialized. It serializes to:
+ // <Struct><EnumValue><a>666</a><b>BBB</b><c>true</c></EnumValue></Struct>
+ // EnumValue::Struct {
+ // a: 666,
+ // b: "BBB".to_string(),
+ // c: true,
+ // },
+ ],
+ };
+
+ let xml = serde_xml_rs::to_string(&values).unwrap();
+ expect_test::expect![[r#"<VecEnumValues><vec><Int>123</Int><String>FooBar</String><Int>456</Int><String>XXX</String><Unit></Unit></vec></VecEnumValues>"#]]
+ .assert_eq(&xml);
+ let deser_values: VecEnumValues = serde_xml_rs::from_str(&xml).unwrap();
+ assert_eq!(values, deser_values);
+}
+
+#[test]
+fn serde_test_round_trip() {
+ let values = VecEnumValues {
+ vec: 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,
+ },
+ ],
+ };
+
+ use serde_test::Token::*;
+ serde_test::assert_tokens(
+ &values.readable(),
+ &[
+ Struct {
+ name: "VecEnumValues",
+ len: 1,
+ },
+ Str("vec"),
+ Map {
+ len: Option::Some(7),
+ },
+ Str("Int"),
+ I32(123),
+ Str("String"),
+ Str("FooBar"),
+ Str("Int"),
+ I32(456),
+ Str("String"),
+ Str("XXX"),
+ Str("Unit"),
+ Unit,
+ Str("Tuple"),
+ TupleStruct {
+ name: "EnumValue",
+ len: 3,
+ },
+ I32(1),
+ Str("Middle"),
+ Bool(false),
+ TupleStructEnd,
+ Str("Struct"),
+ Struct {
+ name: "EnumValue",
+ len: 3,
+ },
+ Str("a"),
+ I32(666),
+ Str("b"),
+ Str("BBB"),
+ Str("c"),
+ Bool(true),
+ StructEnd,
+ MapEnd,
+ StructEnd,
+ ],
+ );
+}
+
+#[test]
+fn serde_test_round_trip_human_readable() {
+ let values = VecEnumValues {
+ vec: vec![EnumValue::Ip(
+ IpAddr::from_str("127.0.0.1").unwrap(),
+ IpAddr::from_str("::7777:dead:beef").unwrap(),
+ )],
+ };
+
+ use serde_test::Token::*;
+ serde_test::assert_tokens(
+ &values.clone().readable(),
+ &[
+ Struct {
+ name: "VecEnumValues",
+ len: 1,
+ },
+ Str("vec"),
+ Map {
+ len: Option::Some(1),
+ },
+ Str("Ip"),
+ TupleStruct {
+ name: "EnumValue",
+ len: 2,
+ },
+ Str("127.0.0.1"),
+ Str("::7777:dead:beef"),
+ TupleStructEnd,
+ MapEnd,
+ StructEnd,
+ ],
+ );
+
+ serde_test::assert_tokens(
+ &values.compact(),
+ &[
+ Struct {
+ name: "VecEnumValues",
+ len: 1,
+ },
+ Str("vec"),
+ Map {
+ len: Option::Some(1),
+ },
+ Str("Ip"),
+ TupleStruct {
+ name: "EnumValue",
+ len: 2,
+ },
+ NewtypeVariant {
+ name: "IpAddr",
+ variant: "V4",
+ },
+ Tuple { len: 4 },
+ U8(127),
+ U8(0),
+ U8(0),
+ U8(1),
+ TupleEnd,
+ NewtypeVariant {
+ name: "IpAddr",
+ variant: "V6",
+ },
+ Tuple { len: 16 },
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0),
+ U8(0x77),
+ U8(0x77),
+ U8(0xde),
+ U8(0xad),
+ U8(0xbe),
+ U8(0xef),
+ TupleEnd,
+ TupleStructEnd,
+ MapEnd,
+ StructEnd,
+ ],
+ );
+}
+
+// Bincode does not support Deserializer::deserialize_identifier
+// https://github.com/bincode-org/bincode/blob/e0ac3245162ba668ba04591897dd88ff5b3096b8/src/de/mod.rs#L442
+
+#[test]
+fn rmp_round_trip() {
+ let values = VecEnumValues {
+ vec: 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,
+ },
+ EnumValue::Ip(
+ IpAddr::from_str("127.0.0.1").unwrap(),
+ IpAddr::from_str("::7777:dead:beef").unwrap(),
+ ),
+ ],
+ };
+
+ let rmp = rmp_serde::to_vec(&values).unwrap();
+ expect_test::expect![[r#"\x91\x88\xa3Int{\xa6String\xa6FooBar\xa3Int\xcd\x01\xc8\xa6String\xa3XXX\xa4Unit\xc0\xa5Tuple\x93\x01\xa6Middle\xc2\xa6Struct\x93\xcd\x02\x9a\xa3BBB\xc3\xa2Ip\x92\x81\xa2V4\x94\x7f\x00\x00\x01\x81\xa2V6\xdc\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00ww\xcc\xde\xcc\xad\xcc\xbe\xcc\xef"#]]
+ .assert_eq(&bytes_debug_readable(&rmp));
+ let deser_values: VecEnumValues = rmp_serde::from_read(&*rmp).unwrap();
+ assert_eq!(values, deser_values);
+}
+
+#[test]
+fn yaml_round_trip() {
+ // Duplicate enum variants do not work with YAML
+ let values = VecEnumValues {
+ vec: 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,
+ },
+ ],
+ };
+
+ let yaml = serde_yaml::to_string(&values).unwrap();
+ expect_test::expect![[r#"
+ ---
+ vec:
+ Int: 123
+ String: FooBar
+ Unit: ~
+ Tuple:
+ - 1
+ - Middle
+ - false
+ Struct:
+ a: 666
+ b: BBB
+ c: true
+ "#]]
+ .assert_eq(&yaml);
+ let deser_values: VecEnumValues = serde_yaml::from_str(&yaml).unwrap();
+ assert_eq!(values, deser_values);
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/frominto.rs b/third_party/rust/serde_with/tests/serde_as/frominto.rs
new file mode 100644
index 0000000000..f7f3cac213
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/frominto.rs
@@ -0,0 +1,187 @@
+use super::*;
+use core::convert::TryFrom;
+use serde_with::{FromInto, TryFromInto};
+
+#[derive(Clone, Debug, PartialEq)]
+enum IntoSerializable {
+ A,
+ B,
+ C,
+}
+
+impl From<IntoSerializable> for String {
+ fn from(value: IntoSerializable) -> Self {
+ match value {
+ IntoSerializable::A => "String A",
+ IntoSerializable::B => "Some other value",
+ IntoSerializable::C => "Looks like 123",
+ }
+ .to_string()
+ }
+}
+
+#[derive(Debug, PartialEq)]
+enum FromDeserializable {
+ Zero,
+ Odd(u32),
+ Even(u32),
+}
+
+impl From<u32> for FromDeserializable {
+ fn from(value: u32) -> Self {
+ match value {
+ 0 => FromDeserializable::Zero,
+ e if e % 2 == 0 => FromDeserializable::Even(e),
+ o => FromDeserializable::Odd(o),
+ }
+ }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum LikeBool {
+ Trueish,
+ Falseisch,
+}
+
+impl From<bool> for LikeBool {
+ fn from(b: bool) -> Self {
+ if b {
+ LikeBool::Trueish
+ } else {
+ LikeBool::Falseisch
+ }
+ }
+}
+
+impl From<LikeBool> for bool {
+ fn from(lb: LikeBool) -> Self {
+ match lb {
+ LikeBool::Trueish => true,
+ LikeBool::Falseisch => false,
+ }
+ }
+}
+
+#[test]
+fn test_frominto_ser() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize)]
+ struct S(#[serde_as(serialize_as = "FromInto<String>")] IntoSerializable);
+
+ check_serialization(S(IntoSerializable::A), expect![[r#""String A""#]]);
+ check_serialization(S(IntoSerializable::B), expect![[r#""Some other value""#]]);
+ check_serialization(S(IntoSerializable::C), expect![[r#""Looks like 123""#]]);
+}
+
+#[test]
+fn test_tryfrominto_ser() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize)]
+ struct S(#[serde_as(serialize_as = "TryFromInto<String>")] IntoSerializable);
+
+ check_serialization(S(IntoSerializable::A), expect![[r#""String A""#]]);
+ check_serialization(S(IntoSerializable::B), expect![[r#""Some other value""#]]);
+ check_serialization(S(IntoSerializable::C), expect![[r#""Looks like 123""#]]);
+}
+
+#[test]
+fn test_frominto_de() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize)]
+ struct S(#[serde_as(deserialize_as = "FromInto<u32>")] FromDeserializable);
+
+ check_deserialization(S(FromDeserializable::Zero), "0");
+ check_deserialization(S(FromDeserializable::Odd(1)), "1");
+ check_deserialization(S(FromDeserializable::Odd(101)), "101");
+ check_deserialization(S(FromDeserializable::Even(2)), "2");
+ check_deserialization(S(FromDeserializable::Even(202)), "202");
+}
+
+#[test]
+fn test_tryfrominto_de() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize)]
+ struct S(#[serde_as(deserialize_as = "TryFromInto<u32>")] FromDeserializable);
+
+ check_deserialization(S(FromDeserializable::Zero), "0");
+ check_deserialization(S(FromDeserializable::Odd(1)), "1");
+ check_deserialization(S(FromDeserializable::Odd(101)), "101");
+ check_deserialization(S(FromDeserializable::Even(2)), "2");
+ check_deserialization(S(FromDeserializable::Even(202)), "202");
+}
+
+#[test]
+fn test_frominto_de_and_ser() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde_as(as = "FromInto<bool>")] LikeBool);
+
+ is_equal(S(LikeBool::Trueish), expect![[r#"true"#]]);
+ is_equal(S(LikeBool::Falseisch), expect![[r#"false"#]]);
+}
+
+#[test]
+fn test_tryfrominto_de_and_ser() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde_as(as = "TryFromInto<bool>")] LikeBool);
+
+ is_equal(S(LikeBool::Trueish), expect![[r#"true"#]]);
+ is_equal(S(LikeBool::Falseisch), expect![[r#"false"#]]);
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum TryIntoSerializable {
+ Works,
+ Fails,
+}
+
+impl TryFrom<TryIntoSerializable> for String {
+ type Error = &'static str;
+
+ fn try_from(value: TryIntoSerializable) -> Result<Self, Self::Error> {
+ match value {
+ TryIntoSerializable::Works => Ok("Works".to_string()),
+ TryIntoSerializable::Fails => Err("Fails cannot be turned into String"),
+ }
+ }
+}
+
+#[derive(Debug, PartialEq)]
+enum TryFromDeserializable {
+ Zero,
+}
+
+impl TryFrom<u32> for TryFromDeserializable {
+ type Error = &'static str;
+
+ fn try_from(value: u32) -> Result<Self, Self::Error> {
+ match value {
+ 0 => Ok(TryFromDeserializable::Zero),
+ _ => Err("Number is not zero"),
+ }
+ }
+}
+
+#[test]
+fn test_tryfrominto_ser_with_error() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize)]
+ struct S(#[serde_as(serialize_as = "TryFromInto<String>")] TryIntoSerializable);
+
+ check_serialization(S(TryIntoSerializable::Works), expect![[r#""Works""#]]);
+ check_error_serialization(
+ S(TryIntoSerializable::Fails),
+ expect![[r#"Fails cannot be turned into String"#]],
+ );
+}
+
+#[test]
+fn test_tryfrominto_de_with_error() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize)]
+ struct S(#[serde_as(deserialize_as = "TryFromInto<u32>")] TryFromDeserializable);
+
+ check_deserialization(S(TryFromDeserializable::Zero), "0");
+ check_error_deserialization::<S>("1", expect![[r#"Number is not zero"#]]);
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/lib.rs b/third_party/rust/serde_with/tests/serde_as/lib.rs
new file mode 100644
index 0000000000..0b40ce0c26
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/lib.rs
@@ -0,0 +1,1129 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+extern crate alloc;
+
+mod collections;
+mod default_on;
+mod enum_map;
+mod frominto;
+mod map_tuple_list;
+mod pickfirst;
+mod serde_as_macro;
+mod serde_conv;
+mod time;
+#[path = "../utils.rs"]
+mod utils;
+
+use crate::utils::*;
+use alloc::{
+ collections::{BTreeMap, BTreeSet, LinkedList, VecDeque},
+ rc::{Rc, Weak as RcWeak},
+ sync::{Arc, Weak as ArcWeak},
+};
+use core::cell::{Cell, RefCell};
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::{
+ formats::{Flexible, Strict},
+ serde_as, BoolFromInt, BytesOrString, CommaSeparator, DisplayFromStr, NoneAsEmptyString,
+ OneOrMany, Same, StringWithSeparator,
+};
+use std::{
+ collections::HashMap,
+ sync::{Mutex, RwLock},
+};
+
+#[test]
+fn test_basic_wrappers() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SBox(#[serde_as(as = "Box<DisplayFromStr>")] Box<u32>);
+
+ is_equal(SBox(Box::new(123)), expect![[r#""123""#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SRc(#[serde_as(as = "Rc<DisplayFromStr>")] Rc<u32>);
+
+ is_equal(SRc(Rc::new(123)), expect![[r#""123""#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize)]
+ struct SRcWeak(#[serde_as(as = "RcWeak<DisplayFromStr>")] RcWeak<u32>);
+
+ check_serialization(SRcWeak(RcWeak::new()), expect![[r#"null"#]]);
+ let s: SRcWeak = serde_json::from_str("null").unwrap();
+ assert!(s.0.upgrade().is_none());
+ let s: SRcWeak = serde_json::from_str("\"123\"").unwrap();
+ assert!(s.0.upgrade().is_none());
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SArc(#[serde_as(as = "Arc<DisplayFromStr>")] Arc<u32>);
+
+ is_equal(SArc(Arc::new(123)), expect![[r#""123""#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize)]
+ struct SArcWeak(#[serde_as(as = "ArcWeak<DisplayFromStr>")] ArcWeak<u32>);
+
+ check_serialization(SArcWeak(ArcWeak::new()), expect![[r#"null"#]]);
+ let s: SArcWeak = serde_json::from_str("null").unwrap();
+ assert!(s.0.upgrade().is_none());
+ let s: SArcWeak = serde_json::from_str("\"123\"").unwrap();
+ assert!(s.0.upgrade().is_none());
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SCell(#[serde_as(as = "Cell<DisplayFromStr>")] Cell<u32>);
+
+ is_equal(SCell(Cell::new(123)), expect![[r#""123""#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SRefCell(#[serde_as(as = "RefCell<DisplayFromStr>")] RefCell<u32>);
+
+ is_equal(SRefCell(RefCell::new(123)), expect![[r#""123""#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize)]
+ struct SMutex(#[serde_as(as = "Mutex<DisplayFromStr>")] Mutex<u32>);
+
+ check_serialization(SMutex(Mutex::new(123)), expect![[r#""123""#]]);
+ let s: SMutex = serde_json::from_str("\"123\"").unwrap();
+ assert_eq!(*s.0.lock().unwrap(), 123);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize)]
+ struct SRwLock(#[serde_as(as = "RwLock<DisplayFromStr>")] RwLock<u32>);
+
+ let expected = expect![[r#""123""#]];
+ check_serialization(SRwLock(RwLock::new(123)), expected);
+ let s: SRwLock = serde_json::from_str("\"123\"").unwrap();
+ assert_eq!(*s.0.read().unwrap(), 123);
+}
+
+#[test]
+fn test_option() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "_")] Option<u32>);
+
+ is_equal(S(None), expect![[r#"null"#]]);
+ is_equal(S(Some(9)), expect![[r#"9"#]]);
+ check_error_deserialization::<S>(
+ r#"{}"#,
+ expect![[r#"invalid type: map, expected u32 at line 1 column 0"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Struct {
+ #[serde_as(as = "_")]
+ value: Option<u32>,
+ }
+ check_error_deserialization::<Struct>(
+ r#"{}"#,
+ expect![[r#"missing field `value` at line 1 column 2"#]],
+ );
+}
+
+#[test]
+fn test_result() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(
+ #[serde_as(as = "Result<StringWithSeparator<CommaSeparator, u32>, DisplayFromStr>")]
+ Result<Vec<u32>, u32>,
+ );
+
+ is_equal(
+ S(Ok(vec![1, 2, 3])),
+ expect![[r#"
+ {
+ "Ok": "1,2,3"
+ }"#]],
+ );
+ is_equal(
+ S(Err(9)),
+ expect![[r#"
+ {
+ "Err": "9"
+ }"#]],
+ );
+ check_error_deserialization::<S>(r#"{}"#, expect![[r#"expected value at line 1 column 2"#]]);
+}
+
+#[test]
+fn test_display_fromstr() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "DisplayFromStr")] u32);
+
+ is_equal(S(123), expect![[r#""123""#]]);
+}
+
+#[test]
+fn test_tuples() {
+ use std::net::IpAddr;
+ let ip = "1.2.3.4".parse().unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S1(#[serde_as(as = "(DisplayFromStr,)")] (u32,));
+ is_equal(
+ S1((1,)),
+ expect![[r#"
+ [
+ "1"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2a(#[serde_as(as = "(DisplayFromStr, DisplayFromStr)")] (u32, IpAddr));
+ is_equal(
+ S2a((555_888, ip)),
+ expect![[r#"
+ [
+ "555888",
+ "1.2.3.4"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2b(#[serde_as(as = "(_, DisplayFromStr)")] (u32, IpAddr));
+ is_equal(
+ S2b((987, ip)),
+ expect![[r#"
+ [
+ 987,
+ "1.2.3.4"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2c(#[serde_as(as = "(Same, DisplayFromStr)")] (u32, IpAddr));
+ is_equal(
+ S2c((987, ip)),
+ expect![[r#"
+ [
+ 987,
+ "1.2.3.4"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S6(
+ #[serde_as(as = "(Same, Same, Same, Same, Same, Same)")] (u8, u16, u32, i8, i16, i32),
+ );
+ is_equal(
+ S6((8, 16, 32, -8, 16, -32)),
+ expect![[r#"
+ [
+ 8,
+ 16,
+ 32,
+ -8,
+ 16,
+ -32
+ ]"#]],
+ );
+}
+
+#[test]
+fn test_arrays() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S0(#[serde_as(as = "[DisplayFromStr; 0]")] [u32; 0]);
+ is_equal(S0([]), expect![[r#"[]"#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S1(#[serde_as(as = "[DisplayFromStr; 1]")] [u32; 1]);
+ is_equal(
+ S1([1]),
+ expect![[r#"
+ [
+ "1"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2(#[serde_as(as = "[Same; 2]")] [u32; 2]);
+ is_equal(
+ S2([11, 22]),
+ expect![[r#"
+ [
+ 11,
+ 22
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S32(#[serde_as(as = "[Same; 32]")] [u32; 32]);
+ is_equal(
+ S32([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 26, 27, 28, 29, 30, 31,
+ ]),
+ expect![[r#"
+ [
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ 10,
+ 11,
+ 12,
+ 13,
+ 14,
+ 15,
+ 16,
+ 17,
+ 18,
+ 19,
+ 20,
+ 21,
+ 22,
+ 23,
+ 24,
+ 25,
+ 26,
+ 27,
+ 28,
+ 29,
+ 30,
+ 31
+ ]"#]],
+ );
+}
+
+#[test]
+fn test_sequence_like_types() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S1(#[serde_as(as = "Box<[Same]>")] Box<[u32]>);
+ is_equal(
+ S1(vec![1, 2, 3, 99].into()),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 99
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2(#[serde_as(as = "BTreeSet<Same>")] BTreeSet<u32>);
+ is_equal(
+ S2(vec![1, 2, 3, 99].into_iter().collect()),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 99
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S3(#[serde_as(as = "LinkedList<Same>")] LinkedList<u32>);
+ is_equal(
+ S3(vec![1, 2, 3, 99].into_iter().collect()),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 99
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S4(#[serde_as(as = "Vec<Same>")] Vec<u32>);
+ is_equal(
+ S4(vec![1, 2, 3, 99]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 99
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S5(#[serde_as(as = "VecDeque<Same>")] VecDeque<u32>);
+ is_equal(
+ S5(vec![1, 2, 3, 99].into()),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3,
+ 99
+ ]"#]],
+ );
+}
+
+#[test]
+fn test_none_as_empty_string() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "NoneAsEmptyString")] Option<String>);
+
+ is_equal(S(None), expect![[r#""""#]]);
+ is_equal(S(Some("Hello".to_string())), expect![[r#""Hello""#]]);
+}
+
+#[test]
+fn test_bytes_or_string() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "BytesOrString")] Vec<u8>);
+
+ is_equal(
+ S(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#]],
+ );
+ check_deserialization(S(vec![72, 101, 108, 108, 111]), r#""Hello""#);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SVec(#[serde_as(as = "Vec<BytesOrString>")] Vec<Vec<u8>>);
+
+ is_equal(
+ SVec(vec![vec![1, 2, 3]]),
+ expect![[r#"
+ [
+ [
+ 1,
+ 2,
+ 3
+ ]
+ ]"#]],
+ );
+ check_deserialization(
+ SVec(vec![
+ vec![72, 101, 108, 108, 111],
+ vec![87, 111, 114, 108, 100],
+ vec![1, 2, 3],
+ ]),
+ r#"["Hello","World",[1,2,3]]"#,
+ );
+}
+
+#[test]
+fn string_with_separator() {
+ use serde_with::{rust::StringWithSeparator, CommaSeparator, SpaceSeparator};
+
+ #[serde_as]
+ #[derive(Deserialize, Serialize)]
+ struct A {
+ #[serde_as(as = "StringWithSeparator::<SpaceSeparator, String>")]
+ tags: Vec<String>,
+ #[serde_as(as = "StringWithSeparator::<CommaSeparator, String>")]
+ // more_tags: Vec<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: Default::default(),
+ };
+ assert_eq!(
+ r#"{"tags":"1 2 3","more_tags":""}"#,
+ serde_json::to_string(&x).unwrap()
+ );
+}
+
+#[test]
+fn test_vec_skip_error() {
+ use serde_with::VecSkipError;
+
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S {
+ tag: String,
+ #[serde_as(as = "VecSkipError<_>")]
+ values: Vec<u8>,
+ }
+
+ check_deserialization(
+ S {
+ tag: "type".into(),
+ values: vec![0, 1],
+ },
+ r#"{"tag":"type","values":[0, "str", 1, [10, 11], -2, {}, 300]}"#,
+ );
+ is_equal(
+ S {
+ tag: "round-trip".into(),
+ values: vec![0, 255],
+ },
+ expect![[r#"
+ {
+ "tag": "round-trip",
+ "values": [
+ 0,
+ 255
+ ]
+ }"#]],
+ );
+}
+
+#[test]
+fn test_serialize_reference() {
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S1<'a>(#[serde_as(as = "Vec<DisplayFromStr>")] &'a Vec<u32>);
+ check_serialization(
+ S1(&vec![1, 2]),
+ expect![[r#"
+ [
+ "1",
+ "2"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S1a<'a>(#[serde_as(as = "&Vec<DisplayFromStr>")] &'a Vec<u32>);
+ check_serialization(
+ S1(&vec![1, 2]),
+ expect![[r#"
+ [
+ "1",
+ "2"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S1Mut<'a>(#[serde_as(as = "Vec<DisplayFromStr>")] &'a mut Vec<u32>);
+ check_serialization(
+ S1(&vec![1, 2]),
+ expect![[r#"
+ [
+ "1",
+ "2"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S1aMut<'a>(#[serde_as(as = "&mut Vec<DisplayFromStr>")] &'a mut Vec<u32>);
+ check_serialization(
+ S1(&vec![1, 2]),
+ expect![[r#"
+ [
+ "1",
+ "2"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S2<'a>(#[serde_as(as = "&[DisplayFromStr]")] &'a [u32]);
+ check_serialization(
+ S2(&[1, 2]),
+ expect![[r#"
+ [
+ "1",
+ "2"
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S3<'a>(
+ #[serde_as(as = "&BTreeMap<DisplayFromStr, DisplayFromStr>")] &'a BTreeMap<bool, u32>,
+ );
+ let bmap = vec![(false, 123), (true, 456)].into_iter().collect();
+ check_serialization(
+ S3(&bmap),
+ expect![[r#"
+ {
+ "false": "123",
+ "true": "456"
+ }"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S4<'a>(#[serde_as(as = "&Vec<(_, DisplayFromStr)>")] &'a BTreeMap<bool, u32>);
+ let bmap = vec![(false, 123), (true, 456)].into_iter().collect();
+ check_serialization(
+ S4(&bmap),
+ expect![[r#"
+ [
+ [
+ false,
+ "123"
+ ],
+ [
+ true,
+ "456"
+ ]
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize)]
+ struct S5<'a>(
+ #[serde_as(as = "&BTreeMap<DisplayFromStr, &Vec<(_, _)>>")]
+ &'a Vec<(u32, &'a BTreeMap<bool, String>)>,
+ );
+ let bmap0 = vec![(false, "123".to_string()), (true, "456".to_string())]
+ .into_iter()
+ .collect();
+ let bmap1 = vec![(true, "Hello".to_string()), (false, "World".to_string())]
+ .into_iter()
+ .collect();
+ let vec = vec![(111, &bmap0), (999, &bmap1)];
+ check_serialization(
+ S5(&vec),
+ expect![[r#"
+ {
+ "111": [
+ [
+ false,
+ "123"
+ ],
+ [
+ true,
+ "456"
+ ]
+ ],
+ "999": [
+ [
+ false,
+ "World"
+ ],
+ [
+ true,
+ "Hello"
+ ]
+ ]
+ }"#]],
+ );
+}
+
+#[test]
+fn test_big_arrays() {
+ // Single Big Array
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct S1(#[serde_as(as = "[_; 64]")] [u8; 64]);
+ is_equal_compact(
+ S1([0; 64]),
+ expect![[
+ r#"[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]"#
+ ]],
+ );
+ // Too few entries
+ check_error_deserialization::<S1>(
+ r#"[0,0,0,0,0,0,0,0,0,0,0,0,0,0]"#,
+ expect![[r#"invalid length 14, expected an array of size 64 at line 1 column 29"#]],
+ );
+ // Too many entries
+ check_error_deserialization::<S1>(
+ r#"[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]"#,
+ expect![[r#"trailing characters at line 1 column 130"#]],
+ );
+
+ // Single Big Array
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct S2(#[serde_as(as = "[DisplayFromStr; 40]")] [u8; 40]);
+ is_equal_compact(
+ S2([0; 40]),
+ expect![[
+ r#"["0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"]"#
+ ]],
+ );
+
+ // Nested Big Arrays
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct S3(#[serde_as(as = "[[_; 34]; 33]")] [[u8; 34]; 33]);
+ is_equal_compact(
+ S3([[0; 34]; 33]),
+ expect![[
+ r#"[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]"#
+ ]],
+ );
+}
+
+#[test]
+fn test_bytes() {
+ // The test case is copied from
+ // https://github.com/serde-rs/bytes/blob/cbae606b9dc225fc094b031cc84eac9493da2058/tests/test_derive.rs
+ // Original code by @dtolnay
+
+ use alloc::borrow::Cow;
+ use serde_test::{assert_de_tokens, assert_tokens, Token};
+ use serde_with::Bytes;
+
+ #[serde_as]
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Test<'a> {
+ #[serde_as(as = "Bytes")]
+ array: [u8; 52],
+
+ #[serde_as(as = "Bytes")]
+ slice: &'a [u8],
+
+ #[serde_as(as = "Bytes")]
+ vec: Vec<u8>,
+
+ #[serde_as(as = "Bytes")]
+ cow_slice: Cow<'a, [u8]>,
+
+ #[serde_as(as = "Box<Bytes>")]
+ boxed_array: Box<[u8; 52]>,
+
+ #[serde_as(as = "Bytes")]
+ boxed_array2: Box<[u8; 52]>,
+
+ #[serde_as(as = "Bytes")]
+ boxed_slice: Box<[u8]>,
+
+ #[serde_as(as = "Option<Bytes>")]
+ opt_slice: Option<&'a [u8]>,
+
+ #[serde_as(as = "Option<Bytes>")]
+ opt_vec: Option<Vec<u8>>,
+
+ #[serde_as(as = "Option<Bytes>")]
+ opt_cow_slice: Option<Cow<'a, [u8]>>,
+ }
+
+ let test = Test {
+ array: *b"ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz",
+ slice: b"...",
+ vec: b"...".to_vec(),
+ cow_slice: Cow::Borrowed(b"..."),
+ boxed_array: Box::new(*b"ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ boxed_array2: Box::new(*b"ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ boxed_slice: b"...".to_vec().into_boxed_slice(),
+ opt_slice: Some(b"..."),
+ opt_vec: Some(b"...".to_vec()),
+ opt_cow_slice: Some(Cow::Borrowed(b"...")),
+ };
+
+ assert_tokens(
+ &test,
+ &[
+ Token::Struct {
+ name: "Test",
+ len: 10,
+ },
+ Token::Str("array"),
+ Token::BorrowedBytes(b"ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ Token::Str("slice"),
+ Token::BorrowedBytes(b"..."),
+ Token::Str("vec"),
+ Token::Bytes(b"..."),
+ Token::Str("cow_slice"),
+ Token::BorrowedBytes(b"..."),
+ Token::Str("boxed_array"),
+ Token::BorrowedBytes(b"ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ Token::Str("boxed_array2"),
+ Token::BorrowedBytes(b"ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ Token::Str("boxed_slice"),
+ Token::Bytes(b"..."),
+ Token::Str("opt_slice"),
+ Token::Some,
+ Token::BorrowedBytes(b"..."),
+ Token::Str("opt_vec"),
+ Token::Some,
+ Token::Bytes(b"..."),
+ Token::Str("opt_cow_slice"),
+ Token::Some,
+ Token::BorrowedBytes(b"..."),
+ Token::StructEnd,
+ ],
+ );
+
+ // Test string deserialization
+ assert_de_tokens(
+ &test,
+ &[
+ Token::Struct {
+ name: "Test",
+ len: 10,
+ },
+ Token::Str("array"),
+ Token::BorrowedStr("ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ Token::Str("slice"),
+ Token::BorrowedStr("..."),
+ Token::Str("vec"),
+ Token::Bytes(b"..."),
+ Token::Str("cow_slice"),
+ Token::BorrowedStr("..."),
+ Token::Str("boxed_array"),
+ Token::BorrowedStr("ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ Token::Str("boxed_array2"),
+ Token::BorrowedStr("ABCDEFGHIJKLMNOPQRSTUVWXZYabcdefghijklmnopqrstuvwxyz"),
+ Token::Str("boxed_slice"),
+ Token::Bytes(b"..."),
+ Token::Str("opt_slice"),
+ Token::Some,
+ Token::BorrowedStr("..."),
+ Token::Str("opt_vec"),
+ Token::Some,
+ Token::Bytes(b"..."),
+ Token::Str("opt_cow_slice"),
+ Token::Some,
+ Token::BorrowedStr("..."),
+ Token::StructEnd,
+ ],
+ );
+}
+
+#[test]
+fn test_one_or_many_prefer_one() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S1Vec(#[serde_as(as = "OneOrMany<_>")] Vec<u32>);
+
+ // Normal
+ is_equal(S1Vec(vec![]), expect![[r#"[]"#]]);
+ is_equal(S1Vec(vec![1]), expect![[r#"1"#]]);
+ is_equal(
+ S1Vec(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#]],
+ );
+ check_deserialization(S1Vec(vec![1]), r#"1"#);
+ check_deserialization(S1Vec(vec![1]), r#"[1]"#);
+ check_error_deserialization::<S1Vec>(r#"{}"#, expect![[r#"a list or single element"#]]);
+ check_error_deserialization::<S1Vec>(r#""xx""#, expect![[r#"a list or single element"#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2Vec(#[serde_as(as = "OneOrMany<DisplayFromStr>")] Vec<u32>);
+
+ // Normal
+ is_equal(S2Vec(vec![]), expect![[r#"[]"#]]);
+ is_equal(S2Vec(vec![1]), expect![[r#""1""#]]);
+ is_equal(
+ S2Vec(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#]],
+ );
+ check_deserialization(S2Vec(vec![1]), r#""1""#);
+ check_deserialization(S2Vec(vec![1]), r#"["1"]"#);
+ check_error_deserialization::<S2Vec>(r#"{}"#, expect![[r#"a list or single element"#]]);
+ check_error_deserialization::<S2Vec>(r#""xx""#, expect![[r#"a list or single element"#]]);
+}
+
+#[test]
+fn test_one_or_many_prefer_many() {
+ use serde_with::formats::PreferMany;
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S1Vec(#[serde_as(as = "OneOrMany<_, PreferMany>")] Vec<u32>);
+
+ // Normal
+ is_equal(S1Vec(vec![]), expect![[r#"[]"#]]);
+ is_equal(
+ S1Vec(vec![1]),
+ expect![[r#"
+ [
+ 1
+ ]"#]],
+ );
+ is_equal(
+ S1Vec(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#]],
+ );
+ check_deserialization(S1Vec(vec![1]), r#"1"#);
+ check_deserialization(S1Vec(vec![1]), r#"[1]"#);
+ check_error_deserialization::<S1Vec>(r#"{}"#, expect![[r#"a list or single element"#]]);
+ check_error_deserialization::<S1Vec>(r#""xx""#, expect![[r#"a list or single element"#]]);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2Vec(#[serde_as(as = "OneOrMany<DisplayFromStr, PreferMany>")] Vec<u32>);
+
+ // Normal
+ is_equal(S2Vec(vec![]), expect![[r#"[]"#]]);
+ is_equal(
+ S2Vec(vec![1]),
+ expect![[r#"
+ [
+ "1"
+ ]"#]],
+ );
+ is_equal(
+ S2Vec(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#]],
+ );
+ check_deserialization(S2Vec(vec![1]), r#""1""#);
+ check_deserialization(S2Vec(vec![1]), r#"["1"]"#);
+ check_error_deserialization::<S2Vec>(r#"{}"#, expect![[r#"a list or single element"#]]);
+ check_error_deserialization::<S2Vec>(r#""xx""#, expect![[r#"a list or single element"#]]);
+}
+
+/// Test that Cow borrows from the input
+#[test]
+fn test_borrow_cow_str() {
+ use alloc::borrow::Cow;
+ use serde_test::{assert_ser_tokens, Token};
+ use serde_with::BorrowCow;
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S1<'a> {
+ #[serde_as(as = "BorrowCow")]
+ cow: Cow<'a, str>,
+ #[serde_as(as = "Option<BorrowCow>")]
+ opt: Option<Cow<'a, str>>,
+ #[serde_as(as = "Box<BorrowCow>")]
+ b: Box<Cow<'a, str>>,
+ #[serde_as(as = "[BorrowCow; 1]")]
+ arr: [Cow<'a, str>; 1],
+ }
+
+ assert_ser_tokens(
+ &S1 {
+ cow: "abc".into(),
+ opt: Some("foo".into()),
+ b: Box::new("bar".into()),
+ arr: ["def".into()],
+ },
+ &[
+ Token::Struct { name: "S1", len: 4 },
+ Token::Str("cow"),
+ Token::BorrowedStr("abc"),
+ Token::Str("opt"),
+ Token::Some,
+ Token::BorrowedStr("foo"),
+ Token::Str("b"),
+ Token::BorrowedStr("bar"),
+ Token::Str("arr"),
+ Token::Tuple { len: 1 },
+ Token::BorrowedStr("def"),
+ Token::TupleEnd,
+ Token::StructEnd,
+ ],
+ );
+ let s1: S1<'_> = serde_json::from_str(
+ r#"{
+ "cow": "abc",
+ "opt": "foo",
+ "b": "bar",
+ "arr": ["def"]
+ }"#,
+ )
+ .unwrap();
+ assert!(matches!(s1.cow, Cow::Borrowed(_)));
+ assert!(matches!(s1.opt, Some(Cow::Borrowed(_))));
+ assert!(matches!(*s1.b, Cow::Borrowed(_)));
+ assert!(matches!(s1.arr, [Cow::Borrowed(_)]));
+ let s1: S1<'_> = serde_json::from_str(
+ r#"{
+ "cow": "a\"c",
+ "opt": "f\"o",
+ "b": "b\"r",
+ "arr": ["d\"f"]
+ }"#,
+ )
+ .unwrap();
+ assert!(matches!(s1.cow, Cow::Owned(_)));
+ assert!(matches!(s1.opt, Some(Cow::Owned(_))));
+ assert!(matches!(*s1.b, Cow::Owned(_)));
+ assert!(matches!(s1.arr, [Cow::Owned(_)]));
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2<'a> {
+ #[serde_as(as = "BorrowCow")]
+ cow: Cow<'a, [u8]>,
+ #[serde_as(as = "Option<BorrowCow>")]
+ opt: Option<Cow<'a, [u8]>>,
+ }
+
+ assert_ser_tokens(
+ &S2 {
+ cow: b"abc"[..].into(),
+ opt: Some(b"foo"[..].into()),
+ },
+ &[
+ Token::Struct { name: "S2", len: 2 },
+ Token::Str("cow"),
+ Token::Seq { len: Some(3) },
+ Token::U8(b'a'),
+ Token::U8(b'b'),
+ Token::U8(b'c'),
+ Token::SeqEnd,
+ Token::Str("opt"),
+ Token::Some,
+ Token::Seq { len: Some(3) },
+ Token::U8(b'f'),
+ Token::U8(b'o'),
+ Token::U8(b'o'),
+ Token::SeqEnd,
+ Token::StructEnd,
+ ],
+ );
+ let tokens = &[
+ Token::Struct { name: "S2", len: 2 },
+ Token::Str("cow"),
+ Token::BorrowedBytes(b"abc"),
+ Token::Str("opt"),
+ Token::Some,
+ Token::BorrowedBytes(b"foo"),
+ Token::StructEnd,
+ ];
+ let mut deser = serde_test::Deserializer::new(tokens);
+ let s2 = S2::deserialize(&mut deser).unwrap();
+ assert!(matches!(s2.cow, Cow::Borrowed(_)));
+ assert!(matches!(s2.opt, Some(Cow::Borrowed(_))));
+
+ // Check that a manual borrow works too
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S3<'a>(
+ #[serde(borrow = "'a")]
+ #[serde_as(as = "BorrowCow")]
+ Cow<'a, [u8]>,
+ // TODO add a test for Cow<'b, [u8; N]>
+ // #[serde_as(as = "BorrowCow")]
+ // Cow<'b, [u8; N]>,
+ );
+ let tokens = &[
+ Token::NewtypeStruct { name: "S3" },
+ Token::BorrowedBytes(b"abc"),
+ ];
+
+ let mut deser = serde_test::Deserializer::new(tokens);
+ let s3 = S3::deserialize(&mut deser).unwrap();
+ assert!(matches!(s3.0, Cow::Borrowed(_)));
+}
+
+#[test]
+fn test_boolfromint() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "BoolFromInt")] bool);
+
+ is_equal(S(false), expect![[r#"0"#]]);
+ is_equal(S(true), expect![[r#"1"#]]);
+ check_error_deserialization::<S>(
+ "2",
+ expect![[r#"invalid value: integer `2`, expected 0 or 1 at line 1 column 1"#]],
+ );
+ check_error_deserialization::<S>(
+ "-100",
+ expect![[r#"invalid value: integer `-100`, expected 0 or 1 at line 1 column 4"#]],
+ );
+ check_error_deserialization::<S>(
+ "18446744073709551615",
+ expect![[
+ r#"invalid value: integer `18446744073709551615`, expected 0 or 1 at line 1 column 20"#
+ ]],
+ );
+ check_error_deserialization::<S>(
+ r#""""#,
+ expect![[r#"invalid type: string "", expected an integer 0 or 1 at line 1 column 2"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SStrict(#[serde_as(as = "BoolFromInt<Strict>")] bool);
+
+ is_equal(SStrict(false), expect![[r#"0"#]]);
+ is_equal(SStrict(true), expect![[r#"1"#]]);
+ check_error_deserialization::<SStrict>(
+ "2",
+ expect![[r#"invalid value: integer `2`, expected 0 or 1 at line 1 column 1"#]],
+ );
+ check_error_deserialization::<SStrict>(
+ "-100",
+ expect![[r#"invalid value: integer `-100`, expected 0 or 1 at line 1 column 4"#]],
+ );
+ check_error_deserialization::<SStrict>(
+ "18446744073709551615",
+ expect![[
+ r#"invalid value: integer `18446744073709551615`, expected 0 or 1 at line 1 column 20"#
+ ]],
+ );
+ check_error_deserialization::<SStrict>(
+ r#""""#,
+ expect![[r#"invalid type: string "", expected an integer 0 or 1 at line 1 column 2"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SFlexible(#[serde_as(as = "BoolFromInt<Flexible>")] bool);
+
+ is_equal(SFlexible(false), expect![[r#"0"#]]);
+ is_equal(SFlexible(true), expect![[r#"1"#]]);
+ check_deserialization::<SFlexible>(SFlexible(true), "2");
+ check_deserialization::<SFlexible>(SFlexible(true), "-100");
+ check_deserialization::<SFlexible>(SFlexible(true), "18446744073709551615");
+ check_error_deserialization::<SFlexible>(
+ r#""""#,
+ expect![[r#"invalid type: string "", expected an integer at line 1 column 2"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/map_tuple_list.rs b/third_party/rust/serde_with/tests/serde_as/map_tuple_list.rs
new file mode 100644
index 0000000000..332dcf676e
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/map_tuple_list.rs
@@ -0,0 +1,272 @@
+use super::*;
+use std::net::IpAddr;
+
+#[test]
+fn test_map_as_tuple_list() {
+ let ip = "1.2.3.4".parse().unwrap();
+ let ip2 = "255.255.255.255".parse().unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SB(#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr)>")] BTreeMap<u32, IpAddr>);
+
+ let map: BTreeMap<_, _> = vec![(1, ip), (10, ip), (200, ip2)].into_iter().collect();
+ is_equal(
+ SB(map.clone()),
+ expect![[r#"
+ [
+ [
+ "1",
+ "1.2.3.4"
+ ],
+ [
+ "10",
+ "1.2.3.4"
+ ],
+ [
+ "200",
+ "255.255.255.255"
+ ]
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SB2(#[serde_as(as = "Vec<(Same, DisplayFromStr)>")] BTreeMap<u32, IpAddr>);
+
+ is_equal(
+ SB2(map),
+ expect![[r#"
+ [
+ [
+ 1,
+ "1.2.3.4"
+ ],
+ [
+ 10,
+ "1.2.3.4"
+ ],
+ [
+ 200,
+ "255.255.255.255"
+ ]
+ ]"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SH(#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr)>")] HashMap<u32, IpAddr>);
+
+ // HashMap serialization tests with more than 1 entry are unreliable
+ let map1: HashMap<_, _> = vec![(200, ip2)].into_iter().collect();
+ let map: HashMap<_, _> = vec![(1, ip), (10, ip), (200, ip2)].into_iter().collect();
+ is_equal(
+ SH(map1.clone()),
+ expect![[r#"
+ [
+ [
+ "200",
+ "255.255.255.255"
+ ]
+ ]"#]],
+ );
+ check_deserialization(
+ SH(map.clone()),
+ r#"[["1","1.2.3.4"],["10","1.2.3.4"],["200","255.255.255.255"]]"#,
+ );
+ check_error_deserialization::<SH>(
+ r#"{"200":"255.255.255.255"}"#,
+ expect![[r#"invalid type: map, expected a sequence at line 1 column 0"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SH2(#[serde_as(as = "Vec<(Same, DisplayFromStr)>")] HashMap<u32, IpAddr>);
+
+ is_equal(
+ SH2(map1),
+ expect![[r#"
+ [
+ [
+ 200,
+ "255.255.255.255"
+ ]
+ ]"#]],
+ );
+ check_deserialization(
+ SH2(map),
+ r#"[[1,"1.2.3.4"],[10,"1.2.3.4"],[200,"255.255.255.255"]]"#,
+ );
+ check_error_deserialization::<SH2>(
+ r#"1"#,
+ expect![[r#"invalid type: integer `1`, expected a sequence at line 1 column 1"#]],
+ );
+}
+
+#[test]
+fn test_tuple_list_as_map() {
+ let ip = "1.2.3.4".parse().unwrap();
+ let ip2 = "255.255.255.255".parse().unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SH(#[serde_as(as = "HashMap<DisplayFromStr, DisplayFromStr>")] Vec<(u32, IpAddr)>);
+
+ is_equal(
+ SH(vec![(1, ip), (10, ip), (200, ip2)]),
+ expect![[r#"
+ {
+ "1": "1.2.3.4",
+ "10": "1.2.3.4",
+ "200": "255.255.255.255"
+ }"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SB(#[serde_as(as = "BTreeMap<DisplayFromStr, DisplayFromStr>")] Vec<(u32, IpAddr)>);
+
+ is_equal(
+ SB(vec![(1, ip), (10, ip), (200, ip2)]),
+ expect![[r#"
+ {
+ "1": "1.2.3.4",
+ "10": "1.2.3.4",
+ "200": "255.255.255.255"
+ }"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SD(#[serde_as(as = "BTreeMap<DisplayFromStr, DisplayFromStr>")] VecDeque<(u32, IpAddr)>);
+
+ is_equal(
+ SD(vec![(1, ip), (10, ip), (200, ip2)].into()),
+ expect![[r#"
+ {
+ "1": "1.2.3.4",
+ "10": "1.2.3.4",
+ "200": "255.255.255.255"
+ }"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Sll(
+ #[serde_as(as = "HashMap<DisplayFromStr, DisplayFromStr>")] LinkedList<(u32, IpAddr)>,
+ );
+
+ is_equal(
+ Sll(vec![(1, ip), (10, ip), (200, ip2)].into_iter().collect()),
+ expect![[r#"
+ {
+ "1": "1.2.3.4",
+ "10": "1.2.3.4",
+ "200": "255.255.255.255"
+ }"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct SO(#[serde_as(as = "HashMap<DisplayFromStr, DisplayFromStr>")] Option<(u32, IpAddr)>);
+
+ is_equal(
+ SO(Some((1, ip))),
+ expect![[r#"
+ {
+ "1": "1.2.3.4"
+ }"#]],
+ );
+ is_equal(SO(None), expect![[r#"{}"#]]);
+}
+
+#[test]
+fn test_tuple_array_as_map() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct S1(#[serde_as(as = "BTreeMap<_, _>")] [(u8, u8); 1]);
+ is_equal(
+ S1([(1, 2)]),
+ expect![[r#"
+ {
+ "1": 2
+ }"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct S2(#[serde_as(as = "HashMap<_, _>")] [(u8, u8); 33]);
+ is_equal(
+ S2([
+ (0, 0),
+ (1, 1),
+ (2, 2),
+ (3, 3),
+ (4, 4),
+ (5, 5),
+ (6, 6),
+ (7, 7),
+ (8, 8),
+ (9, 9),
+ (10, 10),
+ (11, 11),
+ (12, 12),
+ (13, 13),
+ (14, 14),
+ (15, 15),
+ (16, 16),
+ (17, 17),
+ (18, 18),
+ (19, 19),
+ (20, 20),
+ (21, 21),
+ (22, 22),
+ (23, 23),
+ (24, 24),
+ (25, 25),
+ (26, 26),
+ (27, 27),
+ (28, 28),
+ (29, 29),
+ (30, 30),
+ (31, 31),
+ (32, 32),
+ ]),
+ expect![[r#"
+ {
+ "0": 0,
+ "1": 1,
+ "2": 2,
+ "3": 3,
+ "4": 4,
+ "5": 5,
+ "6": 6,
+ "7": 7,
+ "8": 8,
+ "9": 9,
+ "10": 10,
+ "11": 11,
+ "12": 12,
+ "13": 13,
+ "14": 14,
+ "15": 15,
+ "16": 16,
+ "17": 17,
+ "18": 18,
+ "19": 19,
+ "20": 20,
+ "21": 21,
+ "22": 22,
+ "23": 23,
+ "24": 24,
+ "25": 25,
+ "26": 26,
+ "27": 27,
+ "28": 28,
+ "29": 29,
+ "30": 30,
+ "31": 31,
+ "32": 32
+ }"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/pickfirst.rs b/third_party/rust/serde_with/tests/serde_as/pickfirst.rs
new file mode 100644
index 0000000000..ed3cacb1dd
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/pickfirst.rs
@@ -0,0 +1,134 @@
+use super::*;
+use serde_with::{CommaSeparator, PickFirst, SpaceSeparator, StringWithSeparator};
+
+#[test]
+fn test_pick_first_two() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "PickFirst<(_, DisplayFromStr)>")] u32);
+
+ is_equal(S(123), expect![[r#"123"#]]);
+ check_deserialization(S(123), r#""123""#);
+ check_error_deserialization::<S>(
+ r#""Abc""#,
+ expect![[r#"PickFirst could not deserialize data"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2(#[serde_as(as = "PickFirst<(DisplayFromStr, _)>")] u32);
+
+ is_equal(S2(123), expect![[r#""123""#]]);
+ check_deserialization(S2(123), r#"123"#);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S3(
+ #[serde_as(as = "PickFirst<(_, StringWithSeparator::<SpaceSeparator, String>,)>")]
+ Vec<String>,
+ );
+ is_equal(
+ S3(vec!["A".to_string(), "B".to_string(), "C".to_string()]),
+ expect![[r#"
+ [
+ "A",
+ "B",
+ "C"
+ ]"#]],
+ );
+ check_deserialization(
+ S3(vec!["A".to_string(), "B".to_string(), "C".to_string()]),
+ r#""A B C""#,
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S4(
+ #[serde_as(as = "PickFirst<(StringWithSeparator::<CommaSeparator, String>, _,)>")]
+ Vec<String>,
+ );
+ is_equal(
+ S4(vec!["A".to_string(), "B".to_string(), "C".to_string()]),
+ expect![[r#""A,B,C""#]],
+ );
+ check_deserialization(
+ S4(vec!["A".to_string(), "B".to_string(), "C".to_string()]),
+ r#"["A", "B", "C"]"#,
+ );
+}
+
+#[test]
+fn test_pick_first_three() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(
+ #[serde_as(
+ as = "PickFirst<(_, Vec<DisplayFromStr>, StringWithSeparator::<CommaSeparator, u32>)>"
+ )]
+ Vec<u32>,
+ );
+ is_equal(
+ S(vec![1, 2, 3]),
+ expect![[r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#]],
+ );
+ check_deserialization(
+ S(vec![1, 2, 3]),
+ r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#,
+ );
+ check_deserialization(S(vec![1, 2, 3]), r#""1,2,3""#);
+ check_error_deserialization::<S>(
+ r#""Abc""#,
+ expect![[r#"PickFirst could not deserialize data"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S2(
+ #[serde_as(
+ as = "PickFirst<(StringWithSeparator::<CommaSeparator, u32>, _, Vec<DisplayFromStr>)>"
+ )]
+ Vec<u32>,
+ );
+ is_equal(S2(vec![1, 2, 3]), expect![[r#""1,2,3""#]]);
+ check_deserialization(
+ S2(vec![1, 2, 3]),
+ r#"
+ [
+ "1",
+ "2",
+ "3"
+ ]"#,
+ );
+ check_deserialization(
+ S2(vec![1, 2, 3]),
+ r#"
+ [
+ 1,
+ 2,
+ 3
+ ]"#,
+ );
+}
+
+#[test]
+fn test_pick_first_four() {
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = "PickFirst<(_, _, _, _)>")] u32);
+
+ is_equal(S(123), expect![[r#"123"#]]);
+ check_error_deserialization::<S>(
+ r#""Abc""#,
+ expect![[r#"PickFirst could not deserialize data"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/serde_as_macro.rs b/third_party/rust/serde_with/tests/serde_as/serde_as_macro.rs
new file mode 100644
index 0000000000..b180079d46
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/serde_as_macro.rs
@@ -0,0 +1,191 @@
+use super::*;
+
+/// Test that the [`serde_as`] macro can replace the `_` type and the resulting code compiles.
+#[test]
+fn test_serde_as_macro_replace_infer_type() {
+ #[serde_as]
+ #[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
+ struct Data {
+ #[serde_as(as = "_")]
+ a: u32,
+ #[serde_as(as = "std::vec::Vec<_>")]
+ b: Vec<u32>,
+ #[serde_as(as = "Vec<(_, _)>")]
+ c: Vec<(u32, String)>,
+ #[serde_as(as = "[_; 2]")]
+ d: [u32; 2],
+ #[serde_as(as = "Box<[_]>")]
+ e: Box<[u32]>,
+ }
+
+ is_equal(
+ Data {
+ a: 10,
+ b: vec![20, 33],
+ c: vec![(40, "Hello".into()), (55, "World".into()), (60, "!".into())],
+ d: [70, 88],
+ e: vec![99, 100, 110].into_boxed_slice(),
+ },
+ expect![[r#"
+ {
+ "a": 10,
+ "b": [
+ 20,
+ 33
+ ],
+ "c": [
+ [
+ 40,
+ "Hello"
+ ],
+ [
+ 55,
+ "World"
+ ],
+ [
+ 60,
+ "!"
+ ]
+ ],
+ "d": [
+ 70,
+ 88
+ ],
+ "e": [
+ 99,
+ 100,
+ 110
+ ]
+ }"#]],
+ );
+}
+
+/// Test that the [`serde_as`] macro supports `deserialize_as`
+#[test]
+fn test_serde_as_macro_deserialize() {
+ #[serde_as]
+ #[derive(Debug, Eq, PartialEq, Deserialize)]
+ struct Data {
+ #[serde_as(deserialize_as = "DisplayFromStr")]
+ a: u32,
+ #[serde_as(deserialize_as = "Vec<DisplayFromStr>")]
+ b: Vec<u32>,
+ #[serde_as(deserialize_as = "(DisplayFromStr, _)")]
+ c: (u32, u32),
+ }
+
+ check_deserialization(
+ Data {
+ a: 10,
+ b: vec![20, 33],
+ c: (40, 55),
+ },
+ r##"{
+ "a": "10",
+ "b": [
+ "20",
+ "33"
+ ],
+ "c": [
+ "40",
+ 55
+ ]
+}"##,
+ );
+}
+
+/// Test that the [`serde_as`] macro supports `serialize_as`
+#[test]
+fn test_serde_as_macro_serialize() {
+ #[serde_as]
+ #[derive(Debug, Eq, PartialEq, Serialize)]
+ struct Data {
+ #[serde_as(serialize_as = "DisplayFromStr")]
+ a: u32,
+ #[serde_as(serialize_as = "Vec<DisplayFromStr>")]
+ b: Vec<u32>,
+ #[serde_as(serialize_as = "(DisplayFromStr, _)")]
+ c: (u32, u32),
+ }
+
+ check_serialization(
+ Data {
+ a: 10,
+ b: vec![20, 33],
+ c: (40, 55),
+ },
+ expect![[r#"
+ {
+ "a": "10",
+ "b": [
+ "20",
+ "33"
+ ],
+ "c": [
+ "40",
+ 55
+ ]
+ }"#]],
+ );
+}
+
+/// Test that the [`serde_as`] macro supports `serialize_as` and `deserialize_as`
+#[test]
+fn test_serde_as_macro_serialize_deserialize() {
+ #[serde_as]
+ #[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
+ struct Data {
+ #[serde_as(serialize_as = "DisplayFromStr", deserialize_as = "DisplayFromStr")]
+ a: u32,
+ #[serde_as(
+ serialize_as = "Vec<DisplayFromStr>",
+ deserialize_as = "Vec<DisplayFromStr>"
+ )]
+ b: Vec<u32>,
+ #[serde_as(
+ serialize_as = "(DisplayFromStr, _)",
+ deserialize_as = "(DisplayFromStr, _)"
+ )]
+ c: (u32, u32),
+ }
+
+ is_equal(
+ Data {
+ a: 10,
+ b: vec![20, 33],
+ c: (40, 55),
+ },
+ expect![[r#"
+ {
+ "a": "10",
+ "b": [
+ "20",
+ "33"
+ ],
+ "c": [
+ "40",
+ 55
+ ]
+ }"#]],
+ );
+}
+
+/// Test that the [`serde_as`] macro works correctly if applied multiple times to a field
+#[test]
+fn test_serde_as_macro_multiple_field_attributes() {
+ #[serde_as]
+ #[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
+ struct Data {
+ #[serde_as(serialize_as = "DisplayFromStr")]
+ #[serde_as(deserialize_as = "DisplayFromStr")]
+ a: u32,
+ }
+
+ is_equal(
+ Data { a: 10 },
+ expect![[r#"
+ {
+ "a": "10"
+ }"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/serde_conv.rs b/third_party/rust/serde_with/tests/serde_as/serde_conv.rs
new file mode 100644
index 0000000000..1e510f72a3
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/serde_conv.rs
@@ -0,0 +1,52 @@
+use super::*;
+use serde_with::serde_conv;
+
+#[test]
+fn test_bool_as_string() {
+ serde_conv!(BoolAsString, bool, |x: &bool| x.to_string(), |x: String| x
+ .parse());
+
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct SWith(#[serde(with = "BoolAsString")] bool);
+
+ is_equal(SWith(false), expect![[r#""false""#]]);
+ is_equal(SWith(true), expect![[r#""true""#]]);
+ check_error_deserialization::<SWith>(
+ "123",
+ expect![[r#"invalid type: integer `123`, expected a string at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct SAs(#[serde_as(as = "BoolAsString")] bool);
+
+ is_equal(SAs(false), expect![[r#""false""#]]);
+ is_equal(SAs(true), expect![[r#""true""#]]);
+ check_error_deserialization::<SAs>(
+ "123",
+ expect![[r#"invalid type: integer `123`, expected a string at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct SAsVec(#[serde_as(as = "Vec<BoolAsString>")] Vec<bool>);
+
+ is_equal(
+ SAsVec(vec![false]),
+ expect![[r#"
+ [
+ "false"
+ ]"#]],
+ );
+ is_equal(
+ SAsVec(vec![true]),
+ expect![[r#"
+ [
+ "true"
+ ]"#]],
+ );
+ check_error_deserialization::<SAsVec>(
+ "123",
+ expect![[r#"invalid type: integer `123`, expected a sequence at line 1 column 3"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/serde_as/time.rs b/third_party/rust/serde_with/tests/serde_as/time.rs
new file mode 100644
index 0000000000..91808b4d8c
--- /dev/null
+++ b/third_party/rust/serde_with/tests/serde_as/time.rs
@@ -0,0 +1,521 @@
+use super::*;
+use core::time::Duration;
+use serde_with::{
+ DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds,
+ DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac,
+ DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds, TimestampMicroSecondsWithFrac,
+ TimestampMilliSeconds, TimestampMilliSecondsWithFrac, TimestampNanoSeconds,
+ TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac,
+};
+use std::time::SystemTime;
+
+#[test]
+fn test_duration_seconds() {
+ let zero = Duration::new(0, 0);
+ let one_second = Duration::new(1, 0);
+ let half_second = Duration::new(0, 500_000_000);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct IntStrict(#[serde_as(as = "DurationSeconds")] Duration);
+
+ is_equal(IntStrict(zero), expect![[r#"0"#]]);
+ is_equal(IntStrict(one_second), expect![[r#"1"#]]);
+ check_serialization(IntStrict(half_second), expect![[r#"1"#]]);
+ check_error_deserialization::<IntStrict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected u64 at line 1 column 3"#]],
+ );
+ check_error_deserialization::<IntStrict>(
+ r#"-1"#,
+ expect![[r#"invalid value: integer `-1`, expected u64 at line 1 column 2"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct IntFlexible(#[serde_as(as = "DurationSeconds<u64, Flexible>")] Duration);
+
+ is_equal(IntFlexible(zero), expect![[r#"0"#]]);
+ is_equal(IntFlexible(one_second), expect![[r#"1"#]]);
+ check_serialization(IntFlexible(half_second), expect![[r#"1"#]]);
+ check_deserialization(IntFlexible(half_second), r#""0.5""#);
+ check_deserialization(IntFlexible(one_second), r#""1""#);
+ check_deserialization(IntFlexible(zero), r#""0""#);
+ check_error_deserialization::<IntFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+ check_error_deserialization::<IntFlexible>(
+ r#"-1"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct F64Strict(#[serde_as(as = "DurationSeconds<f64>")] Duration);
+
+ is_equal(F64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(F64Strict(one_second), expect![[r#"1.0"#]]);
+ check_serialization(F64Strict(half_second), expect![[r#"1.0"#]]);
+ check_deserialization(F64Strict(one_second), r#"0.5"#);
+ check_error_deserialization::<F64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+ check_error_deserialization::<F64Strict>(
+ r#"-1.0"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct F64Flexible(#[serde_as(as = "DurationSeconds<f64, Flexible>")] Duration);
+
+ is_equal(F64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(F64Flexible(one_second), expect![[r#"1.0"#]]);
+ check_serialization(F64Flexible(half_second), expect![[r#"1.0"#]]);
+ check_deserialization(F64Flexible(half_second), r#""0.5""#);
+ check_deserialization(F64Flexible(one_second), r#""1""#);
+ check_deserialization(F64Flexible(zero), r#""0""#);
+ check_error_deserialization::<F64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+ check_error_deserialization::<F64Flexible>(
+ r#"-1"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StringStrict(#[serde_as(as = "DurationSeconds<String>")] Duration);
+
+ is_equal(StringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StringStrict(one_second), expect![[r#""1""#]]);
+ check_serialization(StringStrict(half_second), expect![[r#""1""#]]);
+ check_error_deserialization::<StringStrict>(
+ r#"1"#,
+ expect![[
+ r#"invalid type: integer `1`, expected a string containing a number at line 1 column 1"#
+ ]],
+ );
+ check_error_deserialization::<StringStrict>(
+ r#"-1"#,
+ expect![[
+ r#"invalid type: integer `-1`, expected a string containing a number at line 1 column 2"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StringFlexible(#[serde_as(as = "DurationSeconds<String, Flexible>")] Duration);
+
+ is_equal(StringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StringFlexible(one_second), expect![[r#""1""#]]);
+ check_serialization(StringFlexible(half_second), expect![[r#""1""#]]);
+ check_deserialization(StringFlexible(half_second), r#""0.5""#);
+ check_deserialization(StringFlexible(one_second), r#""1""#);
+ check_deserialization(StringFlexible(zero), r#""0""#);
+ check_error_deserialization::<StringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+ check_error_deserialization::<StringFlexible>(
+ r#"-1"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+}
+
+#[test]
+fn test_duration_seconds_with_frac() {
+ let zero = Duration::new(0, 0);
+ let one_second = Duration::new(1, 0);
+ let half_second = Duration::new(0, 500_000_000);
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct F64Strict(#[serde_as(as = "DurationSecondsWithFrac<f64>")] Duration);
+
+ is_equal(F64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(F64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(F64Strict(half_second), expect![[r#"0.5"#]]);
+ check_error_deserialization::<F64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+ check_error_deserialization::<F64Strict>(
+ r#"-1.0"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct F64Flexible(#[serde_as(as = "DurationSecondsWithFrac<f64, Flexible>")] Duration);
+
+ is_equal(F64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(F64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(F64Flexible(half_second), expect![[r#"0.5"#]]);
+ check_deserialization(F64Flexible(one_second), r#""1""#);
+ check_deserialization(F64Flexible(zero), r#""0""#);
+ check_error_deserialization::<F64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+ check_error_deserialization::<F64Flexible>(
+ r#"-1"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StringStrict(#[serde_as(as = "DurationSecondsWithFrac<String>")] Duration);
+
+ is_equal(StringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StringStrict(half_second), expect![[r#""0.5""#]]);
+ check_error_deserialization::<StringStrict>(
+ r#"1"#,
+ expect![[r#"invalid type: integer `1`, expected a string at line 1 column 1"#]],
+ );
+ check_error_deserialization::<StringStrict>(
+ r#"-1"#,
+ expect![[r#"invalid type: integer `-1`, expected a string at line 1 column 2"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StringFlexible(#[serde_as(as = "DurationSecondsWithFrac<String, Flexible>")] Duration);
+
+ is_equal(StringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StringFlexible(half_second), expect![[r#""0.5""#]]);
+ check_deserialization(StringFlexible(zero), r#""0""#);
+ check_error_deserialization::<StringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+ check_error_deserialization::<StringFlexible>(
+ r#"-1"#,
+ expect![[r#"std::time::Duration cannot be negative"#]],
+ );
+}
+
+#[test]
+fn test_timestamp_seconds_systemtime() {
+ let zero = SystemTime::UNIX_EPOCH;
+ let one_second = SystemTime::UNIX_EPOCH
+ .checked_add(Duration::new(1, 0))
+ .unwrap();
+ let half_second = SystemTime::UNIX_EPOCH
+ .checked_add(Duration::new(0, 500_000_000))
+ .unwrap();
+ let minus_one_second = SystemTime::UNIX_EPOCH
+ .checked_sub(Duration::new(1, 0))
+ .unwrap();
+ let minus_half_second = SystemTime::UNIX_EPOCH
+ .checked_sub(Duration::new(0, 500_000_000))
+ .unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructIntStrict(#[serde_as(as = "TimestampSeconds")] SystemTime);
+
+ is_equal(StructIntStrict(zero), expect![[r#"0"#]]);
+ is_equal(StructIntStrict(one_second), expect![[r#"1"#]]);
+ is_equal(StructIntStrict(minus_one_second), expect![[r#"-1"#]]);
+ check_serialization(StructIntStrict(half_second), expect![[r#"1"#]]);
+ check_serialization(StructIntStrict(minus_half_second), expect![[r#"-1"#]]);
+ check_error_deserialization::<StructIntStrict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected i64 at line 1 column 3"#]],
+ );
+ check_error_deserialization::<StructIntStrict>(
+ r#"0.123"#,
+ expect![[r#"invalid type: floating point `0.123`, expected i64 at line 1 column 5"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructIntFlexible(#[serde_as(as = "TimestampSeconds<i64, Flexible>")] SystemTime);
+
+ is_equal(StructIntFlexible(zero), expect![[r#"0"#]]);
+ is_equal(StructIntFlexible(one_second), expect![[r#"1"#]]);
+ is_equal(StructIntFlexible(minus_one_second), expect![[r#"-1"#]]);
+ check_serialization(StructIntFlexible(half_second), expect![[r#"1"#]]);
+ check_serialization(StructIntFlexible(minus_half_second), expect![[r#"-1"#]]);
+ check_deserialization(StructIntFlexible(one_second), r#""1""#);
+ check_deserialization(StructIntFlexible(one_second), r#"1.0"#);
+ check_deserialization(StructIntFlexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(StructIntFlexible(half_second), r#"0.5"#);
+ check_error_deserialization::<StructIntFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Strict(#[serde_as(as = "TimestampSeconds<f64>")] SystemTime);
+
+ is_equal(Structf64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Strict(minus_one_second), expect![[r#"-1.0"#]]);
+ check_serialization(Structf64Strict(half_second), expect![[r#"1.0"#]]);
+ check_serialization(Structf64Strict(minus_half_second), expect![[r#"-1.0"#]]);
+ check_deserialization(Structf64Strict(one_second), r#"0.5"#);
+ check_error_deserialization::<Structf64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Flexible(#[serde_as(as = "TimestampSeconds<f64, Flexible>")] SystemTime);
+
+ is_equal(Structf64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Flexible(minus_one_second), expect![[r#"-1.0"#]]);
+ check_serialization(Structf64Flexible(half_second), expect![[r#"1.0"#]]);
+ check_serialization(Structf64Flexible(minus_half_second), expect![[r#"-1.0"#]]);
+ check_deserialization(Structf64Flexible(one_second), r#""1""#);
+ check_deserialization(Structf64Flexible(one_second), r#"1.0"#);
+ check_deserialization(Structf64Flexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(Structf64Flexible(half_second), r#"0.5"#);
+ check_error_deserialization::<Structf64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringStrict(#[serde_as(as = "TimestampSeconds<String>")] SystemTime);
+
+ is_equal(StructStringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StructStringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringStrict(minus_one_second), expect![[r#""-1""#]]);
+ check_serialization(StructStringStrict(half_second), expect![[r#""1""#]]);
+ check_serialization(StructStringStrict(minus_half_second), expect![[r#""-1""#]]);
+ check_deserialization(StructStringStrict(one_second), r#""1""#);
+ check_error_deserialization::<StructStringStrict>(
+ r#""0.5""#,
+ expect![[r#"invalid digit found in string at line 1 column 5"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#""-0.5""#,
+ expect![[r#"invalid digit found in string at line 1 column 6"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"1"#,
+ expect![[
+ r#"invalid type: integer `1`, expected a string containing a number at line 1 column 1"#
+ ]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"0.0"#,
+ expect![[
+ r#"invalid type: floating point `0`, expected a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringFlexible(#[serde_as(as = "TimestampSeconds<String, Flexible>")] SystemTime);
+
+ is_equal(StructStringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StructStringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringFlexible(minus_one_second), expect![[r#""-1""#]]);
+ check_serialization(StructStringFlexible(half_second), expect![[r#""1""#]]);
+ check_serialization(
+ StructStringFlexible(minus_half_second),
+ expect![[r#""-1""#]],
+ );
+ check_deserialization(StructStringFlexible(one_second), r#"1"#);
+ check_deserialization(StructStringFlexible(one_second), r#"1.0"#);
+ check_deserialization(StructStringFlexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(StructStringFlexible(half_second), r#"0.5"#);
+ check_error_deserialization::<StructStringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+}
+
+#[test]
+fn test_timestamp_seconds_with_frac_systemtime() {
+ let zero = SystemTime::UNIX_EPOCH;
+ let one_second = SystemTime::UNIX_EPOCH
+ .checked_add(Duration::new(1, 0))
+ .unwrap();
+ let half_second = SystemTime::UNIX_EPOCH
+ .checked_add(Duration::new(0, 500_000_000))
+ .unwrap();
+ let minus_one_second = SystemTime::UNIX_EPOCH
+ .checked_sub(Duration::new(1, 0))
+ .unwrap();
+ let minus_half_second = SystemTime::UNIX_EPOCH
+ .checked_sub(Duration::new(0, 500_000_000))
+ .unwrap();
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Strict(#[serde_as(as = "TimestampSecondsWithFrac<f64>")] SystemTime);
+
+ is_equal(Structf64Strict(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Strict(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Strict(minus_one_second), expect![[r#"-1.0"#]]);
+ is_equal(Structf64Strict(half_second), expect![[r#"0.5"#]]);
+ is_equal(Structf64Strict(minus_half_second), expect![[r#"-0.5"#]]);
+ check_error_deserialization::<Structf64Strict>(
+ r#""1""#,
+ expect![[r#"invalid type: string "1", expected f64 at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct Structf64Flexible(
+ #[serde_as(as = "TimestampSecondsWithFrac<f64, Flexible>")] SystemTime,
+ );
+
+ is_equal(Structf64Flexible(zero), expect![[r#"0.0"#]]);
+ is_equal(Structf64Flexible(one_second), expect![[r#"1.0"#]]);
+ is_equal(Structf64Flexible(minus_one_second), expect![[r#"-1.0"#]]);
+ is_equal(Structf64Flexible(half_second), expect![[r#"0.5"#]]);
+ is_equal(Structf64Flexible(minus_half_second), expect![[r#"-0.5"#]]);
+ check_deserialization(Structf64Flexible(one_second), r#""1""#);
+ check_deserialization(Structf64Flexible(one_second), r#"1.0"#);
+ check_deserialization(Structf64Flexible(minus_half_second), r#""-0.5""#);
+ check_deserialization(Structf64Flexible(half_second), r#"0.5"#);
+ check_error_deserialization::<Structf64Flexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringStrict(#[serde_as(as = "TimestampSecondsWithFrac<String>")] SystemTime);
+
+ is_equal(StructStringStrict(zero), expect![[r#""0""#]]);
+ is_equal(StructStringStrict(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringStrict(minus_one_second), expect![[r#""-1""#]]);
+ is_equal(StructStringStrict(half_second), expect![[r#""0.5""#]]);
+ is_equal(
+ StructStringStrict(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"1"#,
+ expect![[r#"invalid type: integer `1`, expected a string at line 1 column 1"#]],
+ );
+ check_error_deserialization::<StructStringStrict>(
+ r#"0.0"#,
+ expect![[r#"invalid type: floating point `0`, expected a string at line 1 column 3"#]],
+ );
+
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct StructStringFlexible(
+ #[serde_as(as = "TimestampSecondsWithFrac<String, Flexible>")] SystemTime,
+ );
+
+ is_equal(StructStringFlexible(zero), expect![[r#""0""#]]);
+ is_equal(StructStringFlexible(one_second), expect![[r#""1""#]]);
+ is_equal(StructStringFlexible(minus_one_second), expect![[r#""-1""#]]);
+ is_equal(StructStringFlexible(half_second), expect![[r#""0.5""#]]);
+ is_equal(
+ StructStringFlexible(minus_half_second),
+ expect![[r#""-0.5""#]],
+ );
+ check_deserialization(StructStringFlexible(one_second), r#"1"#);
+ check_deserialization(StructStringFlexible(one_second), r#"1.0"#);
+ check_deserialization(StructStringFlexible(half_second), r#"0.5"#);
+ check_error_deserialization::<StructStringFlexible>(
+ r#""a""#,
+ expect![[
+ r#"invalid value: string "a", expected an integer, a float, or a string containing a number at line 1 column 3"#
+ ]],
+ );
+}
+
+macro_rules! smoketest {
+ ($($valuety:ty, $adapter:literal, $value:ident, $expect:tt;)*) => {
+ $({
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = $adapter)] $valuety);
+ #[allow(unused_braces)]
+ is_equal(S($value), $expect);
+ })*
+ };
+}
+
+#[test]
+fn test_duration_smoketest() {
+ let one_second = Duration::new(1, 0);
+
+ smoketest! {
+ Duration, "DurationSeconds<u64>", one_second, {expect![[r#"1"#]]};
+ Duration, "DurationSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ Duration, "DurationMilliSeconds<u64>", one_second, {expect![[r#"1000"#]]};
+ Duration, "DurationMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ Duration, "DurationMicroSeconds<u64>", one_second, {expect![[r#"1000000"#]]};
+ Duration, "DurationMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ Duration, "DurationNanoSeconds<u64>", one_second, {expect![[r#"1000000000"#]]};
+ Duration, "DurationNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ Duration, "DurationSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ Duration, "DurationSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ Duration, "DurationMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ Duration, "DurationMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ Duration, "DurationMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ Duration, "DurationMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ Duration, "DurationNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ Duration, "DurationNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+}
+
+#[test]
+fn test_timestamp_systemtime_smoketest() {
+ let one_second = SystemTime::UNIX_EPOCH
+ .checked_add(Duration::new(1, 0))
+ .unwrap();
+
+ smoketest! {
+ SystemTime, "TimestampSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ SystemTime, "TimestampSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ SystemTime, "TimestampMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ SystemTime, "TimestampMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ SystemTime, "TimestampMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ SystemTime, "TimestampMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ SystemTime, "TimestampNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ SystemTime, "TimestampNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ SystemTime, "TimestampSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ SystemTime, "TimestampSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ SystemTime, "TimestampMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ SystemTime, "TimestampMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ SystemTime, "TimestampMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ SystemTime, "TimestampMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ SystemTime, "TimestampNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ SystemTime, "TimestampNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+}
diff --git a/third_party/rust/serde_with/tests/time_0_3.rs b/third_party/rust/serde_with/tests/time_0_3.rs
new file mode 100644
index 0000000000..4c89dbd7d4
--- /dev/null
+++ b/third_party/rust/serde_with/tests/time_0_3.rs
@@ -0,0 +1,229 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+mod utils;
+
+use crate::utils::{check_deserialization, check_error_deserialization, is_equal};
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::{
+ serde_as, DurationMicroSeconds, DurationMicroSecondsWithFrac, DurationMilliSeconds,
+ DurationMilliSecondsWithFrac, DurationNanoSeconds, DurationNanoSecondsWithFrac,
+ DurationSeconds, DurationSecondsWithFrac, TimestampMicroSeconds, TimestampMicroSecondsWithFrac,
+ TimestampMilliSeconds, TimestampMilliSecondsWithFrac, TimestampNanoSeconds,
+ TimestampNanoSecondsWithFrac, TimestampSeconds, TimestampSecondsWithFrac,
+};
+use time_0_3::{Duration, OffsetDateTime, PrimitiveDateTime, UtcOffset};
+
+/// 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(),
+ )
+}
+
+macro_rules! smoketest {
+ ($($valuety:ty, $adapter:literal, $value:expr, $expect:tt;)*) => {
+ $({
+ #[serde_as]
+ #[derive(Debug, Serialize, Deserialize, PartialEq)]
+ struct S(#[serde_as(as = $adapter)] $valuety);
+ #[allow(unused_braces)]
+ is_equal(S($value), $expect);
+ })*
+ };
+}
+
+#[test]
+fn test_duration_smoketest() {
+ let zero = Duration::seconds(0);
+ let one_second = Duration::seconds(1);
+
+ smoketest! {
+ Duration, "DurationSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ Duration, "DurationSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ Duration, "DurationMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ Duration, "DurationMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ Duration, "DurationMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ Duration, "DurationMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ Duration, "DurationNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ Duration, "DurationNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ Duration, "DurationSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ Duration, "DurationSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ Duration, "DurationMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ Duration, "DurationMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ Duration, "DurationMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ Duration, "DurationMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ Duration, "DurationNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ Duration, "DurationNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ Duration, "DurationSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ Duration, "DurationSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ Duration, "DurationSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ Duration, "DurationSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ Duration, "DurationSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
+
+#[test]
+fn test_datetime_utc_smoketest() {
+ let zero = OffsetDateTime::UNIX_EPOCH;
+ let one_second = zero + Duration::seconds(1);
+
+ smoketest! {
+ OffsetDateTime, "TimestampSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ OffsetDateTime, "TimestampSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ OffsetDateTime, "TimestampMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ OffsetDateTime, "TimestampMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ OffsetDateTime, "TimestampMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ OffsetDateTime, "TimestampMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ OffsetDateTime, "TimestampNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ OffsetDateTime, "TimestampNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ OffsetDateTime, "TimestampSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ OffsetDateTime, "TimestampSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ OffsetDateTime, "TimestampMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ OffsetDateTime, "TimestampMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ OffsetDateTime, "TimestampMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ OffsetDateTime, "TimestampMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ OffsetDateTime, "TimestampNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ OffsetDateTime, "TimestampNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ OffsetDateTime, "TimestampSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ OffsetDateTime, "TimestampSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ OffsetDateTime, "TimestampSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ OffsetDateTime, "TimestampSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ OffsetDateTime, "TimestampSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
+
+#[test]
+fn test_naive_datetime_smoketest() {
+ let zero = unix_epoch_primitive();
+ let one_second = zero + Duration::seconds(1);
+
+ smoketest! {
+ PrimitiveDateTime, "TimestampSeconds<i64>", one_second, {expect![[r#"1"#]]};
+ PrimitiveDateTime, "TimestampSeconds<f64>", one_second, {expect![[r#"1.0"#]]};
+ PrimitiveDateTime, "TimestampMilliSeconds<i64>", one_second, {expect![[r#"1000"#]]};
+ PrimitiveDateTime, "TimestampMilliSeconds<f64>", one_second, {expect![[r#"1000.0"#]]};
+ PrimitiveDateTime, "TimestampMicroSeconds<i64>", one_second, {expect![[r#"1000000"#]]};
+ PrimitiveDateTime, "TimestampMicroSeconds<f64>", one_second, {expect![[r#"1000000.0"#]]};
+ PrimitiveDateTime, "TimestampNanoSeconds<i64>", one_second, {expect![[r#"1000000000"#]]};
+ PrimitiveDateTime, "TimestampNanoSeconds<f64>", one_second, {expect![[r#"1000000000.0"#]]};
+ };
+
+ smoketest! {
+ PrimitiveDateTime, "TimestampSecondsWithFrac", one_second, {expect![[r#"1.0"#]]};
+ PrimitiveDateTime, "TimestampSecondsWithFrac<String>", one_second, {expect![[r#""1""#]]};
+ PrimitiveDateTime, "TimestampMilliSecondsWithFrac", one_second, {expect![[r#"1000.0"#]]};
+ PrimitiveDateTime, "TimestampMilliSecondsWithFrac<String>", one_second, {expect![[r#""1000""#]]};
+ PrimitiveDateTime, "TimestampMicroSecondsWithFrac", one_second, {expect![[r#"1000000.0"#]]};
+ PrimitiveDateTime, "TimestampMicroSecondsWithFrac<String>", one_second, {expect![[r#""1000000""#]]};
+ PrimitiveDateTime, "TimestampNanoSecondsWithFrac", one_second, {expect![[r#"1000000000.0"#]]};
+ PrimitiveDateTime, "TimestampNanoSecondsWithFrac<String>", one_second, {expect![[r#""1000000000""#]]};
+ };
+
+ smoketest! {
+ PrimitiveDateTime, "TimestampSecondsWithFrac", zero, {expect![[r#"0.0"#]]};
+ PrimitiveDateTime, "TimestampSecondsWithFrac", zero + Duration::nanoseconds(500_000_000), {expect![[r#"0.5"#]]};
+ PrimitiveDateTime, "TimestampSecondsWithFrac", zero + Duration::seconds(1), {expect![[r#"1.0"#]]};
+ PrimitiveDateTime, "TimestampSecondsWithFrac", zero - Duration::nanoseconds(500_000_000), {expect![[r#"-0.5"#]]};
+ PrimitiveDateTime, "TimestampSecondsWithFrac", zero - Duration::seconds(1), {expect![[r#"-1.0"#]]};
+ };
+}
+
+#[test]
+fn test_offset_datetime_rfc2822() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde_as(as = "time_0_3::format_description::well_known::Rfc2822")] OffsetDateTime);
+
+ is_equal(
+ S(OffsetDateTime::UNIX_EPOCH),
+ expect![[r#""Thu, 01 Jan 1970 00:00:00 +0000""#]],
+ );
+
+ check_error_deserialization::<S>(
+ r#""Foobar""#,
+ expect![[r#"the 'weekday' component could not be parsed at line 1 column 8"#]],
+ );
+ check_error_deserialization::<S>(
+ r#""Fri, 2000""#,
+ expect![[r#"a character literal was not valid at line 1 column 11"#]],
+ );
+}
+
+#[test]
+fn test_offset_datetime_rfc3339() {
+ #[serde_as]
+ #[derive(Debug, PartialEq, Deserialize, Serialize)]
+ struct S(#[serde_as(as = "time_0_3::format_description::well_known::Rfc3339")] OffsetDateTime);
+
+ is_equal(
+ S(OffsetDateTime::UNIX_EPOCH),
+ expect![[r#""1970-01-01T00:00:00Z""#]],
+ );
+ check_deserialization::<S>(
+ S(
+ OffsetDateTime::from_unix_timestamp_nanos(482_196_050_520_000_000)
+ .unwrap()
+ .to_offset(UtcOffset::from_hms(0, 0, 0).unwrap()),
+ ),
+ r#""1985-04-12T23:20:50.52Z""#,
+ );
+ check_deserialization::<S>(
+ S(OffsetDateTime::from_unix_timestamp(851_042_397)
+ .unwrap()
+ .to_offset(UtcOffset::from_hms(-8, 0, 0).unwrap())),
+ r#""1996-12-19T16:39:57-08:00""#,
+ );
+ check_deserialization::<S>(
+ S(
+ OffsetDateTime::from_unix_timestamp_nanos(662_687_999_999_999_999)
+ .unwrap()
+ .to_offset(UtcOffset::from_hms(0, 0, 0).unwrap()),
+ ),
+ r#""1990-12-31T23:59:60Z""#,
+ );
+ check_deserialization::<S>(
+ S(
+ OffsetDateTime::from_unix_timestamp_nanos(662_687_999_999_999_999)
+ .unwrap()
+ .to_offset(UtcOffset::from_hms(-8, 0, 0).unwrap()),
+ ),
+ r#""1990-12-31T15:59:60-08:00""#,
+ );
+ check_deserialization::<S>(
+ S(
+ OffsetDateTime::from_unix_timestamp_nanos(-1_041_337_172_130_000_000)
+ .unwrap()
+ .to_offset(UtcOffset::from_hms(0, 20, 0).unwrap()),
+ ),
+ r#""1937-01-01T12:00:27.87+00:20""#,
+ );
+
+ check_error_deserialization::<S>(
+ r#""Foobar""#,
+ expect![[r#"the 'year' component could not be parsed at line 1 column 8"#]],
+ );
+ check_error_deserialization::<S>(
+ r#""2000-AA""#,
+ expect![[r#"the 'month' component could not be parsed at line 1 column 9"#]],
+ );
+}
diff --git a/third_party/rust/serde_with/tests/utils.rs b/third_party/rust/serde_with/tests/utils.rs
new file mode 100644
index 0000000000..d9247ffff9
--- /dev/null
+++ b/third_party/rust/serde_with/tests/utils.rs
@@ -0,0 +1,79 @@
+#![allow(dead_code)]
+
+use core::fmt::Debug;
+use expect_test::Expect;
+use pretty_assertions::assert_eq;
+use serde::{de::DeserializeOwned, Serialize};
+
+#[track_caller]
+pub fn is_equal<T>(value: T, expected: Expect)
+where
+ T: Debug + DeserializeOwned + PartialEq + Serialize,
+{
+ let serialized = serde_json::to_string_pretty(&value).unwrap();
+ expected.assert_eq(&serialized);
+ assert_eq!(
+ value,
+ serde_json::from_str::<T>(&serialized).unwrap(),
+ "Deserialization differs from expected value."
+ );
+}
+
+/// Like [`is_equal`] but not pretty-print
+#[track_caller]
+pub fn is_equal_compact<T>(value: T, expected: Expect)
+where
+ T: Debug + DeserializeOwned + PartialEq + Serialize,
+{
+ let serialized = serde_json::to_string(&value).unwrap();
+ expected.assert_eq(&serialized);
+ assert_eq!(
+ value,
+ serde_json::from_str::<T>(&serialized).unwrap(),
+ "Deserialization differs from expected value."
+ );
+}
+
+#[track_caller]
+pub fn check_deserialization<T>(value: T, deserialize_from: &str)
+where
+ T: Debug + DeserializeOwned + PartialEq,
+{
+ assert_eq!(
+ value,
+ serde_json::from_str::<T>(deserialize_from).unwrap(),
+ "Deserialization differs from expected value."
+ );
+}
+
+#[track_caller]
+pub fn check_serialization<T>(value: T, serialize_to: Expect)
+where
+ T: Debug + Serialize,
+{
+ serialize_to.assert_eq(&serde_json::to_string_pretty(&value).unwrap());
+}
+
+#[track_caller]
+pub fn check_error_serialization<T>(value: T, error_msg: Expect)
+where
+ T: Debug + Serialize,
+{
+ error_msg.assert_eq(
+ &serde_json::to_string_pretty(&value)
+ .unwrap_err()
+ .to_string(),
+ );
+}
+
+#[track_caller]
+pub fn check_error_deserialization<T>(deserialize_from: &str, error_msg: Expect)
+where
+ T: Debug + DeserializeOwned,
+{
+ error_msg.assert_eq(
+ &serde_json::from_str::<T>(deserialize_from)
+ .unwrap_err()
+ .to_string(),
+ )
+}
diff --git a/third_party/rust/serde_with/tests/version_numbers.rs b/third_party/rust/serde_with/tests/version_numbers.rs
new file mode 100644
index 0000000000..5c478d91ed
--- /dev/null
+++ b/third_party/rust/serde_with/tests/version_numbers.rs
@@ -0,0 +1,80 @@
+// Needed to supress a 2021 incompatability warning in the macro generated code
+// The non_fmt_panic lint is not yet available on most Rust versions
+#![allow(unknown_lints, non_fmt_panics)]
+
+use version_sync::{
+ assert_contains_regex, assert_html_root_url_updated, assert_markdown_deps_updated,
+};
+
+#[test]
+fn test_readme_deps() {
+ assert_markdown_deps_updated!("README.md");
+}
+
+#[test]
+fn test_readme_deps_in_lib() {
+ assert_contains_regex!("src/lib.rs", r#"^//! version = "{version}""#);
+}
+
+#[test]
+fn test_changelog() {
+ assert_contains_regex!("CHANGELOG.md", r#"## \[{version}\]"#);
+}
+
+#[test]
+fn test_html_root_url() {
+ assert_html_root_url_updated!("src/lib.rs");
+}
+
+/// Check that all docs.rs links point to the current version
+///
+/// Parse all docs.rs links in `*.rs` and `*.md` files and check that they point to the current version.
+/// If a link should point to latest version this can be done by using `latest` in the version.
+/// The `*` version specifier is not allowed.
+///
+/// Arguably this should be part of version-sync. There is an open issue for this feature:
+/// https://github.com/mgeisler/version-sync/issues/72
+#[test]
+fn test_docs_rs_url_point_to_current_version() -> Result<(), Box<dyn std::error::Error>> {
+ let pkg_name = env!("CARGO_PKG_NAME");
+ let pkg_version = env!("CARGO_PKG_VERSION");
+
+ let re = regex::Regex::new(&format!(
+ "https?://docs.rs/{}/((\\d[^/]+|\\*|latest))/",
+ pkg_name
+ ))?;
+ let mut error = false;
+
+ for entry in glob::glob("**/*.rs")?.chain(glob::glob("**/README.md")?) {
+ let entry = entry?;
+ let content = std::fs::read_to_string(&entry)?;
+ for (line_number, line) in content.split('\n').enumerate() {
+ for capture in re.captures_iter(line) {
+ match capture
+ .get(1)
+ .expect("Will exist if regex matches")
+ .as_str()
+ {
+ "latest" => {}
+ version if version != pkg_version => {
+ error = true;
+ println!(
+ "{}:{} pkg_version is {} but found URL {}",
+ entry.display(),
+ line_number + 1,
+ pkg_version,
+ capture.get(0).expect("Group 0 always exists").as_str()
+ )
+ }
+ _ => {}
+ }
+ }
+ }
+ }
+
+ if error {
+ panic!("Found wrong URLs in file(s)");
+ } else {
+ Ok(())
+ }
+}
diff --git a/third_party/rust/serde_with/tests/with_prefix.rs b/third_party/rust/serde_with/tests/with_prefix.rs
new file mode 100644
index 0000000000..bc7a78711e
--- /dev/null
+++ b/third_party/rust/serde_with/tests/with_prefix.rs
@@ -0,0 +1,164 @@
+#![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/8867
+ clippy::derive_partial_eq_without_eq,
+)]
+
+extern crate alloc;
+
+mod utils;
+
+use crate::utils::is_equal;
+use alloc::collections::BTreeMap;
+use core::iter::FromIterator;
+use expect_test::expect;
+use serde::{Deserialize, Serialize};
+use serde_with::with_prefix;
+use std::collections::HashMap;
+
+#[test]
+fn test_flatten_with_prefix() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Match {
+ #[serde(flatten, with = "prefix_player1")]
+ player1: Player,
+ #[serde(flatten, with = "prefix_player2")]
+ player2: Option<Player>,
+ #[serde(flatten, with = "prefix_player3")]
+ player3: Option<Player>,
+ #[serde(flatten, with = "prefix_tag")]
+ tags: HashMap<String, String>,
+ }
+
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Player {
+ name: String,
+ votes: u64,
+ }
+
+ with_prefix!(prefix_player1 "player1_");
+ with_prefix!(prefix_player2 "player2_");
+ with_prefix!(prefix_player3 "player3_");
+ with_prefix!(prefix_tag "tag_");
+
+ let m = Match {
+ player1: Player {
+ name: "name1".to_owned(),
+ votes: 1,
+ },
+ player2: Some(Player {
+ name: "name2".to_owned(),
+ votes: 2,
+ }),
+ player3: None,
+ tags: HashMap::from_iter(vec![("t".to_owned(), "T".to_owned())]),
+ };
+
+ is_equal(
+ m,
+ expect![[r#"
+ {
+ "player1_name": "name1",
+ "player1_votes": 1,
+ "player2_name": "name2",
+ "player2_votes": 2,
+ "tag_t": "T"
+ }"#]],
+ );
+}
+
+#[test]
+fn test_plain_with_prefix() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Match {
+ #[serde(with = "prefix_player1")]
+ player1: Player,
+ #[serde(with = "prefix_player2")]
+ player2: Option<Player>,
+ #[serde(with = "prefix_player3")]
+ player3: Option<Player>,
+ #[serde(with = "prefix_tag")]
+ tags: HashMap<String, String>,
+ }
+
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Player {
+ name: String,
+ votes: u64,
+ }
+
+ with_prefix!(prefix_player1 "player1_");
+ with_prefix!(prefix_player2 "player2_");
+ with_prefix!(prefix_player3 "player3_");
+ with_prefix!(prefix_tag "tag_");
+
+ let m = Match {
+ player1: Player {
+ name: "name1".to_owned(),
+ votes: 1,
+ },
+ player2: Some(Player {
+ name: "name2".to_owned(),
+ votes: 2,
+ }),
+ player3: None,
+ tags: HashMap::from_iter(vec![("t".to_owned(), "T".to_owned())]),
+ };
+
+ is_equal(
+ m,
+ expect![[r#"
+ {
+ "player1": {
+ "player1_name": "name1",
+ "player1_votes": 1
+ },
+ "player2": {
+ "player2_name": "name2",
+ "player2_votes": 2
+ },
+ "player3": null,
+ "tags": {
+ "tag_t": "T"
+ }
+ }"#]],
+ );
+}
+
+/// Ensure that with_prefix works for unit type enum variants.
+#[test]
+fn test_enum_unit_variant_with_prefix() {
+ #[derive(Hash, PartialEq, Eq, Debug, Serialize, Deserialize, Ord, PartialOrd)]
+ enum Foo {
+ One,
+ Two,
+ Three,
+ }
+
+ #[derive(Hash, PartialEq, Eq, Debug, Serialize, Deserialize, Ord, PartialOrd)]
+ struct Data {
+ stuff: String,
+
+ #[serde(flatten, with = "foo")]
+ foo: BTreeMap<Foo, i32>,
+ }
+ with_prefix!(foo "foo_");
+
+ let d = Data {
+ stuff: "Stuff".to_owned(),
+ foo: BTreeMap::from_iter(vec![(Foo::One, 1), (Foo::Two, 2), (Foo::Three, 3)]),
+ };
+
+ is_equal(
+ d,
+ expect![[r#"
+ {
+ "stuff": "Stuff",
+ "foo_One": 1,
+ "foo_Two": 2,
+ "foo_Three": 3
+ }"#]],
+ );
+}