serde_json-1.0.45/Cargo.toml.orig010064400017500001750000000052741361216122500150530ustar0000000000000000[package] name = "serde_json" version = "1.0.45" # remember to update html_root_url authors = ["Erick Tryzelaar ", "David Tolnay "] license = "MIT OR Apache-2.0" description = "A JSON serialization file format" repository = "https://github.com/serde-rs/json" documentation = "http://docs.serde.rs/serde_json/" keywords = ["json", "serde", "serialization"] categories = ["encoding"] readme = "README.md" include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"] edition = "2018" [badges] travis-ci = { repository = "serde-rs/json" } appveyor = { repository = "serde-rs/json" } [dependencies] serde = { version = "1.0.60", default-features = false } indexmap = { version = "1.2", optional = true } itoa = { version = "0.4.3", default-features = false } ryu = "1.0" [dev-dependencies] automod = "0.1" rustversion = "1.0" serde_bytes = "0.11" serde_derive = "1.0" serde_stacker = "0.1" trybuild = { version = "1.0.19", features = ["diff"] } [workspace] members = ["tests/crate"] [package.metadata.docs.rs] features = ["raw_value", "unbounded_depth"] [package.metadata.playground] features = ["raw_value"] ### FEATURES ################################################################# [features] default = ["std"] std = ["serde/std"] # Provide integration for heap-allocated collections without depending on the # rest of the Rust standard library. # NOTE: Disabling both `std` *and* `alloc` features is not supported yet. # Available on Rust 1.36+. alloc = ["serde/alloc"] # Use a different representation for the map type of serde_json::Value. # This allows data to be read into a Value and written back to a JSON string # while preserving the order of map keys in the input. preserve_order = ["indexmap"] # Use an arbitrary precision number representation for serde_json::Number. This # allows JSON numbers of arbitrary size/precision to be read into a Number and # written back to a JSON string without loss of precision. arbitrary_precision = [] # Provide a RawValue type that can hold unprocessed JSON during deserialization. raw_value = [] # Provide a method disable_recursion_limit to parse arbitrarily deep JSON # structures without any consideration for overflowing the stack. When using # this feature, you will want to provide some other way to protect against stack # overflows, such as by wrapping your Deserializer in the dynamically growing # stack adapter provided by the serde_stacker crate. Additionally you will need # to be careful around other recursive operations on the parsed result which may # overflow the stack after deserialization has completed, including, but not # limited to, Display and Debug and Drop impls. unbounded_depth = [] serde_json-1.0.45/Cargo.toml0000644000000036471361216173500113710ustar00# 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 believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] edition = "2018" name = "serde_json" version = "1.0.45" authors = ["Erick Tryzelaar ", "David Tolnay "] include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"] description = "A JSON serialization file format" documentation = "http://docs.serde.rs/serde_json/" readme = "README.md" keywords = ["json", "serde", "serialization"] categories = ["encoding"] license = "MIT OR Apache-2.0" repository = "https://github.com/serde-rs/json" [package.metadata.docs.rs] features = ["raw_value", "unbounded_depth"] [package.metadata.playground] features = ["raw_value"] [dependencies.indexmap] version = "1.2" optional = true [dependencies.itoa] version = "0.4.3" default-features = false [dependencies.ryu] version = "1.0" [dependencies.serde] version = "1.0.60" default-features = false [dev-dependencies.automod] version = "0.1" [dev-dependencies.rustversion] version = "1.0" [dev-dependencies.serde_bytes] version = "0.11" [dev-dependencies.serde_derive] version = "1.0" [dev-dependencies.serde_stacker] version = "0.1" [dev-dependencies.trybuild] version = "1.0.19" features = ["diff"] [features] alloc = ["serde/alloc"] arbitrary_precision = [] default = ["std"] preserve_order = ["indexmap"] raw_value = [] std = ["serde/std"] unbounded_depth = [] [badges.appveyor] repository = "serde-rs/json" [badges.travis-ci] repository = "serde-rs/json" serde_json-1.0.45/LICENSE-APACHE010064400017500001750000000251371346021213300141040ustar0000000000000000 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. serde_json-1.0.45/LICENSE-MIT010064400017500001750000000017771346021213300136200ustar0000000000000000Permission 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. serde_json-1.0.45/README.md010064400017500001750000000310321361216101300134250ustar0000000000000000# Serde JSON   [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.31+]][rustc] [Build Status]: https://api.travis-ci.org/serde-rs/json.svg?branch=master [travis]: https://travis-ci.org/serde-rs/json [Latest Version]: https://img.shields.io/crates/v/serde_json.svg [crates.io]: https://crates.io/crates/serde\_json [Rustc Version 1.31+]: https://img.shields.io/badge/rustc-1.31+-lightgray.svg [rustc]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.** --- ```toml [dependencies] serde_json = "1.0" ``` You may be looking for: - [JSON API documentation](https://docs.serde.rs/serde_json/) - [Serde API documentation](https://docs.serde.rs/serde/) - [Detailed documentation about Serde](https://serde.rs/) - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html) - [Release notes](https://github.com/serde-rs/json/releases) JSON is a ubiquitous open-standard format that uses human-readable text to transmit data objects consisting of key-value pairs. ```json { "name": "John Doe", "age": 43, "address": { "street": "10 Downing Street", "city": "London" }, "phones": [ "+44 1234567", "+44 2345678" ] } ``` There are three common ways that you might find yourself needing to work with JSON data in Rust. - **As text data.** An unprocessed string of JSON data that you receive on an HTTP endpoint, read from a file, or prepare to send to a remote server. - **As an untyped or loosely typed representation.** Maybe you want to check that some JSON data is valid before passing it on, but without knowing the structure of what it contains. Or you want to do very basic manipulations like insert a key in a particular spot. - **As a strongly typed Rust data structure.** When you expect all or most of your data to conform to a particular structure and want to get real work done without JSON's loosey-goosey nature tripping you up. Serde JSON provides efficient, flexible, safe ways of converting data between each of these representations. ## Operating on untyped JSON values Any valid JSON data can be manipulated in the following recursive enum representation. This data structure is [`serde_json::Value`][value]. ```rust enum Value { Null, Bool(bool), Number(Number), String(String), Array(Vec), Object(Map), } ``` A string of JSON data can be parsed into a `serde_json::Value` by the [`serde_json::from_str`][from_str] function. There is also [`from_slice`][from_slice] for parsing from a byte slice &[u8] and [`from_reader`][from_reader] for parsing from any `io::Read` like a File or a TCP stream. ```rust use serde_json::{Result, Value}; fn untyped_example() -> Result<()> { // Some JSON input data as a &str. Maybe this comes from the user. let data = r#" { "name": "John Doe", "age": 43, "phones": [ "+44 1234567", "+44 2345678" ] }"#; // Parse the string of data into serde_json::Value. let v: Value = serde_json::from_str(data)?; // Access parts of the data by indexing with square brackets. println!("Please call {} at the number {}", v["name"], v["phones"][0]); Ok(()) } ``` The result of square bracket indexing like `v["name"]` is a borrow of the data at that index, so the type is `&Value`. A JSON map can be indexed with string keys, while a JSON array can be indexed with integer keys. If the type of the data is not right for the type with which it is being indexed, or if a map does not contain the key being indexed, or if the index into a vector is out of bounds, the returned element is `Value::Null`. When a `Value` is printed, it is printed as a JSON string. So in the code above, the output looks like `Please call "John Doe" at the number "+44 1234567"`. The quotation marks appear because `v["name"]` is a `&Value` containing a JSON string and its JSON representation is `"John Doe"`. Printing as a plain string without quotation marks involves converting from a JSON string to a Rust string with [`as_str()`] or avoiding the use of `Value` as described in the following section. [`as_str()`]: https://docs.serde.rs/serde_json/enum.Value.html#method.as_str The `Value` representation is sufficient for very basic tasks but can be tedious to work with for anything more significant. Error handling is verbose to implement correctly, for example imagine trying to detect the presence of unrecognized fields in the input data. The compiler is powerless to help you when you make a mistake, for example imagine typoing `v["name"]` as `v["nmae"]` in one of the dozens of places it is used in your code. ## Parsing JSON as strongly typed data structures Serde provides a powerful way of mapping JSON data into Rust data structures largely automatically. ```rust use serde::{Deserialize, Serialize}; use serde_json::Result; #[derive(Serialize, Deserialize)] struct Person { name: String, age: u8, phones: Vec, } fn typed_example() -> Result<()> { // Some JSON input data as a &str. Maybe this comes from the user. let data = r#" { "name": "John Doe", "age": 43, "phones": [ "+44 1234567", "+44 2345678" ] }"#; // Parse the string of data into a Person object. This is exactly the // same function as the one that produced serde_json::Value above, but // now we are asking it for a Person as output. let p: Person = serde_json::from_str(data)?; // Do things just like with any other Rust data structure. println!("Please call {} at the number {}", p.name, p.phones[0]); Ok(()) } ``` This is the same `serde_json::from_str` function as before, but this time we assign the return value to a variable of type `Person` so Serde will automatically interpret the input data as a `Person` and produce informative error messages if the layout does not conform to what a `Person` is expected to look like. Any type that implements Serde's `Deserialize` trait can be deserialized this way. This includes built-in Rust standard library types like `Vec` and `HashMap`, as well as any structs or enums annotated with `#[derive(Deserialize)]`. Once we have `p` of type `Person`, our IDE and the Rust compiler can help us use it correctly like they do for any other Rust code. The IDE can autocomplete field names to prevent typos, which was impossible in the `serde_json::Value` representation. And the Rust compiler can check that when we write `p.phones[0]`, then `p.phones` is guaranteed to be a `Vec` so indexing into it makes sense and produces a `String`. ## Constructing JSON values Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value` objects with very natural JSON syntax. ```rust use serde_json::json; fn main() { // The type of `john` is `serde_json::Value` let john = json!({ "name": "John Doe", "age": 43, "phones": [ "+44 1234567", "+44 2345678" ] }); println!("first phone number: {}", john["phones"][0]); // Convert to a string of JSON and print it out println!("{}", john.to_string()); } ``` The `Value::to_string()` function converts a `serde_json::Value` into a `String` of JSON text. One neat thing about the `json!` macro is that variables and expressions can be interpolated directly into the JSON value as you are building it. Serde will check at compile time that the value you are interpolating is able to be represented as JSON. ```rust let full_name = "John Doe"; let age_last_year = 42; // The type of `john` is `serde_json::Value` let john = json!({ "name": full_name, "age": age_last_year + 1, "phones": [ format!("+44 {}", random_phone()) ] }); ``` This is amazingly convenient but we have the problem we had before with `Value` which is that the IDE and Rust compiler cannot help us if we get it wrong. Serde JSON provides a better way of serializing strongly-typed data structures into JSON text. ## Creating JSON by serializing data structures A data structure can be converted to a JSON string by [`serde_json::to_string`][to_string]. There is also [`serde_json::to_vec`][to_vec] which serializes to a `Vec` and [`serde_json::to_writer`][to_writer] which serializes to any `io::Write` such as a File or a TCP stream. ```rust use serde::{Deserialize, Serialize}; use serde_json::Result; #[derive(Serialize, Deserialize)] struct Address { street: String, city: String, } fn print_an_address() -> Result<()> { // Some data structure. let address = Address { street: "10 Downing Street".to_owned(), city: "London".to_owned(), }; // Serialize it to a JSON string. let j = serde_json::to_string(&address)?; // Print, write to a file, or send to an HTTP server. println!("{}", j); Ok(()) } ``` Any type that implements Serde's `Serialize` trait can be serialized this way. This includes built-in Rust standard library types like `Vec` and `HashMap`, as well as any structs or enums annotated with `#[derive(Serialize)]`. ## Performance It is fast. You should expect in the ballpark of 500 to 1000 megabytes per second deserialization and 600 to 900 megabytes per second serialization, depending on the characteristics of your data. This is competitive with the fastest C and C++ JSON libraries or even 30% faster for many use cases. Benchmarks live in the [serde-rs/json-benchmark] repo. [serde-rs/json-benchmark]: https://github.com/serde-rs/json-benchmark ## Getting help Serde developers live in the #serde channel on [`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a good resource with generally faster response time but less specific knowledge about Serde. If IRC is not your thing, we are happy to respond to [GitHub issues](https://github.com/serde-rs/json/issues/new) as well. ## No-std support As long as there is a memory allocator, it is possible to use serde_json without the rest of the Rust standard library. This is supported on Rust 1.36+. Disable the default "std" feature and enable the "alloc" feature: ```toml [dependencies] serde_json = { version = "1.0", default-features = false, features = ["alloc"] } ``` For JSON support in Serde without a memory allocator, please see the [`serde-json-core`] crate. [`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_json_core/ [value]: https://docs.serde.rs/serde_json/value/enum.Value.html [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html [to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html [to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html [to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html [macro]: https://docs.serde.rs/serde_json/macro.json.html
#### License Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. serde_json-1.0.45/src/de.rs010064400017500001750000002234051361214356200137130ustar0000000000000000//! Deserialize JSON data to a Rust data structure. use crate::error::{Error, ErrorCode, Result}; use crate::lib::str::FromStr; use crate::lib::*; use crate::number::Number; use crate::read::{self, Reference}; use serde::de::{self, Expected, Unexpected}; use serde::{forward_to_deserialize_any, serde_if_integer128}; #[cfg(feature = "arbitrary_precision")] use crate::number::NumberDeserializer; pub use crate::read::{Read, SliceRead, StrRead}; #[cfg(feature = "std")] pub use crate::read::IoRead; ////////////////////////////////////////////////////////////////////////////// /// A structure that deserializes JSON into Rust values. pub struct Deserializer { read: R, scratch: Vec, remaining_depth: u8, #[cfg(feature = "unbounded_depth")] disable_recursion_limit: bool, } impl<'de, R> Deserializer where R: read::Read<'de>, { /// Create a JSON deserializer from one of the possible serde_json input /// sources. /// /// Typically it is more convenient to use one of these methods instead: /// /// - Deserializer::from_str /// - Deserializer::from_bytes /// - Deserializer::from_reader pub fn new(read: R) -> Self { #[cfg(not(feature = "unbounded_depth"))] { Deserializer { read: read, scratch: Vec::new(), remaining_depth: 128, } } #[cfg(feature = "unbounded_depth")] { Deserializer { read: read, scratch: Vec::new(), remaining_depth: 128, disable_recursion_limit: false, } } } } #[cfg(feature = "std")] impl Deserializer> where R: crate::io::Read, { /// Creates a JSON deserializer from an `io::Read`. /// /// Reader-based deserializers do not support deserializing borrowed types /// like `&str`, since the `std::io::Read` trait has no non-copying methods /// -- everything it does involves copying bytes out of the data source. pub fn from_reader(reader: R) -> Self { Deserializer::new(read::IoRead::new(reader)) } } impl<'a> Deserializer> { /// Creates a JSON deserializer from a `&[u8]`. pub fn from_slice(bytes: &'a [u8]) -> Self { Deserializer::new(read::SliceRead::new(bytes)) } } impl<'a> Deserializer> { /// Creates a JSON deserializer from a `&str`. pub fn from_str(s: &'a str) -> Self { Deserializer::new(read::StrRead::new(s)) } } macro_rules! overflow { ($a:ident * 10 + $b:ident, $c:expr) => { $a >= $c / 10 && ($a > $c / 10 || $b > $c % 10) }; } pub(crate) enum ParserNumber { F64(f64), U64(u64), I64(i64), #[cfg(feature = "arbitrary_precision")] String(String), } impl ParserNumber { fn visit<'de, V>(self, visitor: V) -> Result where V: de::Visitor<'de>, { match self { ParserNumber::F64(x) => visitor.visit_f64(x), ParserNumber::U64(x) => visitor.visit_u64(x), ParserNumber::I64(x) => visitor.visit_i64(x), #[cfg(feature = "arbitrary_precision")] ParserNumber::String(x) => visitor.visit_map(NumberDeserializer { number: x.into() }), } } fn invalid_type(self, exp: &dyn Expected) -> Error { match self { ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp), ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp), ParserNumber::I64(x) => de::Error::invalid_type(Unexpected::Signed(x), exp), #[cfg(feature = "arbitrary_precision")] ParserNumber::String(_) => de::Error::invalid_type(Unexpected::Other("number"), exp), } } } impl<'de, R: Read<'de>> Deserializer { /// The `Deserializer::end` method should be called after a value has been fully deserialized. /// This allows the `Deserializer` to validate that the input stream is at the end or that it /// only has trailing whitespace. pub fn end(&mut self) -> Result<()> { match tri!(self.parse_whitespace()) { Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)), None => Ok(()), } } /// Turn a JSON deserializer into an iterator over values of type T. pub fn into_iter(self) -> StreamDeserializer<'de, R, T> where T: de::Deserialize<'de>, { // This cannot be an implementation of std::iter::IntoIterator because // we need the caller to choose what T is. let offset = self.read.byte_offset(); StreamDeserializer { de: self, offset: offset, output: PhantomData, lifetime: PhantomData, } } /// Parse arbitrarily deep JSON structures without any consideration for /// overflowing the stack. /// /// You will want to provide some other way to protect against stack /// overflows, such as by wrapping your Deserializer in the dynamically /// growing stack adapter provided by the serde_stacker crate. Additionally /// you will need to be careful around other recursive operations on the /// parsed result which may overflow the stack after deserialization has /// completed, including, but not limited to, Display and Debug and Drop /// impls. /// /// *This method is only available if serde_json is built with the /// `"unbounded_depth"` feature.* /// /// # Examples /// /// ``` /// use serde::Deserialize; /// use serde_json::Value; /// /// fn main() { /// let mut json = String::new(); /// for _ in 0..10000 { /// json = format!("[{}]", json); /// } /// /// let mut deserializer = serde_json::Deserializer::from_str(&json); /// deserializer.disable_recursion_limit(); /// let deserializer = serde_stacker::Deserializer::new(&mut deserializer); /// let value = Value::deserialize(deserializer).unwrap(); /// /// carefully_drop_nested_arrays(value); /// } /// /// fn carefully_drop_nested_arrays(value: Value) { /// let mut stack = vec![value]; /// while let Some(value) = stack.pop() { /// if let Value::Array(array) = value { /// stack.extend(array); /// } /// } /// } /// ``` #[cfg(feature = "unbounded_depth")] pub fn disable_recursion_limit(&mut self) { self.disable_recursion_limit = true; } fn peek(&mut self) -> Result> { self.read.peek() } fn peek_or_null(&mut self) -> Result { Ok(tri!(self.peek()).unwrap_or(b'\x00')) } fn eat_char(&mut self) { self.read.discard(); } fn next_char(&mut self) -> Result> { self.read.next() } fn next_char_or_null(&mut self) -> Result { Ok(tri!(self.next_char()).unwrap_or(b'\x00')) } /// Error caused by a byte from next_char(). #[cold] fn error(&self, reason: ErrorCode) -> Error { let position = self.read.position(); Error::syntax(reason, position.line, position.column) } /// Error caused by a byte from peek(). #[cold] fn peek_error(&self, reason: ErrorCode) -> Error { let position = self.read.peek_position(); Error::syntax(reason, position.line, position.column) } /// Returns the first non-whitespace byte without consuming it, or `None` if /// EOF is encountered. fn parse_whitespace(&mut self) -> Result> { loop { match tri!(self.peek()) { Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => { self.eat_char(); } other => { return Ok(other); } } } } #[cold] fn peek_invalid_type(&mut self, exp: &dyn Expected) -> Error { let err = match self.peek_or_null().unwrap_or(b'\x00') { b'n' => { self.eat_char(); if let Err(err) = self.parse_ident(b"ull") { return err; } de::Error::invalid_type(Unexpected::Unit, exp) } b't' => { self.eat_char(); if let Err(err) = self.parse_ident(b"rue") { return err; } de::Error::invalid_type(Unexpected::Bool(true), exp) } b'f' => { self.eat_char(); if let Err(err) = self.parse_ident(b"alse") { return err; } de::Error::invalid_type(Unexpected::Bool(false), exp) } b'-' => { self.eat_char(); match self.parse_any_number(false) { Ok(n) => n.invalid_type(exp), Err(err) => return err, } } b'0'..=b'9' => match self.parse_any_number(true) { Ok(n) => n.invalid_type(exp), Err(err) => return err, }, b'"' => { self.eat_char(); self.scratch.clear(); match self.read.parse_str(&mut self.scratch) { Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp), Err(err) => return err, } } b'[' => de::Error::invalid_type(Unexpected::Seq, exp), b'{' => de::Error::invalid_type(Unexpected::Map, exp), _ => self.peek_error(ErrorCode::ExpectedSomeValue), }; self.fix_position(err) } fn deserialize_prim_number(&mut self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'-' => { self.eat_char(); tri!(self.parse_integer(false)).visit(visitor) } b'0'..=b'9' => tri!(self.parse_integer(true)).visit(visitor), _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } serde_if_integer128! { fn scan_integer128(&mut self, buf: &mut String) -> Result<()> { match tri!(self.next_char_or_null()) { b'0' => { buf.push('0'); // There can be only one leading '0'. match tri!(self.peek_or_null()) { b'0'..=b'9' => { Err(self.peek_error(ErrorCode::InvalidNumber)) } _ => Ok(()), } } c @ b'1'..=b'9' => { buf.push(c as char); while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); buf.push(c as char); } Ok(()) } _ => { Err(self.error(ErrorCode::InvalidNumber)) } } } } #[cold] fn fix_position(&self, err: Error) -> Error { err.fix_position(move |code| self.error(code)) } fn parse_ident(&mut self, ident: &[u8]) -> Result<()> { for expected in ident { match tri!(self.next_char()) { None => { return Err(self.error(ErrorCode::EofWhileParsingValue)); } Some(next) => { if next != *expected { return Err(self.error(ErrorCode::ExpectedSomeIdent)); } } } } Ok(()) } fn parse_integer(&mut self, positive: bool) -> Result { let next = match tri!(self.next_char()) { Some(b) => b, None => { return Err(self.error(ErrorCode::EofWhileParsingValue)); } }; match next { b'0' => { // There can be only one leading '0'. match tri!(self.peek_or_null()) { b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)), _ => self.parse_number(positive, 0), } } c @ b'1'..=b'9' => { let mut res = (c - b'0') as u64; loop { match tri!(self.peek_or_null()) { c @ b'0'..=b'9' => { self.eat_char(); let digit = (c - b'0') as u64; // We need to be careful with overflow. If we can, try to keep the // number as a `u64` until we grow too large. At that point, switch to // parsing the value as a `f64`. if overflow!(res * 10 + digit, u64::max_value()) { return Ok(ParserNumber::F64(tri!(self.parse_long_integer( positive, res, 1, // res * 10^1 )))); } res = res * 10 + digit; } _ => { return self.parse_number(positive, res); } } } } _ => Err(self.error(ErrorCode::InvalidNumber)), } } fn parse_long_integer( &mut self, positive: bool, significand: u64, mut exponent: i32, ) -> Result { loop { match tri!(self.peek_or_null()) { b'0'..=b'9' => { self.eat_char(); // This could overflow... if your integer is gigabytes long. // Ignore that possibility. exponent += 1; } b'.' => { return self.parse_decimal(positive, significand, exponent); } b'e' | b'E' => { return self.parse_exponent(positive, significand, exponent); } _ => { return self.f64_from_parts(positive, significand, exponent); } } } } fn parse_number(&mut self, positive: bool, significand: u64) -> Result { Ok(match tri!(self.peek_or_null()) { b'.' => ParserNumber::F64(tri!(self.parse_decimal(positive, significand, 0))), b'e' | b'E' => ParserNumber::F64(tri!(self.parse_exponent(positive, significand, 0))), _ => { if positive { ParserNumber::U64(significand) } else { let neg = (significand as i64).wrapping_neg(); // Convert into a float if we underflow. if neg > 0 { ParserNumber::F64(-(significand as f64)) } else { ParserNumber::I64(neg) } } } }) } fn parse_decimal( &mut self, positive: bool, mut significand: u64, mut exponent: i32, ) -> Result { self.eat_char(); let mut at_least_one_digit = false; while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); let digit = (c - b'0') as u64; at_least_one_digit = true; if overflow!(significand * 10 + digit, u64::max_value()) { // The next multiply/add would overflow, so just ignore all // further digits. while let b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); } break; } significand = significand * 10 + digit; exponent -= 1; } if !at_least_one_digit { match tri!(self.peek()) { Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)), None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)), } } match tri!(self.peek_or_null()) { b'e' | b'E' => self.parse_exponent(positive, significand, exponent), _ => self.f64_from_parts(positive, significand, exponent), } } fn parse_exponent( &mut self, positive: bool, significand: u64, starting_exp: i32, ) -> Result { self.eat_char(); let positive_exp = match tri!(self.peek_or_null()) { b'+' => { self.eat_char(); true } b'-' => { self.eat_char(); false } _ => true, }; let next = match tri!(self.next_char()) { Some(b) => b, None => { return Err(self.error(ErrorCode::EofWhileParsingValue)); } }; // Make sure a digit follows the exponent place. let mut exp = match next { c @ b'0'..=b'9' => (c - b'0') as i32, _ => { return Err(self.error(ErrorCode::InvalidNumber)); } }; while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); let digit = (c - b'0') as i32; if overflow!(exp * 10 + digit, i32::max_value()) { return self.parse_exponent_overflow(positive, significand, positive_exp); } exp = exp * 10 + digit; } let final_exp = if positive_exp { starting_exp.saturating_add(exp) } else { starting_exp.saturating_sub(exp) }; self.f64_from_parts(positive, significand, final_exp) } // This cold code should not be inlined into the middle of the hot // exponent-parsing loop above. #[cold] #[inline(never)] fn parse_exponent_overflow( &mut self, positive: bool, significand: u64, positive_exp: bool, ) -> Result { // Error instead of +/- infinity. if significand != 0 && positive_exp { return Err(self.error(ErrorCode::NumberOutOfRange)); } while let b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); } Ok(if positive { 0.0 } else { -0.0 }) } fn parse_any_signed_number(&mut self) -> Result { let peek = match tri!(self.peek()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'-' => { self.eat_char(); self.parse_any_number(false) } b'0'..=b'9' => self.parse_any_number(true), _ => Err(self.peek_error(ErrorCode::InvalidNumber)), }; let value = match tri!(self.peek()) { Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)), None => value, }; match value { Ok(value) => Ok(value), // The de::Error impl creates errors with unknown line and column. // Fill in the position here by looking at the current index in the // input. There is no way to tell whether this should call `error` // or `peek_error` so pick the one that seems correct more often. // Worst case, the position is off by one character. Err(err) => Err(self.fix_position(err)), } } #[cfg(not(feature = "arbitrary_precision"))] fn parse_any_number(&mut self, positive: bool) -> Result { self.parse_integer(positive) } #[cfg(feature = "arbitrary_precision")] fn parse_any_number(&mut self, positive: bool) -> Result { let mut buf = String::with_capacity(16); if !positive { buf.push('-'); } self.scan_integer(&mut buf)?; Ok(ParserNumber::String(buf)) } #[cfg(feature = "arbitrary_precision")] fn scan_or_eof(&mut self, buf: &mut String) -> Result { match tri!(self.next_char()) { Some(b) => { buf.push(b as char); Ok(b) } None => Err(self.error(ErrorCode::EofWhileParsingValue)), } } #[cfg(feature = "arbitrary_precision")] fn scan_integer(&mut self, buf: &mut String) -> Result<()> { match tri!(self.scan_or_eof(buf)) { b'0' => { // There can be only one leading '0'. match tri!(self.peek_or_null()) { b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)), _ => self.scan_number(buf), } } b'1'..=b'9' => loop { match tri!(self.peek_or_null()) { c @ b'0'..=b'9' => { self.eat_char(); buf.push(c as char); } _ => { return self.scan_number(buf); } } }, _ => Err(self.error(ErrorCode::InvalidNumber)), } } #[cfg(feature = "arbitrary_precision")] fn scan_number(&mut self, buf: &mut String) -> Result<()> { match tri!(self.peek_or_null()) { b'.' => self.scan_decimal(buf), b'e' | b'E' => self.scan_exponent(buf), _ => Ok(()), } } #[cfg(feature = "arbitrary_precision")] fn scan_decimal(&mut self, buf: &mut String) -> Result<()> { self.eat_char(); buf.push('.'); let mut at_least_one_digit = false; while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); buf.push(c as char); at_least_one_digit = true; } if !at_least_one_digit { match tri!(self.peek()) { Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)), None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)), } } match tri!(self.peek_or_null()) { b'e' | b'E' => self.scan_exponent(buf), _ => Ok(()), } } #[cfg(feature = "arbitrary_precision")] fn scan_exponent(&mut self, buf: &mut String) -> Result<()> { self.eat_char(); buf.push('e'); match tri!(self.peek_or_null()) { b'+' => { self.eat_char(); } b'-' => { self.eat_char(); buf.push('-'); } _ => {} } // Make sure a digit follows the exponent place. match tri!(self.scan_or_eof(buf)) { b'0'..=b'9' => {} _ => { return Err(self.error(ErrorCode::InvalidNumber)); } } while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); buf.push(c as char); } Ok(()) } fn f64_from_parts( &mut self, positive: bool, significand: u64, mut exponent: i32, ) -> Result { let mut f = significand as f64; loop { match POW10.get(exponent.wrapping_abs() as usize) { Some(&pow) => { if exponent >= 0 { f *= pow; if f.is_infinite() { return Err(self.error(ErrorCode::NumberOutOfRange)); } } else { f /= pow; } break; } None => { if f == 0.0 { break; } if exponent >= 0 { return Err(self.error(ErrorCode::NumberOutOfRange)); } f /= 1e308; exponent += 308; } } } Ok(if positive { f } else { -f }) } fn parse_object_colon(&mut self) -> Result<()> { match tri!(self.parse_whitespace()) { Some(b':') => { self.eat_char(); Ok(()) } Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)), None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)), } } fn end_seq(&mut self) -> Result<()> { match tri!(self.parse_whitespace()) { Some(b']') => { self.eat_char(); Ok(()) } Some(b',') => { self.eat_char(); match self.parse_whitespace() { Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)), _ => Err(self.peek_error(ErrorCode::TrailingCharacters)), } } Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)), None => Err(self.peek_error(ErrorCode::EofWhileParsingList)), } } fn end_map(&mut self) -> Result<()> { match tri!(self.parse_whitespace()) { Some(b'}') => { self.eat_char(); Ok(()) } Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)), Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)), None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)), } } fn ignore_value(&mut self) -> Result<()> { self.scratch.clear(); let mut enclosing = None; loop { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let frame = match peek { b'n' => { self.eat_char(); tri!(self.parse_ident(b"ull")); None } b't' => { self.eat_char(); tri!(self.parse_ident(b"rue")); None } b'f' => { self.eat_char(); tri!(self.parse_ident(b"alse")); None } b'-' => { self.eat_char(); tri!(self.ignore_integer()); None } b'0'..=b'9' => { tri!(self.ignore_integer()); None } b'"' => { self.eat_char(); tri!(self.read.ignore_str()); None } frame @ b'[' | frame @ b'{' => { self.scratch.extend(enclosing.take()); self.eat_char(); Some(frame) } _ => return Err(self.peek_error(ErrorCode::ExpectedSomeValue)), }; let (mut accept_comma, mut frame) = match frame { Some(frame) => (false, frame), None => match enclosing.take() { Some(frame) => (true, frame), None => match self.scratch.pop() { Some(frame) => (true, frame), None => return Ok(()), }, }, }; loop { match tri!(self.parse_whitespace()) { Some(b',') if accept_comma => { self.eat_char(); break; } Some(b']') if frame == b'[' => {} Some(b'}') if frame == b'{' => {} Some(_) => { if accept_comma { return Err(self.peek_error(match frame { b'[' => ErrorCode::ExpectedListCommaOrEnd, b'{' => ErrorCode::ExpectedObjectCommaOrEnd, _ => unreachable!(), })); } else { break; } } None => { return Err(self.peek_error(match frame { b'[' => ErrorCode::EofWhileParsingList, b'{' => ErrorCode::EofWhileParsingObject, _ => unreachable!(), })); } } self.eat_char(); frame = match self.scratch.pop() { Some(frame) => frame, None => return Ok(()), }; accept_comma = true; } if frame == b'{' { match tri!(self.parse_whitespace()) { Some(b'"') => self.eat_char(), Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)), None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)), } tri!(self.read.ignore_str()); match tri!(self.parse_whitespace()) { Some(b':') => self.eat_char(), Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)), None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)), } } enclosing = Some(frame); } } fn ignore_integer(&mut self) -> Result<()> { match tri!(self.next_char_or_null()) { b'0' => { // There can be only one leading '0'. if let b'0'..=b'9' = tri!(self.peek_or_null()) { return Err(self.peek_error(ErrorCode::InvalidNumber)); } } b'1'..=b'9' => { while let b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); } } _ => { return Err(self.error(ErrorCode::InvalidNumber)); } } match tri!(self.peek_or_null()) { b'.' => self.ignore_decimal(), b'e' | b'E' => self.ignore_exponent(), _ => Ok(()), } } fn ignore_decimal(&mut self) -> Result<()> { self.eat_char(); let mut at_least_one_digit = false; while let b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); at_least_one_digit = true; } if !at_least_one_digit { return Err(self.peek_error(ErrorCode::InvalidNumber)); } match tri!(self.peek_or_null()) { b'e' | b'E' => self.ignore_exponent(), _ => Ok(()), } } fn ignore_exponent(&mut self) -> Result<()> { self.eat_char(); match tri!(self.peek_or_null()) { b'+' | b'-' => self.eat_char(), _ => {} } // Make sure a digit follows the exponent place. match tri!(self.next_char_or_null()) { b'0'..=b'9' => {} _ => { return Err(self.error(ErrorCode::InvalidNumber)); } } while let b'0'..=b'9' = tri!(self.peek_or_null()) { self.eat_char(); } Ok(()) } #[cfg(feature = "raw_value")] fn deserialize_raw_value(&mut self, visitor: V) -> Result where V: de::Visitor<'de>, { self.parse_whitespace()?; self.read.begin_raw_buffering(); self.ignore_value()?; self.read.end_raw_buffering(visitor) } } impl FromStr for Number { type Err = Error; fn from_str(s: &str) -> result::Result { Deserializer::from_str(s) .parse_any_signed_number() .map(Into::into) } } static POW10: [f64; 309] = [ 1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, // 1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, // 1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029, // 1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039, // 1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049, // 1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059, // 1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069, // 1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079, // 1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089, // 1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099, // 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109, // 1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, // 1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, // 1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, // 1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, // 1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159, // 1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169, // 1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179, // 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189, // 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199, // 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209, // 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219, // 1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, // 1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, // 1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, // 1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, // 1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269, // 1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279, // 1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289, // 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299, // 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308, ]; macro_rules! deserialize_prim_number { ($method:ident) => { fn $method(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_prim_number(visitor) } } } #[cfg(not(feature = "unbounded_depth"))] macro_rules! if_checking_recursion_limit { ($($body:tt)*) => { $($body)* }; } #[cfg(feature = "unbounded_depth")] macro_rules! if_checking_recursion_limit { ($this:ident $($body:tt)*) => { if !$this.disable_recursion_limit { $this $($body)* } }; } macro_rules! check_recursion { ($this:ident $($body:tt)*) => { if_checking_recursion_limit! { $this.remaining_depth -= 1; if $this.remaining_depth == 0 { return Err($this.peek_error(ErrorCode::RecursionLimitExceeded)); } } $this $($body)* if_checking_recursion_limit! { $this.remaining_depth += 1; } }; } impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer { type Error = Error; #[inline] fn deserialize_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'n' => { self.eat_char(); tri!(self.parse_ident(b"ull")); visitor.visit_unit() } b't' => { self.eat_char(); tri!(self.parse_ident(b"rue")); visitor.visit_bool(true) } b'f' => { self.eat_char(); tri!(self.parse_ident(b"alse")); visitor.visit_bool(false) } b'-' => { self.eat_char(); tri!(self.parse_any_number(false)).visit(visitor) } b'0'..=b'9' => tri!(self.parse_any_number(true)).visit(visitor), b'"' => { self.eat_char(); self.scratch.clear(); match tri!(self.read.parse_str(&mut self.scratch)) { Reference::Borrowed(s) => visitor.visit_borrowed_str(s), Reference::Copied(s) => visitor.visit_str(s), } } b'[' => { check_recursion! { self.eat_char(); let ret = visitor.visit_seq(SeqAccess::new(self)); } match (ret, self.end_seq()) { (Ok(ret), Ok(())) => Ok(ret), (Err(err), _) | (_, Err(err)) => Err(err), } } b'{' => { check_recursion! { self.eat_char(); let ret = visitor.visit_map(MapAccess::new(self)); } match (ret, self.end_map()) { (Ok(ret), Ok(())) => Ok(ret), (Err(err), _) | (_, Err(err)) => Err(err), } } _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)), }; match value { Ok(value) => Ok(value), // The de::Error impl creates errors with unknown line and column. // Fill in the position here by looking at the current index in the // input. There is no way to tell whether this should call `error` // or `peek_error` so pick the one that seems correct more often. // Worst case, the position is off by one character. Err(err) => Err(self.fix_position(err)), } } fn deserialize_bool(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b't' => { self.eat_char(); tri!(self.parse_ident(b"rue")); visitor.visit_bool(true) } b'f' => { self.eat_char(); tri!(self.parse_ident(b"alse")); visitor.visit_bool(false) } _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } deserialize_prim_number!(deserialize_i8); deserialize_prim_number!(deserialize_i16); deserialize_prim_number!(deserialize_i32); deserialize_prim_number!(deserialize_i64); deserialize_prim_number!(deserialize_u8); deserialize_prim_number!(deserialize_u16); deserialize_prim_number!(deserialize_u32); deserialize_prim_number!(deserialize_u64); deserialize_prim_number!(deserialize_f32); deserialize_prim_number!(deserialize_f64); serde_if_integer128! { fn deserialize_i128(self, visitor: V) -> Result where V: de::Visitor<'de>, { let mut buf = String::new(); match tri!(self.parse_whitespace()) { Some(b'-') => { self.eat_char(); buf.push('-'); } Some(_) => {} None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; tri!(self.scan_integer128(&mut buf)); let value = match buf.parse() { Ok(int) => visitor.visit_i128(int), Err(_) => { return Err(self.error(ErrorCode::NumberOutOfRange)); } }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } fn deserialize_u128(self, visitor: V) -> Result where V: de::Visitor<'de>, { match tri!(self.parse_whitespace()) { Some(b'-') => { return Err(self.peek_error(ErrorCode::NumberOutOfRange)); } Some(_) => {} None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } } let mut buf = String::new(); tri!(self.scan_integer128(&mut buf)); let value = match buf.parse() { Ok(int) => visitor.visit_u128(int), Err(_) => { return Err(self.error(ErrorCode::NumberOutOfRange)); } }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } } fn deserialize_char(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_str(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'"' => { self.eat_char(); self.scratch.clear(); match tri!(self.read.parse_str(&mut self.scratch)) { Reference::Borrowed(s) => visitor.visit_borrowed_str(s), Reference::Copied(s) => visitor.visit_str(s), } } _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } fn deserialize_string(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_str(visitor) } /// Parses a JSON string as bytes. Note that this function does not check /// whether the bytes represent a valid UTF-8 string. /// /// The relevant part of the JSON specification is Section 8.2 of [RFC /// 7159]: /// /// > When all the strings represented in a JSON text are composed entirely /// > of Unicode characters (however escaped), then that JSON text is /// > interoperable in the sense that all software implementations that /// > parse it will agree on the contents of names and of string values in /// > objects and arrays. /// > /// > However, the ABNF in this specification allows member names and string /// > values to contain bit sequences that cannot encode Unicode characters; /// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances /// > of this have been observed, for example, when a library truncates a /// > UTF-16 string without checking whether the truncation split a /// > surrogate pair. The behavior of software that receives JSON texts /// > containing such values is unpredictable; for example, implementations /// > might return different values for the length of a string value or even /// > suffer fatal runtime exceptions. /// /// [RFC 7159]: https://tools.ietf.org/html/rfc7159 /// /// The behavior of serde_json is specified to fail on non-UTF-8 strings /// when deserializing into Rust UTF-8 string types such as String, and /// succeed with non-UTF-8 bytes when deserializing using this method. /// /// Escape sequences are processed as usual, and for `\uXXXX` escapes it is /// still checked if the hex number represents a valid Unicode code point. /// /// # Examples /// /// You can use this to parse JSON strings containing invalid UTF-8 bytes. /// /// ``` /// use serde_bytes::ByteBuf; /// /// fn look_at_bytes() -> Result<(), serde_json::Error> { /// let json_data = b"\"some bytes: \xe5\x00\xe5\""; /// let bytes: ByteBuf = serde_json::from_slice(json_data)?; /// /// assert_eq!(b'\xe5', bytes[12]); /// assert_eq!(b'\0', bytes[13]); /// assert_eq!(b'\xe5', bytes[14]); /// /// Ok(()) /// } /// # /// # look_at_bytes().unwrap(); /// ``` /// /// Backslash escape sequences like `\n` are still interpreted and required /// to be valid, and `\u` escape sequences are required to represent valid /// Unicode code points. /// /// ``` /// use serde_bytes::ByteBuf; /// /// fn look_at_bytes() { /// let json_data = b"\"invalid unicode surrogate: \\uD801\""; /// let parsed: Result = serde_json::from_slice(json_data); /// /// assert!(parsed.is_err()); /// /// let expected_msg = "unexpected end of hex escape at line 1 column 35"; /// assert_eq!(expected_msg, parsed.unwrap_err().to_string()); /// } /// # /// # look_at_bytes(); /// ``` fn deserialize_bytes(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'"' => { self.eat_char(); self.scratch.clear(); match tri!(self.read.parse_str_raw(&mut self.scratch)) { Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b), Reference::Copied(b) => visitor.visit_bytes(b), } } b'[' => self.deserialize_seq(visitor), _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } #[inline] fn deserialize_byte_buf(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_bytes(visitor) } /// Parses a `null` as a None, and any other values as a `Some(...)`. #[inline] fn deserialize_option(self, visitor: V) -> Result where V: de::Visitor<'de>, { match tri!(self.parse_whitespace()) { Some(b'n') => { self.eat_char(); tri!(self.parse_ident(b"ull")); visitor.visit_none() } _ => visitor.visit_some(self), } } fn deserialize_unit(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'n' => { self.eat_char(); tri!(self.parse_ident(b"ull")); visitor.visit_unit() } _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_unit(visitor) } /// Parses a newtype struct as the underlying value. #[inline] fn deserialize_newtype_struct(self, name: &str, visitor: V) -> Result where V: de::Visitor<'de>, { #[cfg(feature = "raw_value")] { if name == crate::raw::TOKEN { return self.deserialize_raw_value(visitor); } } let _ = name; visitor.visit_newtype_struct(self) } fn deserialize_seq(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'[' => { check_recursion! { self.eat_char(); let ret = visitor.visit_seq(SeqAccess::new(self)); } match (ret, self.end_seq()) { (Ok(ret), Ok(())) => Ok(ret), (Err(err), _) | (_, Err(err)) => Err(err), } } _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } fn deserialize_tuple(self, _len: usize, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_tuple_struct( self, _name: &'static str, _len: usize, visitor: V, ) -> Result where V: de::Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_map(self, visitor: V) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'{' => { check_recursion! { self.eat_char(); let ret = visitor.visit_map(MapAccess::new(self)); } match (ret, self.end_map()) { (Ok(ret), Ok(())) => Ok(ret), (Err(err), _) | (_, Err(err)) => Err(err), } } _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } fn deserialize_struct( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result where V: de::Visitor<'de>, { let peek = match tri!(self.parse_whitespace()) { Some(b) => b, None => { return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); } }; let value = match peek { b'[' => { check_recursion! { self.eat_char(); let ret = visitor.visit_seq(SeqAccess::new(self)); } match (ret, self.end_seq()) { (Ok(ret), Ok(())) => Ok(ret), (Err(err), _) | (_, Err(err)) => Err(err), } } b'{' => { check_recursion! { self.eat_char(); let ret = visitor.visit_map(MapAccess::new(self)); } match (ret, self.end_map()) { (Ok(ret), Ok(())) => Ok(ret), (Err(err), _) | (_, Err(err)) => Err(err), } } _ => Err(self.peek_invalid_type(&visitor)), }; match value { Ok(value) => Ok(value), Err(err) => Err(self.fix_position(err)), } } /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight /// value, a `[..]`, or a `{..}`. #[inline] fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result where V: de::Visitor<'de>, { match tri!(self.parse_whitespace()) { Some(b'{') => { check_recursion! { self.eat_char(); let value = tri!(visitor.visit_enum(VariantAccess::new(self))); } match tri!(self.parse_whitespace()) { Some(b'}') => { self.eat_char(); Ok(value) } Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)), None => Err(self.error(ErrorCode::EofWhileParsingObject)), } } Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)), Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)), None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)), } } fn deserialize_identifier(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_ignored_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { tri!(self.ignore_value()); visitor.visit_unit() } } struct SeqAccess<'a, R: 'a> { de: &'a mut Deserializer, first: bool, } impl<'a, R: 'a> SeqAccess<'a, R> { fn new(de: &'a mut Deserializer) -> Self { SeqAccess { de: de, first: true, } } } impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result> where T: de::DeserializeSeed<'de>, { let peek = match tri!(self.de.parse_whitespace()) { Some(b']') => { return Ok(None); } Some(b',') if !self.first => { self.de.eat_char(); tri!(self.de.parse_whitespace()) } Some(b) => { if self.first { self.first = false; Some(b) } else { return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd)); } } None => { return Err(self.de.peek_error(ErrorCode::EofWhileParsingList)); } }; match peek { Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)), Some(_) => Ok(Some(tri!(seed.deserialize(&mut *self.de)))), None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)), } } } struct MapAccess<'a, R: 'a> { de: &'a mut Deserializer, first: bool, } impl<'a, R: 'a> MapAccess<'a, R> { fn new(de: &'a mut Deserializer) -> Self { MapAccess { de: de, first: true, } } } impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result> where K: de::DeserializeSeed<'de>, { let peek = match tri!(self.de.parse_whitespace()) { Some(b'}') => { return Ok(None); } Some(b',') if !self.first => { self.de.eat_char(); tri!(self.de.parse_whitespace()) } Some(b) => { if self.first { self.first = false; Some(b) } else { return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd)); } } None => { return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject)); } }; match peek { Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some), Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)), Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)), None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)), } } fn next_value_seed(&mut self, seed: V) -> Result where V: de::DeserializeSeed<'de>, { tri!(self.de.parse_object_colon()); seed.deserialize(&mut *self.de) } } struct VariantAccess<'a, R: 'a> { de: &'a mut Deserializer, } impl<'a, R: 'a> VariantAccess<'a, R> { fn new(de: &'a mut Deserializer) -> Self { VariantAccess { de: de } } } impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> { type Error = Error; type Variant = Self; fn variant_seed(self, seed: V) -> Result<(V::Value, Self)> where V: de::DeserializeSeed<'de>, { let val = tri!(seed.deserialize(&mut *self.de)); tri!(self.de.parse_object_colon()); Ok((val, self)) } } impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> { type Error = Error; fn unit_variant(self) -> Result<()> { de::Deserialize::deserialize(self.de) } fn newtype_variant_seed(self, seed: T) -> Result where T: de::DeserializeSeed<'de>, { seed.deserialize(self.de) } fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: de::Visitor<'de>, { de::Deserializer::deserialize_seq(self.de, visitor) } fn struct_variant(self, fields: &'static [&'static str], visitor: V) -> Result where V: de::Visitor<'de>, { de::Deserializer::deserialize_struct(self.de, "", fields, visitor) } } struct UnitVariantAccess<'a, R: 'a> { de: &'a mut Deserializer, } impl<'a, R: 'a> UnitVariantAccess<'a, R> { fn new(de: &'a mut Deserializer) -> Self { UnitVariantAccess { de: de } } } impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> { type Error = Error; type Variant = Self; fn variant_seed(self, seed: V) -> Result<(V::Value, Self)> where V: de::DeserializeSeed<'de>, { let variant = tri!(seed.deserialize(&mut *self.de)); Ok((variant, self)) } } impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a, R> { type Error = Error; fn unit_variant(self) -> Result<()> { Ok(()) } fn newtype_variant_seed(self, _seed: T) -> Result where T: de::DeserializeSeed<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"newtype variant", )) } fn tuple_variant(self, _len: usize, _visitor: V) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"tuple variant", )) } fn struct_variant(self, _fields: &'static [&'static str], _visitor: V) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"struct variant", )) } } /// Only deserialize from this after peeking a '"' byte! Otherwise it may /// deserialize invalid JSON successfully. struct MapKey<'a, R: 'a> { de: &'a mut Deserializer, } macro_rules! deserialize_integer_key { ($method:ident => $visit:ident) => { fn $method(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.de.eat_char(); self.de.scratch.clear(); let string = tri!(self.de.read.parse_str(&mut self.de.scratch)); match (string.parse(), string) { (Ok(integer), _) => visitor.$visit(integer), (Err(_), Reference::Borrowed(s)) => visitor.visit_borrowed_str(s), (Err(_), Reference::Copied(s)) => visitor.visit_str(s), } } } } impl<'de, 'a, R> de::Deserializer<'de> for MapKey<'a, R> where R: Read<'de>, { type Error = Error; #[inline] fn deserialize_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.de.eat_char(); self.de.scratch.clear(); match tri!(self.de.read.parse_str(&mut self.de.scratch)) { Reference::Borrowed(s) => visitor.visit_borrowed_str(s), Reference::Copied(s) => visitor.visit_str(s), } } deserialize_integer_key!(deserialize_i8 => visit_i8); deserialize_integer_key!(deserialize_i16 => visit_i16); deserialize_integer_key!(deserialize_i32 => visit_i32); deserialize_integer_key!(deserialize_i64 => visit_i64); deserialize_integer_key!(deserialize_u8 => visit_u8); deserialize_integer_key!(deserialize_u16 => visit_u16); deserialize_integer_key!(deserialize_u32 => visit_u32); deserialize_integer_key!(deserialize_u64 => visit_u64); serde_if_integer128! { deserialize_integer_key!(deserialize_i128 => visit_i128); deserialize_integer_key!(deserialize_u128 => visit_u128); } #[inline] fn deserialize_option(self, visitor: V) -> Result where V: de::Visitor<'de>, { // Map keys cannot be null. visitor.visit_some(self) } #[inline] fn deserialize_newtype_struct(self, _name: &'static str, visitor: V) -> Result where V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } #[inline] fn deserialize_enum( self, name: &'static str, variants: &'static [&'static str], visitor: V, ) -> Result where V: de::Visitor<'de>, { self.de.deserialize_enum(name, variants, visitor) } #[inline] fn deserialize_bytes(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.de.deserialize_bytes(visitor) } #[inline] fn deserialize_byte_buf(self, visitor: V) -> Result where V: de::Visitor<'de>, { self.de.deserialize_bytes(visitor) } forward_to_deserialize_any! { bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map struct identifier ignored_any } } ////////////////////////////////////////////////////////////////////////////// /// Iterator that deserializes a stream into multiple JSON values. /// /// A stream deserializer can be created from any JSON deserializer using the /// `Deserializer::into_iter` method. /// /// The data can consist of any JSON value. Values need to be a self-delineating value e.g. /// arrays, objects, or strings, or be followed by whitespace or a self-delineating value. /// /// ``` /// use serde_json::{Deserializer, Value}; /// /// fn main() { /// let data = "{\"k\": 3}1\"cool\"\"stuff\" 3{} [0, 1, 2]"; /// /// let stream = Deserializer::from_str(data).into_iter::(); /// /// for value in stream { /// println!("{}", value.unwrap()); /// } /// } /// ``` pub struct StreamDeserializer<'de, R, T> { de: Deserializer, offset: usize, output: PhantomData, lifetime: PhantomData<&'de ()>, } impl<'de, R, T> StreamDeserializer<'de, R, T> where R: read::Read<'de>, T: de::Deserialize<'de>, { /// Create a JSON stream deserializer from one of the possible serde_json /// input sources. /// /// Typically it is more convenient to use one of these methods instead: /// /// - Deserializer::from_str(...).into_iter() /// - Deserializer::from_bytes(...).into_iter() /// - Deserializer::from_reader(...).into_iter() pub fn new(read: R) -> Self { let offset = read.byte_offset(); StreamDeserializer { de: Deserializer::new(read), offset: offset, output: PhantomData, lifetime: PhantomData, } } /// Returns the number of bytes so far deserialized into a successful `T`. /// /// If a stream deserializer returns an EOF error, new data can be joined to /// `old_data[stream.byte_offset()..]` to try again. /// /// ``` /// let data = b"[0] [1] ["; /// /// let de = serde_json::Deserializer::from_slice(data); /// let mut stream = de.into_iter::>(); /// assert_eq!(0, stream.byte_offset()); /// /// println!("{:?}", stream.next()); // [0] /// assert_eq!(3, stream.byte_offset()); /// /// println!("{:?}", stream.next()); // [1] /// assert_eq!(7, stream.byte_offset()); /// /// println!("{:?}", stream.next()); // error /// assert_eq!(8, stream.byte_offset()); /// /// // If err.is_eof(), can join the remaining data to new data and continue. /// let remaining = &data[stream.byte_offset()..]; /// ``` /// /// *Note:* In the future this method may be changed to return the number of /// bytes so far deserialized into a successful T *or* syntactically valid /// JSON skipped over due to a type error. See [serde-rs/json#70] for an /// example illustrating this. /// /// [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70 pub fn byte_offset(&self) -> usize { self.offset } fn peek_end_of_value(&mut self) -> Result<()> { match tri!(self.de.peek()) { Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') | Some(b'"') | Some(b'[') | Some(b']') | Some(b'{') | Some(b'}') | Some(b',') | Some(b':') | None => Ok(()), Some(_) => { let position = self.de.read.peek_position(); Err(Error::syntax( ErrorCode::TrailingCharacters, position.line, position.column, )) } } } } impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> where R: Read<'de>, T: de::Deserialize<'de>, { type Item = Result; fn next(&mut self) -> Option> { // skip whitespaces, if any // this helps with trailing whitespaces, since whitespaces between // values are handled for us. match self.de.parse_whitespace() { Ok(None) => { self.offset = self.de.read.byte_offset(); None } Ok(Some(b)) => { // If the value does not have a clear way to show the end of the value // (like numbers, null, true etc.) we have to look for whitespace or // the beginning of a self-delineated value. let self_delineated_value = match b { b'[' | b'"' | b'{' => true, _ => false, }; self.offset = self.de.read.byte_offset(); let result = de::Deserialize::deserialize(&mut self.de); Some(match result { Ok(value) => { self.offset = self.de.read.byte_offset(); if self_delineated_value { Ok(value) } else { self.peek_end_of_value().map(|_| value) } } Err(e) => Err(e), }) } Err(e) => Some(Err(e)), } } } ////////////////////////////////////////////////////////////////////////////// fn from_trait<'de, R, T>(read: R) -> Result where R: Read<'de>, T: de::Deserialize<'de>, { let mut de = Deserializer::new(read); let value = tri!(de::Deserialize::deserialize(&mut de)); // Make sure the whole stream has been consumed. tri!(de.end()); Ok(value) } /// Deserialize an instance of type `T` from an IO stream of JSON. /// /// The content of the IO stream is deserialized directly from the stream /// without being buffered in memory by serde_json. /// /// When reading from a source against which short reads are not efficient, such /// as a [`File`], you will want to apply your own buffering because serde_json /// will not buffer the input. See [`std::io::BufReader`]. /// /// It is expected that the input stream ends after the deserialized object. /// If the stream does not end, such as in the case of a persistent socket connection, /// this function will not return. It is possible instead to deserialize from a prefix of an input /// stream without looking for EOF by managing your own [`Deserializer`]. /// /// Note that counter to intuition, this function is usually slower than /// reading a file completely into memory and then applying [`from_str`] /// or [`from_slice`] on it. See [issue #160]. /// /// [`File`]: https://doc.rust-lang.org/std/fs/struct.File.html /// [`std::io::BufReader`]: https://doc.rust-lang.org/std/io/struct.BufReader.html /// [`from_str`]: ./fn.from_str.html /// [`from_slice`]: ./fn.from_slice.html /// [issue #160]: https://github.com/serde-rs/json/issues/160 /// /// # Example /// /// Reading the contents of a file. /// /// ``` /// use serde::Deserialize; /// /// use std::error::Error; /// use std::fs::File; /// use std::io::BufReader; /// use std::path::Path; /// /// #[derive(Deserialize, Debug)] /// struct User { /// fingerprint: String, /// location: String, /// } /// /// fn read_user_from_file>(path: P) -> Result> { /// // Open the file in read-only mode with buffer. /// let file = File::open(path)?; /// let reader = BufReader::new(file); /// /// // Read the JSON contents of the file as an instance of `User`. /// let u = serde_json::from_reader(reader)?; /// /// // Return the `User`. /// Ok(u) /// } /// /// fn main() { /// # } /// # fn fake_main() { /// let u = read_user_from_file("test.json").unwrap(); /// println!("{:#?}", u); /// } /// ``` /// /// Reading from a persistent socket connection. /// /// ``` /// use serde::Deserialize; /// /// use std::error::Error; /// use std::net::{TcpListener, TcpStream}; /// /// #[derive(Deserialize, Debug)] /// struct User { /// fingerprint: String, /// location: String, /// } /// /// fn read_user_from_stream(tcp_stream: TcpStream) -> Result> { /// let mut de = serde_json::Deserializer::from_reader(tcp_stream); /// let u = User::deserialize(&mut de)?; /// /// Ok(u) /// } /// /// fn main() { /// # } /// # fn fake_main() { /// let listener = TcpListener::bind("127.0.0.1:4000").unwrap(); /// /// for stream in listener.incoming() { /// println!("{:#?}", read_user_from_stream(stream.unwrap())); /// } /// } /// ``` /// /// # Errors /// /// This conversion can fail if the structure of the input does not match the /// structure expected by `T`, for example if `T` is a struct type but the input /// contains something other than a JSON map. It can also fail if the structure /// is correct but `T`'s implementation of `Deserialize` decides that something /// is wrong with the data, for example required struct fields are missing from /// the JSON map or some number is too big to fit in the expected primitive /// type. #[cfg(feature = "std")] pub fn from_reader(rdr: R) -> Result where R: crate::io::Read, T: de::DeserializeOwned, { from_trait(read::IoRead::new(rdr)) } /// Deserialize an instance of type `T` from bytes of JSON text. /// /// # Example /// /// ``` /// use serde::Deserialize; /// /// #[derive(Deserialize, Debug)] /// struct User { /// fingerprint: String, /// location: String, /// } /// /// fn main() { /// // The type of `j` is `&[u8]` /// let j = b" /// { /// \"fingerprint\": \"0xF9BA143B95FF6D82\", /// \"location\": \"Menlo Park, CA\" /// }"; /// /// let u: User = serde_json::from_slice(j).unwrap(); /// println!("{:#?}", u); /// } /// ``` /// /// # Errors /// /// This conversion can fail if the structure of the input does not match the /// structure expected by `T`, for example if `T` is a struct type but the input /// contains something other than a JSON map. It can also fail if the structure /// is correct but `T`'s implementation of `Deserialize` decides that something /// is wrong with the data, for example required struct fields are missing from /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_slice<'a, T>(v: &'a [u8]) -> Result where T: de::Deserialize<'a>, { from_trait(read::SliceRead::new(v)) } /// Deserialize an instance of type `T` from a string of JSON text. /// /// # Example /// /// ``` /// use serde::Deserialize; /// /// #[derive(Deserialize, Debug)] /// struct User { /// fingerprint: String, /// location: String, /// } /// /// fn main() { /// // The type of `j` is `&str` /// let j = " /// { /// \"fingerprint\": \"0xF9BA143B95FF6D82\", /// \"location\": \"Menlo Park, CA\" /// }"; /// /// let u: User = serde_json::from_str(j).unwrap(); /// println!("{:#?}", u); /// } /// ``` /// /// # Errors /// /// This conversion can fail if the structure of the input does not match the /// structure expected by `T`, for example if `T` is a struct type but the input /// contains something other than a JSON map. It can also fail if the structure /// is correct but `T`'s implementation of `Deserialize` decides that something /// is wrong with the data, for example required struct fields are missing from /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_str<'a, T>(s: &'a str) -> Result where T: de::Deserialize<'a>, { from_trait(read::StrRead::new(s)) } serde_json-1.0.45/src/error.rs010064400017500001750000000335411361214360100144460ustar0000000000000000//! When serializing or deserializing JSON goes wrong. use crate::io; use crate::lib::str::FromStr; use crate::lib::*; use serde::{de, ser}; /// This type represents all possible errors that can occur when serializing or /// deserializing JSON data. pub struct Error { /// This `Box` allows us to keep the size of `Error` as small as possible. A /// larger `Error` type was substantially slower due to all the functions /// that pass around `Result`. err: Box, } /// Alias for a `Result` with the error type `serde_json::Error`. pub type Result = result::Result; impl Error { /// One-based line number at which the error was detected. /// /// Characters in the first line of the input (before the first newline /// character) are in line 1. pub fn line(&self) -> usize { self.err.line } /// One-based column number at which the error was detected. /// /// The first character in the input and any characters immediately /// following a newline character are in column 1. /// /// Note that errors may occur in column 0, for example if a read from an IO /// stream fails immediately following a previously read newline character. pub fn column(&self) -> usize { self.err.column } /// Categorizes the cause of this error. /// /// - `Category::Io` - failure to read or write bytes on an IO stream /// - `Category::Syntax` - input that is not syntactically valid JSON /// - `Category::Data` - input data that is semantically incorrect /// - `Category::Eof` - unexpected end of the input data pub fn classify(&self) -> Category { match self.err.code { ErrorCode::Message(_) => Category::Data, ErrorCode::Io(_) => Category::Io, ErrorCode::EofWhileParsingList | ErrorCode::EofWhileParsingObject | ErrorCode::EofWhileParsingString | ErrorCode::EofWhileParsingValue => Category::Eof, ErrorCode::ExpectedColon | ErrorCode::ExpectedListCommaOrEnd | ErrorCode::ExpectedObjectCommaOrEnd | ErrorCode::ExpectedSomeIdent | ErrorCode::ExpectedSomeValue | ErrorCode::InvalidEscape | ErrorCode::InvalidNumber | ErrorCode::NumberOutOfRange | ErrorCode::InvalidUnicodeCodePoint | ErrorCode::ControlCharacterWhileParsingString | ErrorCode::KeyMustBeAString | ErrorCode::LoneLeadingSurrogateInHexEscape | ErrorCode::TrailingComma | ErrorCode::TrailingCharacters | ErrorCode::UnexpectedEndOfHexEscape | ErrorCode::RecursionLimitExceeded => Category::Syntax, } } /// Returns true if this error was caused by a failure to read or write /// bytes on an IO stream. pub fn is_io(&self) -> bool { self.classify() == Category::Io } /// Returns true if this error was caused by input that was not /// syntactically valid JSON. pub fn is_syntax(&self) -> bool { self.classify() == Category::Syntax } /// Returns true if this error was caused by input data that was /// semantically incorrect. /// /// For example, JSON containing a number is semantically incorrect when the /// type being deserialized into holds a String. pub fn is_data(&self) -> bool { self.classify() == Category::Data } /// Returns true if this error was caused by prematurely reaching the end of /// the input data. /// /// Callers that process streaming input may be interested in retrying the /// deserialization once more data is available. pub fn is_eof(&self) -> bool { self.classify() == Category::Eof } } /// Categorizes the cause of a `serde_json::Error`. #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum Category { /// The error was caused by a failure to read or write bytes on an IO /// stream. Io, /// The error was caused by input that was not syntactically valid JSON. Syntax, /// The error was caused by input data that was semantically incorrect. /// /// For example, JSON containing a number is semantically incorrect when the /// type being deserialized into holds a String. Data, /// The error was caused by prematurely reaching the end of the input data. /// /// Callers that process streaming input may be interested in retrying the /// deserialization once more data is available. Eof, } #[cfg(feature = "std")] #[allow(clippy::fallible_impl_from)] impl From for io::Error { /// Convert a `serde_json::Error` into an `io::Error`. /// /// JSON syntax and data errors are turned into `InvalidData` IO errors. /// EOF errors are turned into `UnexpectedEof` IO errors. /// /// ``` /// use std::io; /// /// enum MyError { /// Io(io::Error), /// Json(serde_json::Error), /// } /// /// impl From for MyError { /// fn from(err: serde_json::Error) -> MyError { /// use serde_json::error::Category; /// match err.classify() { /// Category::Io => { /// MyError::Io(err.into()) /// } /// Category::Syntax | Category::Data | Category::Eof => { /// MyError::Json(err) /// } /// } /// } /// } /// ``` fn from(j: Error) -> Self { if let ErrorCode::Io(err) = j.err.code { err } else { match j.classify() { Category::Io => unreachable!(), Category::Syntax | Category::Data => io::Error::new(io::ErrorKind::InvalidData, j), Category::Eof => io::Error::new(io::ErrorKind::UnexpectedEof, j), } } } } struct ErrorImpl { code: ErrorCode, line: usize, column: usize, } pub(crate) enum ErrorCode { /// Catchall for syntax error messages Message(Box), /// Some IO error occurred while serializing or deserializing. Io(io::Error), /// EOF while parsing a list. EofWhileParsingList, /// EOF while parsing an object. EofWhileParsingObject, /// EOF while parsing a string. EofWhileParsingString, /// EOF while parsing a JSON value. EofWhileParsingValue, /// Expected this character to be a `':'`. ExpectedColon, /// Expected this character to be either a `','` or a `']'`. ExpectedListCommaOrEnd, /// Expected this character to be either a `','` or a `'}'`. ExpectedObjectCommaOrEnd, /// Expected to parse either a `true`, `false`, or a `null`. ExpectedSomeIdent, /// Expected this character to start a JSON value. ExpectedSomeValue, /// Invalid hex escape code. InvalidEscape, /// Invalid number. InvalidNumber, /// Number is bigger than the maximum value of its type. NumberOutOfRange, /// Invalid unicode code point. InvalidUnicodeCodePoint, /// Control character found while parsing a string. ControlCharacterWhileParsingString, /// Object key is not a string. KeyMustBeAString, /// Lone leading surrogate in hex escape. LoneLeadingSurrogateInHexEscape, /// JSON has a comma after the last value in an array or map. TrailingComma, /// JSON has non-whitespace trailing characters after the value. TrailingCharacters, /// Unexpected end of hex excape. UnexpectedEndOfHexEscape, /// Encountered nesting of JSON maps and arrays more than 128 layers deep. RecursionLimitExceeded, } impl Error { #[cold] pub(crate) fn syntax(code: ErrorCode, line: usize, column: usize) -> Self { Error { err: Box::new(ErrorImpl { code: code, line: line, column: column, }), } } // Not public API. Should be pub(crate). // // Update `eager_json` crate when this function changes. #[doc(hidden)] #[cold] pub fn io(error: io::Error) -> Self { Error { err: Box::new(ErrorImpl { code: ErrorCode::Io(error), line: 0, column: 0, }), } } #[cold] pub(crate) fn fix_position(self, f: F) -> Self where F: FnOnce(ErrorCode) -> Error, { if self.err.line == 0 { f(self.err.code) } else { self } } } impl Display for ErrorCode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { ErrorCode::Message(ref msg) => f.write_str(msg), ErrorCode::Io(ref err) => Display::fmt(err, f), ErrorCode::EofWhileParsingList => f.write_str("EOF while parsing a list"), ErrorCode::EofWhileParsingObject => f.write_str("EOF while parsing an object"), ErrorCode::EofWhileParsingString => f.write_str("EOF while parsing a string"), ErrorCode::EofWhileParsingValue => f.write_str("EOF while parsing a value"), ErrorCode::ExpectedColon => f.write_str("expected `:`"), ErrorCode::ExpectedListCommaOrEnd => f.write_str("expected `,` or `]`"), ErrorCode::ExpectedObjectCommaOrEnd => f.write_str("expected `,` or `}`"), ErrorCode::ExpectedSomeIdent => f.write_str("expected ident"), ErrorCode::ExpectedSomeValue => f.write_str("expected value"), ErrorCode::InvalidEscape => f.write_str("invalid escape"), ErrorCode::InvalidNumber => f.write_str("invalid number"), ErrorCode::NumberOutOfRange => f.write_str("number out of range"), ErrorCode::InvalidUnicodeCodePoint => f.write_str("invalid unicode code point"), ErrorCode::ControlCharacterWhileParsingString => { f.write_str("control character (\\u0000-\\u001F) found while parsing a string") } ErrorCode::KeyMustBeAString => f.write_str("key must be a string"), ErrorCode::LoneLeadingSurrogateInHexEscape => { f.write_str("lone leading surrogate in hex escape") } ErrorCode::TrailingComma => f.write_str("trailing comma"), ErrorCode::TrailingCharacters => f.write_str("trailing characters"), ErrorCode::UnexpectedEndOfHexEscape => f.write_str("unexpected end of hex escape"), ErrorCode::RecursionLimitExceeded => f.write_str("recursion limit exceeded"), } } } impl serde::de::StdError for Error { #[cfg(feature = "std")] fn source(&self) -> Option<&(dyn error::Error + 'static)> { match self.err.code { ErrorCode::Io(ref err) => Some(err), _ => None, } } } impl Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { Display::fmt(&*self.err, f) } } impl Display for ErrorImpl { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.line == 0 { Display::fmt(&self.code, f) } else { write!( f, "{} at line {} column {}", self.code, self.line, self.column ) } } } // Remove two layers of verbosity from the debug representation. Humans often // end up seeing this representation because it is what unwrap() shows. impl Debug for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Error({:?}, line: {}, column: {})", self.err.code.to_string(), self.err.line, self.err.column ) } } impl de::Error for Error { #[cold] fn custom(msg: T) -> Error { make_error(msg.to_string()) } #[cold] fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self { if let de::Unexpected::Unit = unexp { Error::custom(format_args!("invalid type: null, expected {}", exp)) } else { Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp)) } } } impl ser::Error for Error { #[cold] fn custom(msg: T) -> Error { make_error(msg.to_string()) } } // Parse our own error message that looks like "{} at line {} column {}" to work // around erased-serde round-tripping the error through de::Error::custom. fn make_error(mut msg: String) -> Error { let (line, column) = parse_line_col(&mut msg).unwrap_or((0, 0)); Error { err: Box::new(ErrorImpl { code: ErrorCode::Message(msg.into_boxed_str()), line: line, column: column, }), } } fn parse_line_col(msg: &mut String) -> Option<(usize, usize)> { let start_of_suffix = match msg.rfind(" at line ") { Some(index) => index, None => return None, }; // Find start and end of line number. let start_of_line = start_of_suffix + " at line ".len(); let mut end_of_line = start_of_line; while starts_with_digit(&msg[end_of_line..]) { end_of_line += 1; } if !msg[end_of_line..].starts_with(" column ") { return None; } // Find start and end of column number. let start_of_column = end_of_line + " column ".len(); let mut end_of_column = start_of_column; while starts_with_digit(&msg[end_of_column..]) { end_of_column += 1; } if end_of_column < msg.len() { return None; } // Parse numbers. let line = match usize::from_str(&msg[start_of_line..end_of_line]) { Ok(line) => line, Err(_) => return None, }; let column = match usize::from_str(&msg[start_of_column..end_of_column]) { Ok(column) => column, Err(_) => return None, }; msg.truncate(start_of_suffix); Some((line, column)) } fn starts_with_digit(slice: &str) -> bool { match slice.as_bytes().get(0) { None => false, Some(&byte) => byte >= b'0' && byte <= b'9', } } serde_json-1.0.45/src/features_check/error.rs010064400017500001750000000001201361213363400174110ustar0000000000000000"serde_json requires that either `std` (default) or `alloc` feature is enabled" serde_json-1.0.45/src/features_check/mod.rs010064400017500001750000000004151361213363400170460ustar0000000000000000//! Shows a user-friendly compiler error on incompatible selected features. #[allow(unused_macros)] macro_rules! hide_from_rustfmt { ($mod:item) => { $mod }; } #[cfg(not(any(feature = "std", feature = "alloc")))] hide_from_rustfmt! { mod error; } serde_json-1.0.45/src/io/core.rs010064400017500001750000000032251361216013500146510ustar0000000000000000//! Reimplements core logic and types from `std::io` in an `alloc`-friendly //! fashion. use crate::lib::*; pub enum ErrorKind { Other, } // IO errors can never occur in no-std mode. All our no-std IO implementations // are infallible. pub struct Error; impl Display for Error { fn fmt(&self, _formatter: &mut fmt::Formatter<'_>) -> fmt::Result { unreachable!() } } impl Error { pub(crate) fn new(_kind: ErrorKind, _error: &'static str) -> Error { Error } } pub type Result = result::Result; pub trait Write { fn write(&mut self, buf: &[u8]) -> Result; fn write_all(&mut self, buf: &[u8]) -> Result<()> { // All our Write impls in no_std mode always write the whole buffer in // one call infallibly. let result = self.write(buf); debug_assert!(result.is_ok()); debug_assert_eq!(result.unwrap_or(0), buf.len()); Ok(()) } fn flush(&mut self) -> Result<()>; } impl Write for &mut W { #[inline] fn write(&mut self, buf: &[u8]) -> Result { (*self).write(buf) } #[inline] fn write_all(&mut self, buf: &[u8]) -> Result<()> { (*self).write_all(buf) } #[inline] fn flush(&mut self) -> Result<()> { (*self).flush() } } impl Write for Vec { #[inline] fn write(&mut self, buf: &[u8]) -> Result { self.extend_from_slice(buf); Ok(buf.len()) } #[inline] fn write_all(&mut self, buf: &[u8]) -> Result<()> { self.extend_from_slice(buf); Ok(()) } #[inline] fn flush(&mut self) -> Result<()> { Ok(()) } } serde_json-1.0.45/src/io/mod.rs010064400017500001750000000012541361213363600145060ustar0000000000000000//! A tiny, `no_std`-friendly facade around `std::io`. //! Reexports types from `std` when available; otherwise reimplements and //! provides some of the core logic. //! //! The main reason that `std::io` hasn't found itself reexported as part of //! the `core` crate is the `std::io::{Read, Write}` traits' reliance on //! `std::io::Error`, which may contain internally a heap-allocated `Box` //! and/or now relying on OS-specific `std::backtrace::Backtrace`. pub use self::imp::{Error, ErrorKind, Result, Write}; #[cfg(not(feature = "std"))] #[path = "core.rs"] mod imp; #[cfg(feature = "std")] use std::io as imp; #[cfg(feature = "std")] pub use std::io::{Bytes, Read}; serde_json-1.0.45/src/iter.rs010064400017500001750000000034761361213776100142760ustar0000000000000000use crate::io; pub struct LineColIterator { iter: I, /// Index of the current line. Characters in the first line of the input /// (before the first newline character) are in line 1. line: usize, /// Index of the current column. The first character in the input and any /// characters immediately following a newline character are in column 1. /// The column is 0 immediately after a newline character has been read. col: usize, /// Byte offset of the start of the current line. This is the sum of lenghts /// of all previous lines. Keeping track of things this way allows efficient /// computation of the current line, column, and byte offset while only /// updating one of the counters in `next()` in the common case. start_of_line: usize, } impl LineColIterator where I: Iterator>, { pub fn new(iter: I) -> LineColIterator { LineColIterator { iter: iter, line: 1, col: 0, start_of_line: 0, } } pub fn line(&self) -> usize { self.line } pub fn col(&self) -> usize { self.col } pub fn byte_offset(&self) -> usize { self.start_of_line + self.col } } impl Iterator for LineColIterator where I: Iterator>, { type Item = io::Result; fn next(&mut self) -> Option> { match self.iter.next() { None => None, Some(Ok(b'\n')) => { self.start_of_line += self.col + 1; self.line += 1; self.col = 0; Some(Ok(b'\n')) } Some(Ok(c)) => { self.col += 1; Some(Ok(c)) } Some(Err(e)) => Some(Err(e)), } } } serde_json-1.0.45/src/lib.rs010064400017500001750000000350231361216122700140640ustar0000000000000000//! # Serde JSON //! //! JSON is a ubiquitous open-standard format that uses human-readable text to //! transmit data objects consisting of key-value pairs. //! //! ```json //! { //! "name": "John Doe", //! "age": 43, //! "address": { //! "street": "10 Downing Street", //! "city": "London" //! }, //! "phones": [ //! "+44 1234567", //! "+44 2345678" //! ] //! } //! ``` //! //! There are three common ways that you might find yourself needing to work //! with JSON data in Rust. //! //! - **As text data.** An unprocessed string of JSON data that you receive on //! an HTTP endpoint, read from a file, or prepare to send to a remote //! server. //! - **As an untyped or loosely typed representation.** Maybe you want to //! check that some JSON data is valid before passing it on, but without //! knowing the structure of what it contains. Or you want to do very basic //! manipulations like insert a key in a particular spot. //! - **As a strongly typed Rust data structure.** When you expect all or most //! of your data to conform to a particular structure and want to get real //! work done without JSON's loosey-goosey nature tripping you up. //! //! Serde JSON provides efficient, flexible, safe ways of converting data //! between each of these representations. //! //! # Operating on untyped JSON values //! //! Any valid JSON data can be manipulated in the following recursive enum //! representation. This data structure is [`serde_json::Value`][value]. //! //! ``` //! # use serde_json::{Number, Map}; //! # //! # #[allow(dead_code)] //! enum Value { //! Null, //! Bool(bool), //! Number(Number), //! String(String), //! Array(Vec), //! Object(Map), //! } //! ``` //! //! A string of JSON data can be parsed into a `serde_json::Value` by the //! [`serde_json::from_str`][from_str] function. There is also //! [`from_slice`][from_slice] for parsing from a byte slice &[u8] and //! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or //! a TCP stream. //! //! ``` //! use serde_json::{Result, Value}; //! //! fn untyped_example() -> Result<()> { //! // Some JSON input data as a &str. Maybe this comes from the user. //! let data = r#" //! { //! "name": "John Doe", //! "age": 43, //! "phones": [ //! "+44 1234567", //! "+44 2345678" //! ] //! }"#; //! //! // Parse the string of data into serde_json::Value. //! let v: Value = serde_json::from_str(data)?; //! //! // Access parts of the data by indexing with square brackets. //! println!("Please call {} at the number {}", v["name"], v["phones"][0]); //! //! Ok(()) //! } //! # //! # fn main() { //! # untyped_example().unwrap(); //! # } //! ``` //! //! The result of square bracket indexing like `v["name"]` is a borrow of the //! data at that index, so the type is `&Value`. A JSON map can be indexed with //! string keys, while a JSON array can be indexed with integer keys. If the //! type of the data is not right for the type with which it is being indexed, //! or if a map does not contain the key being indexed, or if the index into a //! vector is out of bounds, the returned element is `Value::Null`. //! //! When a `Value` is printed, it is printed as a JSON string. So in the code //! above, the output looks like `Please call "John Doe" at the number "+44 //! 1234567"`. The quotation marks appear because `v["name"]` is a `&Value` //! containing a JSON string and its JSON representation is `"John Doe"`. //! Printing as a plain string without quotation marks involves converting from //! a JSON string to a Rust string with [`as_str()`] or avoiding the use of //! `Value` as described in the following section. //! //! [`as_str()`]: https://docs.serde.rs/serde_json/enum.Value.html#method.as_str //! //! The `Value` representation is sufficient for very basic tasks but can be //! tedious to work with for anything more significant. Error handling is //! verbose to implement correctly, for example imagine trying to detect the //! presence of unrecognized fields in the input data. The compiler is powerless //! to help you when you make a mistake, for example imagine typoing `v["name"]` //! as `v["nmae"]` in one of the dozens of places it is used in your code. //! //! # Parsing JSON as strongly typed data structures //! //! Serde provides a powerful way of mapping JSON data into Rust data structures //! largely automatically. //! //! ``` //! use serde::{Deserialize, Serialize}; //! use serde_json::Result; //! //! #[derive(Serialize, Deserialize)] //! struct Person { //! name: String, //! age: u8, //! phones: Vec, //! } //! //! fn typed_example() -> Result<()> { //! // Some JSON input data as a &str. Maybe this comes from the user. //! let data = r#" //! { //! "name": "John Doe", //! "age": 43, //! "phones": [ //! "+44 1234567", //! "+44 2345678" //! ] //! }"#; //! //! // Parse the string of data into a Person object. This is exactly the //! // same function as the one that produced serde_json::Value above, but //! // now we are asking it for a Person as output. //! let p: Person = serde_json::from_str(data)?; //! //! // Do things just like with any other Rust data structure. //! println!("Please call {} at the number {}", p.name, p.phones[0]); //! //! Ok(()) //! } //! # //! # fn main() { //! # typed_example().unwrap(); //! # } //! ``` //! //! This is the same `serde_json::from_str` function as before, but this time we //! assign the return value to a variable of type `Person` so Serde will //! automatically interpret the input data as a `Person` and produce informative //! error messages if the layout does not conform to what a `Person` is expected //! to look like. //! //! Any type that implements Serde's `Deserialize` trait can be deserialized //! this way. This includes built-in Rust standard library types like `Vec` //! and `HashMap`, as well as any structs or enums annotated with //! `#[derive(Deserialize)]`. //! //! Once we have `p` of type `Person`, our IDE and the Rust compiler can help us //! use it correctly like they do for any other Rust code. The IDE can //! autocomplete field names to prevent typos, which was impossible in the //! `serde_json::Value` representation. And the Rust compiler can check that //! when we write `p.phones[0]`, then `p.phones` is guaranteed to be a //! `Vec` so indexing into it makes sense and produces a `String`. //! //! # Constructing JSON values //! //! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value` //! objects with very natural JSON syntax. //! //! ``` //! use serde_json::json; //! //! fn main() { //! // The type of `john` is `serde_json::Value` //! let john = json!({ //! "name": "John Doe", //! "age": 43, //! "phones": [ //! "+44 1234567", //! "+44 2345678" //! ] //! }); //! //! println!("first phone number: {}", john["phones"][0]); //! //! // Convert to a string of JSON and print it out //! println!("{}", john.to_string()); //! } //! ``` //! //! The `Value::to_string()` function converts a `serde_json::Value` into a //! `String` of JSON text. //! //! One neat thing about the `json!` macro is that variables and expressions can //! be interpolated directly into the JSON value as you are building it. Serde //! will check at compile time that the value you are interpolating is able to //! be represented as JSON. //! //! ``` //! # use serde_json::json; //! # //! # fn random_phone() -> u16 { 0 } //! # //! let full_name = "John Doe"; //! let age_last_year = 42; //! //! // The type of `john` is `serde_json::Value` //! let john = json!({ //! "name": full_name, //! "age": age_last_year + 1, //! "phones": [ //! format!("+44 {}", random_phone()) //! ] //! }); //! ``` //! //! This is amazingly convenient but we have the problem we had before with //! `Value` which is that the IDE and Rust compiler cannot help us if we get it //! wrong. Serde JSON provides a better way of serializing strongly-typed data //! structures into JSON text. //! //! # Creating JSON by serializing data structures //! //! A data structure can be converted to a JSON string by //! [`serde_json::to_string`][to_string]. There is also //! [`serde_json::to_vec`][to_vec] which serializes to a `Vec` and //! [`serde_json::to_writer`][to_writer] which serializes to any `io::Write` //! such as a File or a TCP stream. //! //! ``` //! use serde::{Deserialize, Serialize}; //! use serde_json::Result; //! //! #[derive(Serialize, Deserialize)] //! struct Address { //! street: String, //! city: String, //! } //! //! fn print_an_address() -> Result<()> { //! // Some data structure. //! let address = Address { //! street: "10 Downing Street".to_owned(), //! city: "London".to_owned(), //! }; //! //! // Serialize it to a JSON string. //! let j = serde_json::to_string(&address)?; //! //! // Print, write to a file, or send to an HTTP server. //! println!("{}", j); //! //! Ok(()) //! } //! # //! # fn main() { //! # print_an_address().unwrap(); //! # } //! ``` //! //! Any type that implements Serde's `Serialize` trait can be serialized this //! way. This includes built-in Rust standard library types like `Vec` and //! `HashMap`, as well as any structs or enums annotated with //! `#[derive(Serialize)]`. //! //! # No-std support //! //! As long as there is a memory allocator, it is possible to use serde_json //! without the rest of the Rust standard library. This is supported on Rust //! 1.36+. Disable the default "std" feature and enable the "alloc" feature: //! //! ```toml //! [dependencies] //! serde_json = { version = "1.0", default-features = false, features = ["alloc"] } //! ``` //! //! For JSON support in Serde without a memory allocator, please see the //! [`serde-json-core`] crate. //! //! [value]: https://docs.serde.rs/serde_json/value/enum.Value.html //! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html //! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html //! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html //! [to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html //! [to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html //! [to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html //! [macro]: https://docs.serde.rs/serde_json/macro.json.html //! [`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_json_core/ #![doc(html_root_url = "https://docs.rs/serde_json/1.0.45")] #![deny(clippy::all, clippy::pedantic)] // Ignored clippy lints #![allow( clippy::deprecated_cfg_attr, clippy::doc_markdown, clippy::needless_doctest_main, clippy::transmute_ptr_to_ptr )] // Ignored clippy_pedantic lints #![allow( // Deserializer::from_str, into_iter clippy::should_implement_trait, // integer and float ser/de requires these sorts of casts clippy::cast_possible_wrap, clippy::cast_precision_loss, clippy::cast_sign_loss, // correctly used clippy::integer_division, // things are often more readable this way clippy::cast_lossless, clippy::module_name_repetitions, clippy::shadow_unrelated, clippy::single_match_else, clippy::too_many_lines, clippy::use_self, clippy::zero_prefixed_literal, // we support older compilers clippy::checked_conversions, clippy::redundant_field_names, // noisy clippy::missing_errors_doc, clippy::must_use_candidate, )] #![deny(missing_docs)] #![cfg_attr(not(feature = "std"), no_std)] //////////////////////////////////////////////////////////////////////////////// #[cfg(not(feature = "std"))] extern crate alloc; /// A facade around all the types we need from the `std`, `core`, and `alloc` /// crates. This avoids elaborate import wrangling having to happen in every /// module. mod lib { mod core { #[cfg(not(feature = "std"))] pub use core::*; #[cfg(feature = "std")] pub use std::*; } pub use self::core::cell::{Cell, RefCell}; pub use self::core::clone::{self, Clone}; pub use self::core::convert::{self, From, Into}; pub use self::core::default::{self, Default}; pub use self::core::fmt::{self, Debug, Display}; pub use self::core::hash::{self, Hash}; pub use self::core::marker::{self, PhantomData}; pub use self::core::result::{self, Result}; pub use self::core::{borrow, char, cmp, iter, mem, num, ops, slice, str}; #[cfg(not(feature = "std"))] pub use alloc::borrow::{Cow, ToOwned}; #[cfg(feature = "std")] pub use std::borrow::{Cow, ToOwned}; #[cfg(not(feature = "std"))] pub use alloc::string::{String, ToString}; #[cfg(feature = "std")] pub use std::string::{String, ToString}; #[cfg(not(feature = "std"))] pub use alloc::vec::{self, Vec}; #[cfg(feature = "std")] pub use std::vec::{self, Vec}; #[cfg(not(feature = "std"))] pub use alloc::boxed::Box; #[cfg(feature = "std")] pub use std::boxed::Box; #[cfg(not(feature = "std"))] pub use alloc::collections::{btree_map, BTreeMap}; #[cfg(feature = "std")] pub use std::collections::{btree_map, BTreeMap}; #[cfg(feature = "std")] pub use std::error; } //////////////////////////////////////////////////////////////////////////////// #[cfg(feature = "std")] #[doc(inline)] pub use crate::de::from_reader; #[doc(inline)] pub use crate::de::{from_slice, from_str, Deserializer, StreamDeserializer}; #[doc(inline)] pub use crate::error::{Error, Result}; #[doc(inline)] pub use crate::ser::{to_string, to_string_pretty, to_vec, to_vec_pretty}; #[cfg(feature = "std")] #[doc(inline)] pub use crate::ser::{to_writer, to_writer_pretty, Serializer}; #[doc(inline)] pub use crate::value::{from_value, to_value, Map, Number, Value}; // We only use our own error type; no need for From conversions provided by the // standard library's try! macro. This reduces lines of LLVM IR by 4%. macro_rules! tri { ($e:expr) => { match $e { crate::lib::Result::Ok(val) => val, crate::lib::Result::Err(err) => return crate::lib::Result::Err(err), } }; } #[macro_use] mod macros; pub mod de; pub mod error; pub mod map; #[cfg(feature = "std")] pub mod ser; #[cfg(not(feature = "std"))] mod ser; pub mod value; mod features_check; mod io; #[cfg(feature = "std")] mod iter; mod number; mod read; #[cfg(feature = "raw_value")] mod raw; serde_json-1.0.45/src/macros.rs010064400017500001750000000231071361214067400146050ustar0000000000000000/// Construct a `serde_json::Value` from a JSON literal. /// /// ``` /// # use serde_json::json; /// # /// let value = json!({ /// "code": 200, /// "success": true, /// "payload": { /// "features": [ /// "serde", /// "json" /// ] /// } /// }); /// ``` /// /// Variables or expressions can be interpolated into the JSON literal. Any type /// interpolated into an array element or object value must implement Serde's /// `Serialize` trait, while any type interpolated into a object key must /// implement `Into`. If the `Serialize` implementation of the /// interpolated type decides to fail, or if the interpolated type contains a /// map with non-string keys, the `json!` macro will panic. /// /// ``` /// # use serde_json::json; /// # /// let code = 200; /// let features = vec!["serde", "json"]; /// /// let value = json!({ /// "code": code, /// "success": code == 200, /// "payload": { /// features[0]: features[1] /// } /// }); /// ``` /// /// Trailing commas are allowed inside both arrays and objects. /// /// ``` /// # use serde_json::json; /// # /// let value = json!([ /// "notice", /// "the", /// "trailing", /// "comma -->", /// ]); /// ``` #[macro_export(local_inner_macros)] macro_rules! json { // Hide distracting implementation details from the generated rustdoc. ($($json:tt)+) => { json_internal!($($json)+) }; } // Rocket relies on this because they export their own `json!` with a different // doc comment than ours, and various Rust bugs prevent them from calling our // `json!` from their `json!` so they call `json_internal!` directly. Check with // @SergioBenitez before making breaking changes to this macro. // // Changes are fine as long as `json_internal!` does not call any new helper // macros and can still be invoked as `json_internal!($($json)+)`. #[macro_export(local_inner_macros)] #[doc(hidden)] macro_rules! json_internal { ////////////////////////////////////////////////////////////////////////// // TT muncher for parsing the inside of an array [...]. Produces a vec![...] // of the elements. // // Must be invoked as: json_internal!(@array [] $($tt)*) ////////////////////////////////////////////////////////////////////////// // Done with trailing comma. (@array [$($elems:expr,)*]) => { json_internal_vec![$($elems,)*] }; // Done without trailing comma. (@array [$($elems:expr),*]) => { json_internal_vec![$($elems),*] }; // Next element is `null`. (@array [$($elems:expr,)*] null $($rest:tt)*) => { json_internal!(@array [$($elems,)* json_internal!(null)] $($rest)*) }; // Next element is `true`. (@array [$($elems:expr,)*] true $($rest:tt)*) => { json_internal!(@array [$($elems,)* json_internal!(true)] $($rest)*) }; // Next element is `false`. (@array [$($elems:expr,)*] false $($rest:tt)*) => { json_internal!(@array [$($elems,)* json_internal!(false)] $($rest)*) }; // Next element is an array. (@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => { json_internal!(@array [$($elems,)* json_internal!([$($array)*])] $($rest)*) }; // Next element is a map. (@array [$($elems:expr,)*] {$($map:tt)*} $($rest:tt)*) => { json_internal!(@array [$($elems,)* json_internal!({$($map)*})] $($rest)*) }; // Next element is an expression followed by comma. (@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => { json_internal!(@array [$($elems,)* json_internal!($next),] $($rest)*) }; // Last element is an expression with no trailing comma. (@array [$($elems:expr,)*] $last:expr) => { json_internal!(@array [$($elems,)* json_internal!($last)]) }; // Comma after the most recent element. (@array [$($elems:expr),*] , $($rest:tt)*) => { json_internal!(@array [$($elems,)*] $($rest)*) }; // Unexpected token after most recent element. (@array [$($elems:expr),*] $unexpected:tt $($rest:tt)*) => { json_unexpected!($unexpected) }; ////////////////////////////////////////////////////////////////////////// // TT muncher for parsing the inside of an object {...}. Each entry is // inserted into the given map variable. // // Must be invoked as: json_internal!(@object $map () ($($tt)*) ($($tt)*)) // // We require two copies of the input tokens so that we can match on one // copy and trigger errors on the other copy. ////////////////////////////////////////////////////////////////////////// // Done. (@object $object:ident () () ()) => {}; // Insert the current entry followed by trailing comma. (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => { let _ = $object.insert(($($key)+).into(), $value); json_internal!(@object $object () ($($rest)*) ($($rest)*)); }; // Current entry followed by unexpected token. (@object $object:ident [$($key:tt)+] ($value:expr) $unexpected:tt $($rest:tt)*) => { json_unexpected!($unexpected); }; // Insert the last entry without trailing comma. (@object $object:ident [$($key:tt)+] ($value:expr)) => { let _ = $object.insert(($($key)+).into(), $value); }; // Next value is `null`. (@object $object:ident ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!(null)) $($rest)*); }; // Next value is `true`. (@object $object:ident ($($key:tt)+) (: true $($rest:tt)*) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!(true)) $($rest)*); }; // Next value is `false`. (@object $object:ident ($($key:tt)+) (: false $($rest:tt)*) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!(false)) $($rest)*); }; // Next value is an array. (@object $object:ident ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!([$($array)*])) $($rest)*); }; // Next value is a map. (@object $object:ident ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!({$($map)*})) $($rest)*); }; // Next value is an expression followed by comma. (@object $object:ident ($($key:tt)+) (: $value:expr , $($rest:tt)*) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!($value)) , $($rest)*); }; // Last value is an expression with no trailing comma. (@object $object:ident ($($key:tt)+) (: $value:expr) $copy:tt) => { json_internal!(@object $object [$($key)+] (json_internal!($value))); }; // Missing value for last entry. Trigger a reasonable error message. (@object $object:ident ($($key:tt)+) (:) $copy:tt) => { // "unexpected end of macro invocation" json_internal!(); }; // Missing colon and value for last entry. Trigger a reasonable error // message. (@object $object:ident ($($key:tt)+) () $copy:tt) => { // "unexpected end of macro invocation" json_internal!(); }; // Misplaced colon. Trigger a reasonable error message. (@object $object:ident () (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => { // Takes no arguments so "no rules expected the token `:`". json_unexpected!($colon); }; // Found a comma inside a key. Trigger a reasonable error message. (@object $object:ident ($($key:tt)*) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => { // Takes no arguments so "no rules expected the token `,`". json_unexpected!($comma); }; // Key is fully parenthesized. This avoids clippy double_parens false // positives because the parenthesization may be necessary here. (@object $object:ident () (($key:expr) : $($rest:tt)*) $copy:tt) => { json_internal!(@object $object ($key) (: $($rest)*) (: $($rest)*)); }; // Munch a token into the current key. (@object $object:ident ($($key:tt)*) ($tt:tt $($rest:tt)*) $copy:tt) => { json_internal!(@object $object ($($key)* $tt) ($($rest)*) ($($rest)*)); }; ////////////////////////////////////////////////////////////////////////// // The main implementation. // // Must be invoked as: json_internal!($($json)+) ////////////////////////////////////////////////////////////////////////// (null) => { $crate::Value::Null }; (true) => { $crate::Value::Bool(true) }; (false) => { $crate::Value::Bool(false) }; ([]) => { $crate::Value::Array(json_internal_vec![]) }; ([ $($tt:tt)+ ]) => { $crate::Value::Array(json_internal!(@array [] $($tt)+)) }; ({}) => { $crate::Value::Object($crate::Map::new()) }; ({ $($tt:tt)+ }) => { $crate::Value::Object({ let mut object = $crate::Map::new(); json_internal!(@object object () ($($tt)+) ($($tt)+)); object }) }; // Any Serialize type: numbers, strings, struct literals, variables etc. // Must be below every other rule. ($other:expr) => { $crate::to_value(&$other).unwrap() }; } // The json_internal macro above cannot invoke vec directly because it uses // local_inner_macros. A vec invocation there would resolve to $crate::vec. // Instead invoke vec here outside of local_inner_macros. #[macro_export] #[doc(hidden)] macro_rules! json_internal_vec { ($($content:tt)*) => { vec![$($content)*] }; } #[macro_export] #[doc(hidden)] macro_rules! json_unexpected { () => {}; } serde_json-1.0.45/src/map.rs010064400017500001750000000540501361214206200140700ustar0000000000000000//! A map of String to serde_json::Value. //! //! By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order` //! feature of serde_json to use [`IndexMap`] instead. //! //! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html //! [`IndexMap`]: https://docs.rs/indexmap/*/indexmap/map/struct.IndexMap.html use crate::lib::borrow::Borrow; use crate::lib::iter::FromIterator; use crate::lib::*; use crate::value::Value; use serde::{de, ser}; #[cfg(feature = "preserve_order")] use indexmap::{self, IndexMap}; /// Represents a JSON key/value type. pub struct Map { map: MapImpl, } #[cfg(not(feature = "preserve_order"))] type MapImpl = BTreeMap; #[cfg(feature = "preserve_order")] type MapImpl = IndexMap; impl Map { /// Makes a new empty Map. #[inline] pub fn new() -> Self { Map { map: MapImpl::new(), } } #[cfg(not(feature = "preserve_order"))] /// Makes a new empty Map with the given initial capacity. #[inline] pub fn with_capacity(capacity: usize) -> Self { // does not support with_capacity let _ = capacity; Map { map: BTreeMap::new(), } } #[cfg(feature = "preserve_order")] /// Makes a new empty Map with the given initial capacity. #[inline] pub fn with_capacity(capacity: usize) -> Self { Map { map: IndexMap::with_capacity(capacity), } } /// Clears the map, removing all values. #[inline] pub fn clear(&mut self) { self.map.clear() } /// Returns a reference to the value corresponding to the key. /// /// The key may be any borrowed form of the map's key type, but the ordering /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn get(&self, key: &Q) -> Option<&Value> where String: Borrow, Q: Ord + Eq + Hash, { self.map.get(key) } /// Returns true if the map contains a value for the specified key. /// /// The key may be any borrowed form of the map's key type, but the ordering /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn contains_key(&self, key: &Q) -> bool where String: Borrow, Q: Ord + Eq + Hash, { self.map.contains_key(key) } /// Returns a mutable reference to the value corresponding to the key. /// /// The key may be any borrowed form of the map's key type, but the ordering /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn get_mut(&mut self, key: &Q) -> Option<&mut Value> where String: Borrow, Q: Ord + Eq + Hash, { self.map.get_mut(key) } /// Inserts a key-value pair into the map. /// /// If the map did not have this key present, `None` is returned. /// /// If the map did have this key present, the value is updated, and the old /// value is returned. #[inline] pub fn insert(&mut self, k: String, v: Value) -> Option { self.map.insert(k, v) } /// Removes a key from the map, returning the value at the key if the key /// was previously in the map. /// /// The key may be any borrowed form of the map's key type, but the ordering /// on the borrowed form *must* match the ordering on the key type. #[inline] pub fn remove(&mut self, key: &Q) -> Option where String: Borrow, Q: Ord + Eq + Hash, { #[cfg(feature = "preserve_order")] return self.map.swap_remove(key); #[cfg(not(feature = "preserve_order"))] return self.map.remove(key); } /// Moves all elements from other into Self, leaving other empty. #[inline] pub fn append(&mut self, other: &mut Self) { #[cfg(feature = "preserve_order")] for (k, v) in std::mem::replace(&mut other.map, MapImpl::default()).into_iter() { self.map.insert(k, v); } #[cfg(not(feature = "preserve_order"))] self.map.append(&mut other.map); } /// Gets the given key's corresponding entry in the map for in-place /// manipulation. pub fn entry(&mut self, key: S) -> Entry where S: Into, { #[cfg(not(feature = "preserve_order"))] use crate::lib::btree_map::Entry as EntryImpl; #[cfg(feature = "preserve_order")] use indexmap::map::Entry as EntryImpl; match self.map.entry(key.into()) { EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant: vacant }), EntryImpl::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied: occupied }), } } /// Returns the number of elements in the map. #[inline] pub fn len(&self) -> usize { self.map.len() } /// Returns true if the map contains no elements. #[inline] pub fn is_empty(&self) -> bool { self.map.is_empty() } /// Gets an iterator over the entries of the map. #[inline] pub fn iter(&self) -> Iter { Iter { iter: self.map.iter(), } } /// Gets a mutable iterator over the entries of the map. #[inline] pub fn iter_mut(&mut self) -> IterMut { IterMut { iter: self.map.iter_mut(), } } /// Gets an iterator over the keys of the map. #[inline] pub fn keys(&self) -> Keys { Keys { iter: self.map.keys(), } } /// Gets an iterator over the values of the map. #[inline] pub fn values(&self) -> Values { Values { iter: self.map.values(), } } /// Gets an iterator over mutable values of the map. #[inline] pub fn values_mut(&mut self) -> ValuesMut { ValuesMut { iter: self.map.values_mut(), } } } impl Default for Map { #[inline] fn default() -> Self { Map { map: MapImpl::new(), } } } impl Clone for Map { #[inline] fn clone(&self) -> Self { Map { map: self.map.clone(), } } } impl PartialEq for Map { #[inline] fn eq(&self, other: &Self) -> bool { if cfg!(feature = "preserve_order") { if self.len() != other.len() { return false; } self.iter() .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v)) } else { self.map.eq(&other.map) } } } /// Access an element of this map. Panics if the given key is not present in the /// map. /// /// ``` /// # use serde_json::Value; /// # /// # let val = &Value::String("".to_owned()); /// # let _ = /// match *val { /// Value::String(ref s) => Some(s.as_str()), /// Value::Array(ref arr) => arr[0].as_str(), /// Value::Object(ref map) => map["type"].as_str(), /// _ => None, /// } /// # ; /// ``` impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map where String: Borrow, Q: Ord + Eq + Hash, { type Output = Value; fn index(&self, index: &Q) -> &Value { self.map.index(index) } } /// Mutably access an element of this map. Panics if the given key is not /// present in the map. /// /// ``` /// # use serde_json::json; /// # /// # let mut map = serde_json::Map::new(); /// # map.insert("key".to_owned(), serde_json::Value::Null); /// # /// map["key"] = json!("value"); /// ``` impl<'a, Q: ?Sized> ops::IndexMut<&'a Q> for Map where String: Borrow, Q: Ord + Eq + Hash, { fn index_mut(&mut self, index: &Q) -> &mut Value { self.map.get_mut(index).expect("no entry found for key") } } impl Debug for Map { #[inline] fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.map.fmt(formatter) } } impl ser::Serialize for Map { #[inline] fn serialize(&self, serializer: S) -> Result where S: ser::Serializer, { use serde::ser::SerializeMap; let mut map = tri!(serializer.serialize_map(Some(self.len()))); for (k, v) in self { tri!(map.serialize_key(k)); tri!(map.serialize_value(v)); } map.end() } } impl<'de> de::Deserialize<'de> for Map { #[inline] fn deserialize(deserializer: D) -> Result where D: de::Deserializer<'de>, { struct Visitor; impl<'de> de::Visitor<'de> for Visitor { type Value = Map; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a map") } #[inline] fn visit_unit(self) -> Result where E: de::Error, { Ok(Map::new()) } #[inline] fn visit_map(self, mut visitor: V) -> Result where V: de::MapAccess<'de>, { let mut values = Map::new(); while let Some((key, value)) = tri!(visitor.next_entry()) { values.insert(key, value); } Ok(values) } } deserializer.deserialize_map(Visitor) } } impl FromIterator<(String, Value)> for Map { fn from_iter(iter: T) -> Self where T: IntoIterator, { Map { map: FromIterator::from_iter(iter), } } } impl Extend<(String, Value)> for Map { fn extend(&mut self, iter: T) where T: IntoIterator, { self.map.extend(iter); } } macro_rules! delegate_iterator { (($name:ident $($generics:tt)*) => $item:ty) => { impl $($generics)* Iterator for $name $($generics)* { type Item = $item; #[inline] fn next(&mut self) -> Option { self.iter.next() } #[inline] fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } impl $($generics)* DoubleEndedIterator for $name $($generics)* { #[inline] fn next_back(&mut self) -> Option { self.iter.next_back() } } impl $($generics)* ExactSizeIterator for $name $($generics)* { #[inline] fn len(&self) -> usize { self.iter.len() } } } } ////////////////////////////////////////////////////////////////////////////// /// A view into a single entry in a map, which may either be vacant or occupied. /// This enum is constructed from the [`entry`] method on [`Map`]. /// /// [`entry`]: struct.Map.html#method.entry /// [`Map`]: struct.Map.html pub enum Entry<'a> { /// A vacant Entry. Vacant(VacantEntry<'a>), /// An occupied Entry. Occupied(OccupiedEntry<'a>), } /// A vacant Entry. It is part of the [`Entry`] enum. /// /// [`Entry`]: enum.Entry.html pub struct VacantEntry<'a> { vacant: VacantEntryImpl<'a>, } /// An occupied Entry. It is part of the [`Entry`] enum. /// /// [`Entry`]: enum.Entry.html pub struct OccupiedEntry<'a> { occupied: OccupiedEntryImpl<'a>, } #[cfg(not(feature = "preserve_order"))] type VacantEntryImpl<'a> = btree_map::VacantEntry<'a, String, Value>; #[cfg(feature = "preserve_order")] type VacantEntryImpl<'a> = indexmap::map::VacantEntry<'a, String, Value>; #[cfg(not(feature = "preserve_order"))] type OccupiedEntryImpl<'a> = btree_map::OccupiedEntry<'a, String, Value>; #[cfg(feature = "preserve_order")] type OccupiedEntryImpl<'a> = indexmap::map::OccupiedEntry<'a, String, Value>; impl<'a> Entry<'a> { /// Returns a reference to this entry's key. /// /// # Examples /// /// ``` /// let mut map = serde_json::Map::new(); /// assert_eq!(map.entry("serde").key(), &"serde"); /// ``` pub fn key(&self) -> &String { match *self { Entry::Vacant(ref e) => e.key(), Entry::Occupied(ref e) => e.key(), } } /// Ensures a value is in the entry by inserting the default if empty, and /// returns a mutable reference to the value in the entry. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// let mut map = serde_json::Map::new(); /// map.entry("serde").or_insert(json!(12)); /// /// assert_eq!(map["serde"], 12); /// ``` pub fn or_insert(self, default: Value) -> &'a mut Value { match self { Entry::Vacant(entry) => entry.insert(default), Entry::Occupied(entry) => entry.into_mut(), } } /// Ensures a value is in the entry by inserting the result of the default /// function if empty, and returns a mutable reference to the value in the /// entry. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// let mut map = serde_json::Map::new(); /// map.entry("serde").or_insert_with(|| json!("hoho")); /// /// assert_eq!(map["serde"], "hoho".to_owned()); /// ``` pub fn or_insert_with(self, default: F) -> &'a mut Value where F: FnOnce() -> Value, { match self { Entry::Vacant(entry) => entry.insert(default()), Entry::Occupied(entry) => entry.into_mut(), } } } impl<'a> VacantEntry<'a> { /// Gets a reference to the key that would be used when inserting a value /// through the VacantEntry. /// /// # Examples /// /// ``` /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// /// match map.entry("serde") { /// Entry::Vacant(vacant) => { /// assert_eq!(vacant.key(), &"serde"); /// } /// Entry::Occupied(_) => unimplemented!(), /// } /// ``` #[inline] pub fn key(&self) -> &String { self.vacant.key() } /// Sets the value of the entry with the VacantEntry's key, and returns a /// mutable reference to it. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// /// match map.entry("serde") { /// Entry::Vacant(vacant) => { /// vacant.insert(json!("hoho")); /// } /// Entry::Occupied(_) => unimplemented!(), /// } /// ``` #[inline] pub fn insert(self, value: Value) -> &'a mut Value { self.vacant.insert(value) } } impl<'a> OccupiedEntry<'a> { /// Gets a reference to the key in the entry. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// map.insert("serde".to_owned(), json!(12)); /// /// match map.entry("serde") { /// Entry::Occupied(occupied) => { /// assert_eq!(occupied.key(), &"serde"); /// } /// Entry::Vacant(_) => unimplemented!(), /// } /// ``` #[inline] pub fn key(&self) -> &String { self.occupied.key() } /// Gets a reference to the value in the entry. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// map.insert("serde".to_owned(), json!(12)); /// /// match map.entry("serde") { /// Entry::Occupied(occupied) => { /// assert_eq!(occupied.get(), 12); /// } /// Entry::Vacant(_) => unimplemented!(), /// } /// ``` #[inline] pub fn get(&self) -> &Value { self.occupied.get() } /// Gets a mutable reference to the value in the entry. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// map.insert("serde".to_owned(), json!([1, 2, 3])); /// /// match map.entry("serde") { /// Entry::Occupied(mut occupied) => { /// occupied.get_mut().as_array_mut().unwrap().push(json!(4)); /// } /// Entry::Vacant(_) => unimplemented!(), /// } /// /// assert_eq!(map["serde"].as_array().unwrap().len(), 4); /// ``` #[inline] pub fn get_mut(&mut self) -> &mut Value { self.occupied.get_mut() } /// Converts the entry into a mutable reference to its value. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// map.insert("serde".to_owned(), json!([1, 2, 3])); /// /// match map.entry("serde") { /// Entry::Occupied(mut occupied) => { /// occupied.into_mut().as_array_mut().unwrap().push(json!(4)); /// } /// Entry::Vacant(_) => unimplemented!(), /// } /// /// assert_eq!(map["serde"].as_array().unwrap().len(), 4); /// ``` #[inline] pub fn into_mut(self) -> &'a mut Value { self.occupied.into_mut() } /// Sets the value of the entry with the `OccupiedEntry`'s key, and returns /// the entry's old value. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// map.insert("serde".to_owned(), json!(12)); /// /// match map.entry("serde") { /// Entry::Occupied(mut occupied) => { /// assert_eq!(occupied.insert(json!(13)), 12); /// assert_eq!(occupied.get(), 13); /// } /// Entry::Vacant(_) => unimplemented!(), /// } /// ``` #[inline] pub fn insert(&mut self, value: Value) -> Value { self.occupied.insert(value) } /// Takes the value of the entry out of the map, and returns it. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// use serde_json::map::Entry; /// /// let mut map = serde_json::Map::new(); /// map.insert("serde".to_owned(), json!(12)); /// /// match map.entry("serde") { /// Entry::Occupied(occupied) => { /// assert_eq!(occupied.remove(), 12); /// } /// Entry::Vacant(_) => unimplemented!(), /// } /// ``` #[inline] pub fn remove(self) -> Value { #[cfg(feature = "preserve_order")] return self.occupied.swap_remove(); #[cfg(not(feature = "preserve_order"))] return self.occupied.remove(); } } ////////////////////////////////////////////////////////////////////////////// impl<'a> IntoIterator for &'a Map { type Item = (&'a String, &'a Value); type IntoIter = Iter<'a>; #[inline] fn into_iter(self) -> Self::IntoIter { Iter { iter: self.map.iter(), } } } /// An iterator over a serde_json::Map's entries. pub struct Iter<'a> { iter: IterImpl<'a>, } #[cfg(not(feature = "preserve_order"))] type IterImpl<'a> = btree_map::Iter<'a, String, Value>; #[cfg(feature = "preserve_order")] type IterImpl<'a> = indexmap::map::Iter<'a, String, Value>; delegate_iterator!((Iter<'a>) => (&'a String, &'a Value)); ////////////////////////////////////////////////////////////////////////////// impl<'a> IntoIterator for &'a mut Map { type Item = (&'a String, &'a mut Value); type IntoIter = IterMut<'a>; #[inline] fn into_iter(self) -> Self::IntoIter { IterMut { iter: self.map.iter_mut(), } } } /// A mutable iterator over a serde_json::Map's entries. pub struct IterMut<'a> { iter: IterMutImpl<'a>, } #[cfg(not(feature = "preserve_order"))] type IterMutImpl<'a> = btree_map::IterMut<'a, String, Value>; #[cfg(feature = "preserve_order")] type IterMutImpl<'a> = indexmap::map::IterMut<'a, String, Value>; delegate_iterator!((IterMut<'a>) => (&'a String, &'a mut Value)); ////////////////////////////////////////////////////////////////////////////// impl IntoIterator for Map { type Item = (String, Value); type IntoIter = IntoIter; #[inline] fn into_iter(self) -> Self::IntoIter { IntoIter { iter: self.map.into_iter(), } } } /// An owning iterator over a serde_json::Map's entries. pub struct IntoIter { iter: IntoIterImpl, } #[cfg(not(feature = "preserve_order"))] type IntoIterImpl = btree_map::IntoIter; #[cfg(feature = "preserve_order")] type IntoIterImpl = indexmap::map::IntoIter; delegate_iterator!((IntoIter) => (String, Value)); ////////////////////////////////////////////////////////////////////////////// /// An iterator over a serde_json::Map's keys. pub struct Keys<'a> { iter: KeysImpl<'a>, } #[cfg(not(feature = "preserve_order"))] type KeysImpl<'a> = btree_map::Keys<'a, String, Value>; #[cfg(feature = "preserve_order")] type KeysImpl<'a> = indexmap::map::Keys<'a, String, Value>; delegate_iterator!((Keys<'a>) => &'a String); ////////////////////////////////////////////////////////////////////////////// /// An iterator over a serde_json::Map's values. pub struct Values<'a> { iter: ValuesImpl<'a>, } #[cfg(not(feature = "preserve_order"))] type ValuesImpl<'a> = btree_map::Values<'a, String, Value>; #[cfg(feature = "preserve_order")] type ValuesImpl<'a> = indexmap::map::Values<'a, String, Value>; delegate_iterator!((Values<'a>) => &'a Value); ////////////////////////////////////////////////////////////////////////////// /// A mutable iterator over a serde_json::Map's values. pub struct ValuesMut<'a> { iter: ValuesMutImpl<'a>, } #[cfg(not(feature = "preserve_order"))] type ValuesMutImpl<'a> = btree_map::ValuesMut<'a, String, Value>; #[cfg(feature = "preserve_order")] type ValuesMutImpl<'a> = indexmap::map::ValuesMut<'a, String, Value>; delegate_iterator!((ValuesMut<'a>) => &'a mut Value); serde_json-1.0.45/src/number.rs010064400017500001750000000520431361214240200146010ustar0000000000000000use crate::de::ParserNumber; use crate::error::Error; use crate::lib::*; use serde::de::{self, Unexpected, Visitor}; use serde::{ forward_to_deserialize_any, serde_if_integer128, Deserialize, Deserializer, Serialize, Serializer, }; #[cfg(feature = "arbitrary_precision")] use crate::error::ErrorCode; #[cfg(feature = "arbitrary_precision")] use serde::de::{IntoDeserializer, MapAccess}; #[cfg(feature = "arbitrary_precision")] pub(crate) const TOKEN: &str = "$serde_json::private::Number"; /// Represents a JSON number, whether integer or floating point. #[derive(Clone, PartialEq)] pub struct Number { n: N, } #[cfg(not(feature = "arbitrary_precision"))] #[derive(Copy, Clone, PartialEq)] enum N { PosInt(u64), /// Always less than zero. NegInt(i64), /// Always finite. Float(f64), } #[cfg(feature = "arbitrary_precision")] type N = String; impl Number { /// Returns true if the `Number` is an integer between `i64::MIN` and /// `i64::MAX`. /// /// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to /// return the integer value. /// /// ``` /// # use serde_json::json; /// # /// let big = i64::max_value() as u64 + 10; /// let v = json!({ "a": 64, "b": big, "c": 256.0 }); /// /// assert!(v["a"].is_i64()); /// /// // Greater than i64::MAX. /// assert!(!v["b"].is_i64()); /// /// // Numbers with a decimal point are not considered integers. /// assert!(!v["c"].is_i64()); /// ``` #[inline] pub fn is_i64(&self) -> bool { #[cfg(not(feature = "arbitrary_precision"))] match self.n { N::PosInt(v) => v <= i64::max_value() as u64, N::NegInt(_) => true, N::Float(_) => false, } #[cfg(feature = "arbitrary_precision")] self.as_i64().is_some() } /// Returns true if the `Number` is an integer between zero and `u64::MAX`. /// /// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to /// return the integer value. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 64, "b": -64, "c": 256.0 }); /// /// assert!(v["a"].is_u64()); /// /// // Negative integer. /// assert!(!v["b"].is_u64()); /// /// // Numbers with a decimal point are not considered integers. /// assert!(!v["c"].is_u64()); /// ``` #[inline] pub fn is_u64(&self) -> bool { #[cfg(not(feature = "arbitrary_precision"))] match self.n { N::PosInt(_) => true, N::NegInt(_) | N::Float(_) => false, } #[cfg(feature = "arbitrary_precision")] self.as_u64().is_some() } /// Returns true if the `Number` can be represented by f64. /// /// For any Number on which `is_f64` returns true, `as_f64` is guaranteed to /// return the floating point value. /// /// Currently this function returns true if and only if both `is_i64` and /// `is_u64` return false but this is not a guarantee in the future. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 256.0, "b": 64, "c": -64 }); /// /// assert!(v["a"].is_f64()); /// /// // Integers. /// assert!(!v["b"].is_f64()); /// assert!(!v["c"].is_f64()); /// ``` #[inline] pub fn is_f64(&self) -> bool { #[cfg(not(feature = "arbitrary_precision"))] match self.n { N::Float(_) => true, N::PosInt(_) | N::NegInt(_) => false, } #[cfg(feature = "arbitrary_precision")] { for c in self.n.chars() { if c == '.' || c == 'e' || c == 'E' { return self.n.parse::().ok().map_or(false, |f| f.is_finite()); } } false } } /// If the `Number` is an integer, represent it as i64 if possible. Returns /// None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let big = i64::max_value() as u64 + 10; /// let v = json!({ "a": 64, "b": big, "c": 256.0 }); /// /// assert_eq!(v["a"].as_i64(), Some(64)); /// assert_eq!(v["b"].as_i64(), None); /// assert_eq!(v["c"].as_i64(), None); /// ``` #[inline] pub fn as_i64(&self) -> Option { #[cfg(not(feature = "arbitrary_precision"))] match self.n { N::PosInt(n) => { if n <= i64::max_value() as u64 { Some(n as i64) } else { None } } N::NegInt(n) => Some(n), N::Float(_) => None, } #[cfg(feature = "arbitrary_precision")] self.n.parse().ok() } /// If the `Number` is an integer, represent it as u64 if possible. Returns /// None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 64, "b": -64, "c": 256.0 }); /// /// assert_eq!(v["a"].as_u64(), Some(64)); /// assert_eq!(v["b"].as_u64(), None); /// assert_eq!(v["c"].as_u64(), None); /// ``` #[inline] pub fn as_u64(&self) -> Option { #[cfg(not(feature = "arbitrary_precision"))] match self.n { N::PosInt(n) => Some(n), N::NegInt(_) | N::Float(_) => None, } #[cfg(feature = "arbitrary_precision")] self.n.parse().ok() } /// Represents the number as f64 if possible. Returns None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 256.0, "b": 64, "c": -64 }); /// /// assert_eq!(v["a"].as_f64(), Some(256.0)); /// assert_eq!(v["b"].as_f64(), Some(64.0)); /// assert_eq!(v["c"].as_f64(), Some(-64.0)); /// ``` #[inline] pub fn as_f64(&self) -> Option { #[cfg(not(feature = "arbitrary_precision"))] match self.n { N::PosInt(n) => Some(n as f64), N::NegInt(n) => Some(n as f64), N::Float(n) => Some(n), } #[cfg(feature = "arbitrary_precision")] self.n.parse().ok() } /// Converts a finite `f64` to a `Number`. Infinite or NaN values are not JSON /// numbers. /// /// ``` /// # use std::f64; /// # /// # use serde_json::Number; /// # /// assert!(Number::from_f64(256.0).is_some()); /// /// assert!(Number::from_f64(f64::NAN).is_none()); /// ``` #[inline] pub fn from_f64(f: f64) -> Option { if f.is_finite() { let n = { #[cfg(not(feature = "arbitrary_precision"))] { N::Float(f) } #[cfg(feature = "arbitrary_precision")] { ryu::Buffer::new().format_finite(f).to_owned() } }; Some(Number { n: n }) } else { None } } #[cfg(feature = "arbitrary_precision")] /// Not public API. Only tests use this. #[doc(hidden)] #[inline] pub fn from_string_unchecked(n: String) -> Self { Number { n: n } } } impl fmt::Display for Number { #[cfg(not(feature = "arbitrary_precision"))] fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { match self.n { N::PosInt(u) => Display::fmt(&u, formatter), N::NegInt(i) => Display::fmt(&i, formatter), N::Float(f) => Display::fmt(&f, formatter), } } #[cfg(feature = "arbitrary_precision")] fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { Display::fmt(&self.n, formatter) } } impl Debug for Number { #[cfg(not(feature = "arbitrary_precision"))] fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let mut debug = formatter.debug_tuple("Number"); match self.n { N::PosInt(i) => { debug.field(&i); } N::NegInt(i) => { debug.field(&i); } N::Float(f) => { debug.field(&f); } } debug.finish() } #[cfg(feature = "arbitrary_precision")] fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { write!(formatter, "Number({})", &self.n) } } impl Serialize for Number { #[cfg(not(feature = "arbitrary_precision"))] #[inline] fn serialize(&self, serializer: S) -> Result where S: Serializer, { match self.n { N::PosInt(u) => serializer.serialize_u64(u), N::NegInt(i) => serializer.serialize_i64(i), N::Float(f) => serializer.serialize_f64(f), } } #[cfg(feature = "arbitrary_precision")] #[inline] fn serialize(&self, serializer: S) -> Result where S: Serializer, { use serde::ser::SerializeStruct; let mut s = serializer.serialize_struct(TOKEN, 1)?; s.serialize_field(TOKEN, &self.n)?; s.end() } } impl<'de> Deserialize<'de> for Number { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct NumberVisitor; impl<'de> Visitor<'de> for NumberVisitor { type Value = Number; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a JSON number") } #[inline] fn visit_i64(self, value: i64) -> Result { Ok(value.into()) } #[inline] fn visit_u64(self, value: u64) -> Result { Ok(value.into()) } #[inline] fn visit_f64(self, value: f64) -> Result where E: de::Error, { Number::from_f64(value).ok_or_else(|| de::Error::custom("not a JSON number")) } #[cfg(feature = "arbitrary_precision")] #[inline] fn visit_map(self, mut visitor: V) -> Result where V: de::MapAccess<'de>, { let value = visitor.next_key::()?; if value.is_none() { return Err(de::Error::invalid_type(Unexpected::Map, &self)); } let v: NumberFromString = visitor.next_value()?; Ok(v.value) } } deserializer.deserialize_any(NumberVisitor) } } #[cfg(feature = "arbitrary_precision")] struct NumberKey; #[cfg(feature = "arbitrary_precision")] impl<'de> de::Deserialize<'de> for NumberKey { fn deserialize(deserializer: D) -> Result where D: de::Deserializer<'de>, { struct FieldVisitor; impl<'de> de::Visitor<'de> for FieldVisitor { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a valid number field") } fn visit_str(self, s: &str) -> Result<(), E> where E: de::Error, { if s == TOKEN { Ok(()) } else { Err(de::Error::custom("expected field with custom name")) } } } deserializer.deserialize_identifier(FieldVisitor)?; Ok(NumberKey) } } #[cfg(feature = "arbitrary_precision")] pub struct NumberFromString { pub value: Number, } #[cfg(feature = "arbitrary_precision")] impl<'de> de::Deserialize<'de> for NumberFromString { fn deserialize(deserializer: D) -> Result where D: de::Deserializer<'de>, { struct Visitor; impl<'de> de::Visitor<'de> for Visitor { type Value = NumberFromString; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("string containing a number") } fn visit_str(self, s: &str) -> Result where E: de::Error, { let n = tri!(s.parse().map_err(de::Error::custom)); Ok(NumberFromString { value: n }) } } deserializer.deserialize_str(Visitor) } } #[cfg(feature = "arbitrary_precision")] fn invalid_number() -> Error { Error::syntax(ErrorCode::InvalidNumber, 0, 0) } macro_rules! deserialize_any { (@expand [$($num_string:tt)*]) => { #[cfg(not(feature = "arbitrary_precision"))] #[inline] fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de>, { match self.n { N::PosInt(u) => visitor.visit_u64(u), N::NegInt(i) => visitor.visit_i64(i), N::Float(f) => visitor.visit_f64(f), } } #[cfg(feature = "arbitrary_precision")] #[inline] fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de> { if let Some(u) = self.as_u64() { return visitor.visit_u64(u); } else if let Some(i) = self.as_i64() { return visitor.visit_i64(i); } else if let Some(f) = self.as_f64() { if ryu::Buffer::new().format_finite(f) == self.n || f.to_string() == self.n { return visitor.visit_f64(f); } } visitor.visit_map(NumberDeserializer { number: Some(self.$($num_string)*), }) } }; (owned) => { deserialize_any!(@expand [n]); }; (ref) => { deserialize_any!(@expand [n.clone()]); }; } macro_rules! deserialize_number { ($deserialize:ident => $visit:ident) => { #[cfg(not(feature = "arbitrary_precision"))] fn $deserialize(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_any(visitor) } #[cfg(feature = "arbitrary_precision")] fn $deserialize(self, visitor: V) -> Result where V: de::Visitor<'de>, { visitor.$visit(self.n.parse().map_err(|_| invalid_number())?) } } } impl<'de> Deserializer<'de> for Number { type Error = Error; deserialize_any!(owned); deserialize_number!(deserialize_i8 => visit_i8); deserialize_number!(deserialize_i16 => visit_i16); deserialize_number!(deserialize_i32 => visit_i32); deserialize_number!(deserialize_i64 => visit_i64); deserialize_number!(deserialize_u8 => visit_u8); deserialize_number!(deserialize_u16 => visit_u16); deserialize_number!(deserialize_u32 => visit_u32); deserialize_number!(deserialize_u64 => visit_u64); deserialize_number!(deserialize_f32 => visit_f32); deserialize_number!(deserialize_f64 => visit_f64); serde_if_integer128! { deserialize_number!(deserialize_i128 => visit_i128); deserialize_number!(deserialize_u128 => visit_u128); } forward_to_deserialize_any! { bool 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> Deserializer<'de> for &'a Number { type Error = Error; deserialize_any!(ref); deserialize_number!(deserialize_i8 => visit_i8); deserialize_number!(deserialize_i16 => visit_i16); deserialize_number!(deserialize_i32 => visit_i32); deserialize_number!(deserialize_i64 => visit_i64); deserialize_number!(deserialize_u8 => visit_u8); deserialize_number!(deserialize_u16 => visit_u16); deserialize_number!(deserialize_u32 => visit_u32); deserialize_number!(deserialize_u64 => visit_u64); deserialize_number!(deserialize_f32 => visit_f32); deserialize_number!(deserialize_f64 => visit_f64); serde_if_integer128! { deserialize_number!(deserialize_i128 => visit_i128); deserialize_number!(deserialize_u128 => visit_u128); } forward_to_deserialize_any! { bool char str string bytes byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct map struct enum identifier ignored_any } } #[cfg(feature = "arbitrary_precision")] pub(crate) struct NumberDeserializer { pub number: Option, } #[cfg(feature = "arbitrary_precision")] impl<'de> MapAccess<'de> for NumberDeserializer { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result, Error> where K: de::DeserializeSeed<'de>, { if self.number.is_none() { return Ok(None); } seed.deserialize(NumberFieldDeserializer).map(Some) } fn next_value_seed(&mut self, seed: V) -> Result where V: de::DeserializeSeed<'de>, { seed.deserialize(self.number.take().unwrap().into_deserializer()) } } #[cfg(feature = "arbitrary_precision")] struct NumberFieldDeserializer; #[cfg(feature = "arbitrary_precision")] impl<'de> Deserializer<'de> for NumberFieldDeserializer { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { visitor.visit_borrowed_str(TOKEN) } forward_to_deserialize_any! { bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq bytes byte_buf map struct option unit newtype_struct ignored_any unit_struct tuple_struct tuple enum identifier } } impl From for Number { fn from(value: ParserNumber) -> Self { let n = match value { ParserNumber::F64(f) => { #[cfg(not(feature = "arbitrary_precision"))] { N::Float(f) } #[cfg(feature = "arbitrary_precision")] { f.to_string() } } ParserNumber::U64(u) => { #[cfg(not(feature = "arbitrary_precision"))] { N::PosInt(u) } #[cfg(feature = "arbitrary_precision")] { u.to_string() } } ParserNumber::I64(i) => { #[cfg(not(feature = "arbitrary_precision"))] { N::NegInt(i) } #[cfg(feature = "arbitrary_precision")] { i.to_string() } } #[cfg(feature = "arbitrary_precision")] ParserNumber::String(s) => s, }; Number { n: n } } } macro_rules! impl_from_unsigned { ( $($ty:ty),* ) => { $( impl From<$ty> for Number { #[inline] fn from(u: $ty) -> Self { let n = { #[cfg(not(feature = "arbitrary_precision"))] { N::PosInt(u as u64) } #[cfg(feature = "arbitrary_precision")] { itoa::Buffer::new().format(u).to_owned() } }; Number { n: n } } } )* }; } macro_rules! impl_from_signed { ( $($ty:ty),* ) => { $( impl From<$ty> for Number { #[inline] fn from(i: $ty) -> Self { let n = { #[cfg(not(feature = "arbitrary_precision"))] { if i < 0 { N::NegInt(i as i64) } else { N::PosInt(i as u64) } } #[cfg(feature = "arbitrary_precision")] { itoa::Buffer::new().format(i).to_owned() } }; Number { n: n } } } )* }; } impl_from_unsigned!(u8, u16, u32, u64, usize); impl_from_signed!(i8, i16, i32, i64, isize); #[cfg(feature = "arbitrary_precision")] serde_if_integer128! { impl From for Number { fn from(i: i128) -> Self { Number { n: i.to_string() } } } impl From for Number { fn from(u: u128) -> Self { Number { n: u.to_string() } } } } impl Number { #[cfg(not(feature = "arbitrary_precision"))] #[cold] pub(crate) fn unexpected(&self) -> Unexpected { match self.n { N::PosInt(u) => Unexpected::Unsigned(u), N::NegInt(i) => Unexpected::Signed(i), N::Float(f) => Unexpected::Float(f), } } #[cfg(feature = "arbitrary_precision")] #[cold] pub(crate) fn unexpected(&self) -> Unexpected { Unexpected::Other("number") } } serde_json-1.0.45/src/raw.rs010064400017500001750000000301021361214160200140730ustar0000000000000000use crate::error::Error; use crate::lib::*; use serde::de::value::BorrowedStrDeserializer; use serde::de::{ self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected, Visitor, }; use serde::forward_to_deserialize_any; use serde::ser::{Serialize, SerializeStruct, Serializer}; /// Reference to a range of bytes encompassing a single valid JSON value in the /// input data. /// /// A `RawValue` can be used to defer parsing parts of a payload until later, /// or to avoid parsing it at all in the case that part of the payload just /// needs to be transferred verbatim into a different output object. /// /// When serializing, a value of this type will retain its original formatting /// and will not be minified or pretty-printed. /// /// # Note /// /// `RawValue` is only available if serde\_json is built with the `"raw_value"` /// feature. /// /// ```toml /// [dependencies] /// serde_json = { version = "1.0", features = ["raw_value"] } /// ``` /// /// # Example /// /// ``` /// use serde::{Deserialize, Serialize}; /// use serde_json::{Result, value::RawValue}; /// /// #[derive(Deserialize)] /// struct Input<'a> { /// code: u32, /// #[serde(borrow)] /// payload: &'a RawValue, /// } /// /// #[derive(Serialize)] /// struct Output<'a> { /// info: (u32, &'a RawValue), /// } /// /// // Efficiently rearrange JSON input containing separate "code" and "payload" /// // keys into a single "info" key holding an array of code and payload. /// // /// // This could be done equivalently using serde_json::Value as the type for /// // payload, but &RawValue will perform better because it does not require /// // memory allocation. The correct range of bytes is borrowed from the input /// // data and pasted verbatim into the output. /// fn rearrange(input: &str) -> Result { /// let input: Input = serde_json::from_str(input)?; /// /// let output = Output { /// info: (input.code, input.payload), /// }; /// /// serde_json::to_string(&output) /// } /// /// fn main() -> Result<()> { /// let out = rearrange(r#" {"code": 200, "payload": {}} "#)?; /// /// assert_eq!(out, r#"{"info":[200,{}]}"#); /// /// Ok(()) /// } /// ``` /// /// # Ownership /// /// The typical usage of `RawValue` will be in the borrowed form: /// /// ``` /// # use serde::Deserialize; /// # use serde_json::value::RawValue; /// # /// #[derive(Deserialize)] /// struct SomeStruct<'a> { /// #[serde(borrow)] /// raw_value: &'a RawValue, /// } /// ``` /// /// The borrowed form is suitable when deserializing through /// [`serde_json::from_str`] and [`serde_json::from_slice`] which support /// borrowing from the input data without memory allocation. /// /// When deserializing through [`serde_json::from_reader`] you will need to use /// the boxed form of `RawValue` instead. This is almost as efficient but /// involves buffering the raw value from the I/O stream into memory. /// /// [`serde_json::from_str`]: ../fn.from_str.html /// [`serde_json::from_slice`]: ../fn.from_slice.html /// [`serde_json::from_reader`]: ../fn.from_reader.html /// /// ``` /// # use serde::Deserialize; /// # use serde_json::value::RawValue; /// # /// #[derive(Deserialize)] /// struct SomeStruct { /// raw_value: Box, /// } /// ``` #[repr(C)] pub struct RawValue { json: str, } impl RawValue { fn from_borrowed(json: &str) -> &Self { unsafe { mem::transmute::<&str, &RawValue>(json) } } fn from_owned(json: Box) -> Box { unsafe { mem::transmute::, Box>(json) } } } impl Clone for Box { fn clone(&self) -> Self { (**self).to_owned() } } impl ToOwned for RawValue { type Owned = Box; fn to_owned(&self) -> Self::Owned { RawValue::from_owned(self.json.to_owned().into_boxed_str()) } } impl Default for Box { fn default() -> Self { RawValue::from_borrowed("null").to_owned() } } impl Debug for RawValue { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter .debug_tuple("RawValue") .field(&format_args!("{}", &self.json)) .finish() } } impl Display for RawValue { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(&self.json) } } impl RawValue { /// Convert an owned `String` of JSON data to an owned `RawValue`. /// /// This function is equivalent to `serde_json::from_str::>` /// except that we avoid an allocation and memcpy if both of the following /// are true: /// /// - the input has no leading or trailing whitespace, and /// - the input has capacity equal to its length. pub fn from_string(json: String) -> Result, Error> { { let borrowed = crate::from_str::<&Self>(&json)?; if borrowed.json.len() < json.len() { return Ok(borrowed.to_owned()); } } Ok(Self::from_owned(json.into_boxed_str())) } /// Access the JSON text underlying a raw value. /// /// # Example /// /// ``` /// use serde::Deserialize; /// use serde_json::{Result, value::RawValue}; /// /// #[derive(Deserialize)] /// struct Response<'a> { /// code: u32, /// #[serde(borrow)] /// payload: &'a RawValue, /// } /// /// fn process(input: &str) -> Result<()> { /// let response: Response = serde_json::from_str(input)?; /// /// let payload = response.payload.get(); /// if payload.starts_with('{') { /// // handle a payload which is a JSON map /// } else { /// // handle any other type /// } /// /// Ok(()) /// } /// /// fn main() -> Result<()> { /// process(r#" {"code": 200, "payload": {}} "#)?; /// Ok(()) /// } /// ``` pub fn get(&self) -> &str { &self.json } } pub const TOKEN: &str = "$serde_json::private::RawValue"; impl Serialize for RawValue { fn serialize(&self, serializer: S) -> Result where S: Serializer, { let mut s = serializer.serialize_struct(TOKEN, 1)?; s.serialize_field(TOKEN, &self.json)?; s.end() } } impl<'de: 'a, 'a> Deserialize<'de> for &'a RawValue { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct ReferenceVisitor; impl<'de> Visitor<'de> for ReferenceVisitor { type Value = &'de RawValue; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { write!(formatter, "any valid JSON value") } fn visit_map(self, mut visitor: V) -> Result where V: MapAccess<'de>, { let value = visitor.next_key::()?; if value.is_none() { return Err(de::Error::invalid_type(Unexpected::Map, &self)); } visitor.next_value_seed(ReferenceFromString) } } deserializer.deserialize_newtype_struct(TOKEN, ReferenceVisitor) } } impl<'de> Deserialize<'de> for Box { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct BoxedVisitor; impl<'de> Visitor<'de> for BoxedVisitor { type Value = Box; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { write!(formatter, "any valid JSON value") } fn visit_map(self, mut visitor: V) -> Result where V: MapAccess<'de>, { let value = visitor.next_key::()?; if value.is_none() { return Err(de::Error::invalid_type(Unexpected::Map, &self)); } visitor.next_value_seed(BoxedFromString) } } deserializer.deserialize_newtype_struct(TOKEN, BoxedVisitor) } } struct RawKey; impl<'de> Deserialize<'de> for RawKey { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("raw value") } fn visit_str(self, s: &str) -> Result<(), E> where E: de::Error, { if s == TOKEN { Ok(()) } else { Err(de::Error::custom("unexpected raw value")) } } } deserializer.deserialize_identifier(FieldVisitor)?; Ok(RawKey) } } pub struct ReferenceFromString; impl<'de> DeserializeSeed<'de> for ReferenceFromString { type Value = &'de RawValue; fn deserialize(self, deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_str(self) } } impl<'de> Visitor<'de> for ReferenceFromString { type Value = &'de RawValue; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("raw value") } fn visit_borrowed_str(self, s: &'de str) -> Result where E: de::Error, { Ok(RawValue::from_borrowed(s)) } } pub struct BoxedFromString; impl<'de> DeserializeSeed<'de> for BoxedFromString { type Value = Box; fn deserialize(self, deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_str(self) } } impl<'de> Visitor<'de> for BoxedFromString { type Value = Box; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("raw value") } fn visit_str(self, s: &str) -> Result where E: de::Error, { self.visit_string(s.to_owned()) } fn visit_string(self, s: String) -> Result where E: de::Error, { Ok(RawValue::from_owned(s.into_boxed_str())) } } struct RawKeyDeserializer; impl<'de> Deserializer<'de> for RawKeyDeserializer { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { visitor.visit_borrowed_str(TOKEN) } forward_to_deserialize_any! { bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq bytes byte_buf map struct option unit newtype_struct ignored_any unit_struct tuple_struct tuple enum identifier } } pub struct OwnedRawDeserializer { pub raw_value: Option, } impl<'de> MapAccess<'de> for OwnedRawDeserializer { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result, Error> where K: de::DeserializeSeed<'de>, { if self.raw_value.is_none() { return Ok(None); } seed.deserialize(RawKeyDeserializer).map(Some) } fn next_value_seed(&mut self, seed: V) -> Result where V: de::DeserializeSeed<'de>, { seed.deserialize(self.raw_value.take().unwrap().into_deserializer()) } } pub struct BorrowedRawDeserializer<'de> { pub raw_value: Option<&'de str>, } impl<'de> MapAccess<'de> for BorrowedRawDeserializer<'de> { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result, Error> where K: de::DeserializeSeed<'de>, { if self.raw_value.is_none() { return Ok(None); } seed.deserialize(RawKeyDeserializer).map(Some) } fn next_value_seed(&mut self, seed: V) -> Result where V: de::DeserializeSeed<'de>, { seed.deserialize(BorrowedStrDeserializer::new(self.raw_value.take().unwrap())) } } serde_json-1.0.45/src/read.rs010064400017500001750000000656641361214344600142520ustar0000000000000000use crate::error::{Error, ErrorCode, Result}; use crate::lib::ops::Deref; use crate::lib::*; #[cfg(feature = "std")] use crate::io; #[cfg(feature = "std")] use crate::iter::LineColIterator; #[cfg(feature = "raw_value")] use crate::raw::BorrowedRawDeserializer; #[cfg(all(feature = "raw_value", feature = "std"))] use crate::raw::OwnedRawDeserializer; #[cfg(feature = "raw_value")] use serde::de::Visitor; /// Trait used by the deserializer for iterating over input. This is manually /// "specialized" for iterating over &[u8]. Once feature(specialization) is /// stable we can use actual specialization. /// /// This trait is sealed and cannot be implemented for types outside of /// `serde_json`. pub trait Read<'de>: private::Sealed { #[doc(hidden)] fn next(&mut self) -> Result>; #[doc(hidden)] fn peek(&mut self) -> Result>; /// Only valid after a call to peek(). Discards the peeked byte. #[doc(hidden)] fn discard(&mut self); /// Position of the most recent call to next(). /// /// The most recent call was probably next() and not peek(), but this method /// should try to return a sensible result if the most recent call was /// actually peek() because we don't always know. /// /// Only called in case of an error, so performance is not important. #[doc(hidden)] fn position(&self) -> Position; /// Position of the most recent call to peek(). /// /// The most recent call was probably peek() and not next(), but this method /// should try to return a sensible result if the most recent call was /// actually next() because we don't always know. /// /// Only called in case of an error, so performance is not important. #[doc(hidden)] fn peek_position(&self) -> Position; /// Offset from the beginning of the input to the next byte that would be /// returned by next() or peek(). #[doc(hidden)] fn byte_offset(&self) -> usize; /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped /// string until the next quotation mark using the given scratch space if /// necessary. The scratch space is initially empty. #[doc(hidden)] fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result>; /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped /// string until the next quotation mark using the given scratch space if /// necessary. The scratch space is initially empty. /// /// This function returns the raw bytes in the string with escape sequences /// expanded but without performing unicode validation. #[doc(hidden)] fn parse_str_raw<'s>( &'s mut self, scratch: &'s mut Vec, ) -> Result>; /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped /// string until the next quotation mark but discards the data. #[doc(hidden)] fn ignore_str(&mut self) -> Result<()>; /// Assumes the previous byte was a hex escape sequnce ('\u') in a string. /// Parses next hexadecimal sequence. #[doc(hidden)] fn decode_hex_escape(&mut self) -> Result; /// Switch raw buffering mode on. /// /// This is used when deserializing `RawValue`. #[cfg(feature = "raw_value")] #[doc(hidden)] fn begin_raw_buffering(&mut self); /// Switch raw buffering mode off and provides the raw buffered data to the /// given visitor. #[cfg(feature = "raw_value")] #[doc(hidden)] fn end_raw_buffering(&mut self, visitor: V) -> Result where V: Visitor<'de>; } pub struct Position { pub line: usize, pub column: usize, } pub enum Reference<'b, 'c, T: ?Sized + 'static> { Borrowed(&'b T), Copied(&'c T), } impl<'b, 'c, T: ?Sized + 'static> Deref for Reference<'b, 'c, T> { type Target = T; fn deref(&self) -> &Self::Target { match *self { Reference::Borrowed(b) => b, Reference::Copied(c) => c, } } } /// JSON input source that reads from a std::io input stream. #[cfg(feature = "std")] pub struct IoRead where R: io::Read, { iter: LineColIterator>, /// Temporary storage of peeked byte. ch: Option, #[cfg(feature = "raw_value")] raw_buffer: Option>, } /// JSON input source that reads from a slice of bytes. // // This is more efficient than other iterators because peek() can be read-only // and we can compute line/col position only if an error happens. pub struct SliceRead<'a> { slice: &'a [u8], /// Index of the *next* byte that will be returned by next() or peek(). index: usize, #[cfg(feature = "raw_value")] raw_buffering_start_index: usize, } /// JSON input source that reads from a UTF-8 string. // // Able to elide UTF-8 checks by assuming that the input is valid UTF-8. pub struct StrRead<'a> { delegate: SliceRead<'a>, #[cfg(feature = "raw_value")] data: &'a str, } // Prevent users from implementing the Read trait. mod private { pub trait Sealed {} } ////////////////////////////////////////////////////////////////////////////// #[cfg(feature = "std")] impl IoRead where R: io::Read, { /// Create a JSON input source to read from a std::io input stream. pub fn new(reader: R) -> Self { #[cfg(not(feature = "raw_value"))] { IoRead { iter: LineColIterator::new(reader.bytes()), ch: None, } } #[cfg(feature = "raw_value")] { IoRead { iter: LineColIterator::new(reader.bytes()), ch: None, raw_buffer: None, } } } } #[cfg(feature = "std")] impl private::Sealed for IoRead where R: io::Read {} #[cfg(feature = "std")] impl IoRead where R: io::Read, { fn parse_str_bytes<'s, T, F>( &'s mut self, scratch: &'s mut Vec, validate: bool, result: F, ) -> Result where T: 's, F: FnOnce(&'s Self, &'s [u8]) -> Result, { loop { let ch = tri!(next_or_eof(self)); if !ESCAPE[ch as usize] { scratch.push(ch); continue; } match ch { b'"' => { return result(self, scratch); } b'\\' => { tri!(parse_escape(self, scratch)); } _ => { if validate { return error(self, ErrorCode::ControlCharacterWhileParsingString); } scratch.push(ch); } } } } } #[cfg(feature = "std")] impl<'de, R> Read<'de> for IoRead where R: io::Read, { #[inline] fn next(&mut self) -> Result> { match self.ch.take() { Some(ch) => { #[cfg(feature = "raw_value")] { if let Some(ref mut buf) = self.raw_buffer { buf.push(ch); } } Ok(Some(ch)) } None => match self.iter.next() { Some(Err(err)) => Err(Error::io(err)), Some(Ok(ch)) => { #[cfg(feature = "raw_value")] { if let Some(ref mut buf) = self.raw_buffer { buf.push(ch); } } Ok(Some(ch)) } None => Ok(None), }, } } #[inline] fn peek(&mut self) -> Result> { match self.ch { Some(ch) => Ok(Some(ch)), None => match self.iter.next() { Some(Err(err)) => Err(Error::io(err)), Some(Ok(ch)) => { self.ch = Some(ch); Ok(self.ch) } None => Ok(None), }, } } #[cfg(not(feature = "raw_value"))] #[inline] fn discard(&mut self) { self.ch = None; } #[cfg(feature = "raw_value")] fn discard(&mut self) { if let Some(ch) = self.ch.take() { if let Some(ref mut buf) = self.raw_buffer { buf.push(ch); } } } fn position(&self) -> Position { Position { line: self.iter.line(), column: self.iter.col(), } } fn peek_position(&self) -> Position { // The LineColIterator updates its position during peek() so it has the // right one here. self.position() } fn byte_offset(&self) -> usize { match self.ch { Some(_) => self.iter.byte_offset() - 1, None => self.iter.byte_offset(), } } fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { self.parse_str_bytes(scratch, true, as_str) .map(Reference::Copied) } fn parse_str_raw<'s>( &'s mut self, scratch: &'s mut Vec, ) -> Result> { self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)) .map(Reference::Copied) } fn ignore_str(&mut self) -> Result<()> { loop { let ch = tri!(next_or_eof(self)); if !ESCAPE[ch as usize] { continue; } match ch { b'"' => { return Ok(()); } b'\\' => { tri!(ignore_escape(self)); } _ => { return error(self, ErrorCode::ControlCharacterWhileParsingString); } } } } fn decode_hex_escape(&mut self) -> Result { let mut n = 0; for _ in 0..4 { match decode_hex_val(tri!(next_or_eof(self))) { None => return error(self, ErrorCode::InvalidEscape), Some(val) => { n = (n << 4) + val; } } } Ok(n) } #[cfg(feature = "raw_value")] fn begin_raw_buffering(&mut self) { self.raw_buffer = Some(Vec::new()); } #[cfg(feature = "raw_value")] fn end_raw_buffering(&mut self, visitor: V) -> Result where V: Visitor<'de>, { let raw = self.raw_buffer.take().unwrap(); let raw = String::from_utf8(raw).unwrap(); visitor.visit_map(OwnedRawDeserializer { raw_value: Some(raw), }) } } ////////////////////////////////////////////////////////////////////////////// impl<'a> SliceRead<'a> { /// Create a JSON input source to read from a slice of bytes. pub fn new(slice: &'a [u8]) -> Self { #[cfg(not(feature = "raw_value"))] { SliceRead { slice: slice, index: 0, } } #[cfg(feature = "raw_value")] { SliceRead { slice: slice, index: 0, raw_buffering_start_index: 0, } } } fn position_of_index(&self, i: usize) -> Position { let mut position = Position { line: 1, column: 0 }; for ch in &self.slice[..i] { match *ch { b'\n' => { position.line += 1; position.column = 0; } _ => { position.column += 1; } } } position } /// The big optimization here over IoRead is that if the string contains no /// backslash escape sequences, the returned &str is a slice of the raw JSON /// data so we avoid copying into the scratch space. fn parse_str_bytes<'s, T: ?Sized, F>( &'s mut self, scratch: &'s mut Vec, validate: bool, result: F, ) -> Result> where T: 's, F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>, { // Index of the first byte not yet copied into the scratch space. let mut start = self.index; loop { while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] { self.index += 1; } if self.index == self.slice.len() { return error(self, ErrorCode::EofWhileParsingString); } match self.slice[self.index] { b'"' => { if scratch.is_empty() { // Fast path: return a slice of the raw JSON without any // copying. let borrowed = &self.slice[start..self.index]; self.index += 1; return result(self, borrowed).map(Reference::Borrowed); } else { scratch.extend_from_slice(&self.slice[start..self.index]); self.index += 1; return result(self, scratch).map(Reference::Copied); } } b'\\' => { scratch.extend_from_slice(&self.slice[start..self.index]); self.index += 1; tri!(parse_escape(self, scratch)); start = self.index; } _ => { self.index += 1; if validate { return error(self, ErrorCode::ControlCharacterWhileParsingString); } } } } } } impl<'a> private::Sealed for SliceRead<'a> {} impl<'a> Read<'a> for SliceRead<'a> { #[inline] fn next(&mut self) -> Result> { // `Ok(self.slice.get(self.index).map(|ch| { self.index += 1; *ch }))` // is about 10% slower. Ok(if self.index < self.slice.len() { let ch = self.slice[self.index]; self.index += 1; Some(ch) } else { None }) } #[inline] fn peek(&mut self) -> Result> { // `Ok(self.slice.get(self.index).map(|ch| *ch))` is about 10% slower // for some reason. Ok(if self.index < self.slice.len() { Some(self.slice[self.index]) } else { None }) } #[inline] fn discard(&mut self) { self.index += 1; } fn position(&self) -> Position { self.position_of_index(self.index) } fn peek_position(&self) -> Position { // Cap it at slice.len() just in case the most recent call was next() // and it returned the last byte. self.position_of_index(cmp::min(self.slice.len(), self.index + 1)) } fn byte_offset(&self) -> usize { self.index } fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { self.parse_str_bytes(scratch, true, as_str) } fn parse_str_raw<'s>( &'s mut self, scratch: &'s mut Vec, ) -> Result> { self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)) } fn ignore_str(&mut self) -> Result<()> { loop { while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] { self.index += 1; } if self.index == self.slice.len() { return error(self, ErrorCode::EofWhileParsingString); } match self.slice[self.index] { b'"' => { self.index += 1; return Ok(()); } b'\\' => { self.index += 1; tri!(ignore_escape(self)); } _ => { return error(self, ErrorCode::ControlCharacterWhileParsingString); } } } } fn decode_hex_escape(&mut self) -> Result { if self.index + 4 > self.slice.len() { self.index = self.slice.len(); return error(self, ErrorCode::EofWhileParsingString); } let mut n = 0; for _ in 0..4 { let ch = decode_hex_val(self.slice[self.index]); self.index += 1; match ch { None => return error(self, ErrorCode::InvalidEscape), Some(val) => { n = (n << 4) + val; } } } Ok(n) } #[cfg(feature = "raw_value")] fn begin_raw_buffering(&mut self) { self.raw_buffering_start_index = self.index; } #[cfg(feature = "raw_value")] fn end_raw_buffering(&mut self, visitor: V) -> Result where V: Visitor<'a>, { let raw = &self.slice[self.raw_buffering_start_index..self.index]; let raw = str::from_utf8(raw).unwrap(); visitor.visit_map(BorrowedRawDeserializer { raw_value: Some(raw), }) } } ////////////////////////////////////////////////////////////////////////////// impl<'a> StrRead<'a> { /// Create a JSON input source to read from a UTF-8 string. pub fn new(s: &'a str) -> Self { #[cfg(not(feature = "raw_value"))] { StrRead { delegate: SliceRead::new(s.as_bytes()), } } #[cfg(feature = "raw_value")] { StrRead { delegate: SliceRead::new(s.as_bytes()), data: s, } } } } impl<'a> private::Sealed for StrRead<'a> {} impl<'a> Read<'a> for StrRead<'a> { #[inline] fn next(&mut self) -> Result> { self.delegate.next() } #[inline] fn peek(&mut self) -> Result> { self.delegate.peek() } #[inline] fn discard(&mut self) { self.delegate.discard(); } fn position(&self) -> Position { self.delegate.position() } fn peek_position(&self) -> Position { self.delegate.peek_position() } fn byte_offset(&self) -> usize { self.delegate.byte_offset() } fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec) -> Result> { self.delegate.parse_str_bytes(scratch, true, |_, bytes| { // The input is assumed to be valid UTF-8 and the \u-escapes are // checked along the way, so don't need to check here. Ok(unsafe { str::from_utf8_unchecked(bytes) }) }) } fn parse_str_raw<'s>( &'s mut self, scratch: &'s mut Vec, ) -> Result> { self.delegate.parse_str_raw(scratch) } fn ignore_str(&mut self) -> Result<()> { self.delegate.ignore_str() } fn decode_hex_escape(&mut self) -> Result { self.delegate.decode_hex_escape() } #[cfg(feature = "raw_value")] fn begin_raw_buffering(&mut self) { self.delegate.begin_raw_buffering() } #[cfg(feature = "raw_value")] fn end_raw_buffering(&mut self, visitor: V) -> Result where V: Visitor<'a>, { let raw = &self.data[self.delegate.raw_buffering_start_index..self.delegate.index]; visitor.visit_map(BorrowedRawDeserializer { raw_value: Some(raw), }) } } ////////////////////////////////////////////////////////////////////////////// // Lookup table of bytes that must be escaped. A value of true at index i means // that byte i requires an escape sequence in the input. static ESCAPE: [bool; 256] = { const CT: bool = true; // control character \x00..=\x1F const QU: bool = true; // quote \x22 const BS: bool = true; // backslash \x5C const __: bool = false; // allow unescaped [ // 1 2 3 4 5 6 7 8 9 A B C D E F CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 0 CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 1 __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4 __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F ] }; fn next_or_eof<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result { match tri!(read.next()) { Some(b) => Ok(b), None => error(read, ErrorCode::EofWhileParsingString), } } fn error<'de, R: ?Sized + Read<'de>, T>(read: &R, reason: ErrorCode) -> Result { let position = read.position(); Err(Error::syntax(reason, position.line, position.column)) } fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> { str::from_utf8(slice).or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint)) } /// Parses a JSON escape sequence and appends it into the scratch space. Assumes /// the previous byte read was a backslash. fn parse_escape<'de, R: Read<'de>>(read: &mut R, scratch: &mut Vec) -> Result<()> { let ch = tri!(next_or_eof(read)); match ch { b'"' => scratch.push(b'"'), b'\\' => scratch.push(b'\\'), b'/' => scratch.push(b'/'), b'b' => scratch.push(b'\x08'), b'f' => scratch.push(b'\x0c'), b'n' => scratch.push(b'\n'), b'r' => scratch.push(b'\r'), b't' => scratch.push(b'\t'), b'u' => { let c = match tri!(read.decode_hex_escape()) { 0xDC00..=0xDFFF => { return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); } // Non-BMP characters are encoded as a sequence of // two hex escapes, representing UTF-16 surrogates. n1 @ 0xD800..=0xDBFF => { if tri!(next_or_eof(read)) != b'\\' { return error(read, ErrorCode::UnexpectedEndOfHexEscape); } if tri!(next_or_eof(read)) != b'u' { return error(read, ErrorCode::UnexpectedEndOfHexEscape); } let n2 = tri!(read.decode_hex_escape()); if n2 < 0xDC00 || n2 > 0xDFFF { return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); } let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000; match char::from_u32(n) { Some(c) => c, None => { return error(read, ErrorCode::InvalidUnicodeCodePoint); } } } n => match char::from_u32(n as u32) { Some(c) => c, None => { return error(read, ErrorCode::InvalidUnicodeCodePoint); } }, }; scratch.extend_from_slice(c.encode_utf8(&mut [0_u8; 4]).as_bytes()); } _ => { return error(read, ErrorCode::InvalidEscape); } } Ok(()) } /// Parses a JSON escape sequence and discards the value. Assumes the previous /// byte read was a backslash. fn ignore_escape<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result<()> { let ch = tri!(next_or_eof(read)); match ch { b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {} b'u' => { let n = match tri!(read.decode_hex_escape()) { 0xDC00..=0xDFFF => { return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); } // Non-BMP characters are encoded as a sequence of // two hex escapes, representing UTF-16 surrogates. n1 @ 0xD800..=0xDBFF => { if tri!(next_or_eof(read)) != b'\\' { return error(read, ErrorCode::UnexpectedEndOfHexEscape); } if tri!(next_or_eof(read)) != b'u' { return error(read, ErrorCode::UnexpectedEndOfHexEscape); } let n2 = tri!(read.decode_hex_escape()); if n2 < 0xDC00 || n2 > 0xDFFF { return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape); } (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000 } n => n as u32, }; if char::from_u32(n).is_none() { return error(read, ErrorCode::InvalidUnicodeCodePoint); } } _ => { return error(read, ErrorCode::InvalidEscape); } } Ok(()) } static HEX: [u8; 256] = { const __: u8 = 255; // not a hex digit [ // 1 2 3 4 5 6 7 8 9 A B C D E F __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 0 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 1 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2 00, 01, 02, 03, 04, 05, 06, 07, 08, 09, __, __, __, __, __, __, // 3 __, 10, 11, 12, 13, 14, 15, __, __, __, __, __, __, __, __, __, // 4 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 5 __, 10, 11, 12, 13, 14, 15, __, __, __, __, __, __, __, __, __, // 6 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F ] }; fn decode_hex_val(val: u8) -> Option { let n = HEX[val as usize] as u16; if n == 255 { None } else { Some(n) } } serde_json-1.0.45/src/ser.rs010064400017500001750000001711521361214262500141140ustar0000000000000000//! Serialize a Rust data structure into JSON data. use crate::error::{Error, ErrorCode, Result}; use crate::io; use crate::lib::num::FpCategory; use crate::lib::*; use serde::ser::{self, Impossible, Serialize}; use serde::serde_if_integer128; /// A structure for serializing Rust values into JSON. pub struct Serializer { writer: W, formatter: F, } impl Serializer where W: io::Write, { /// Creates a new JSON serializer. #[inline] pub fn new(writer: W) -> Self { Serializer::with_formatter(writer, CompactFormatter) } } impl<'a, W> Serializer> where W: io::Write, { /// Creates a new JSON pretty print serializer. #[inline] pub fn pretty(writer: W) -> Self { Serializer::with_formatter(writer, PrettyFormatter::new()) } } impl Serializer where W: io::Write, F: Formatter, { /// Creates a new JSON visitor whose output will be written to the writer /// specified. #[inline] pub fn with_formatter(writer: W, formatter: F) -> Self { Serializer { writer: writer, formatter: formatter, } } /// Unwrap the `Writer` from the `Serializer`. #[inline] pub fn into_inner(self) -> W { self.writer } } impl<'a, W, F> ser::Serializer for &'a mut Serializer where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; type SerializeSeq = Compound<'a, W, F>; type SerializeTuple = Compound<'a, W, F>; type SerializeTupleStruct = Compound<'a, W, F>; type SerializeTupleVariant = Compound<'a, W, F>; type SerializeMap = Compound<'a, W, F>; type SerializeStruct = Compound<'a, W, F>; type SerializeStructVariant = Compound<'a, W, F>; #[inline] fn serialize_bool(self, value: bool) -> Result<()> { tri!(self .formatter .write_bool(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_i8(self, value: i8) -> Result<()> { tri!(self .formatter .write_i8(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_i16(self, value: i16) -> Result<()> { tri!(self .formatter .write_i16(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_i32(self, value: i32) -> Result<()> { tri!(self .formatter .write_i32(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_i64(self, value: i64) -> Result<()> { tri!(self .formatter .write_i64(&mut self.writer, value) .map_err(Error::io)); Ok(()) } serde_if_integer128! { fn serialize_i128(self, value: i128) -> Result<()> { self.formatter .write_number_str(&mut self.writer, &value.to_string()) .map_err(Error::io) } } #[inline] fn serialize_u8(self, value: u8) -> Result<()> { tri!(self .formatter .write_u8(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_u16(self, value: u16) -> Result<()> { tri!(self .formatter .write_u16(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_u32(self, value: u32) -> Result<()> { tri!(self .formatter .write_u32(&mut self.writer, value) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_u64(self, value: u64) -> Result<()> { tri!(self .formatter .write_u64(&mut self.writer, value) .map_err(Error::io)); Ok(()) } serde_if_integer128! { fn serialize_u128(self, value: u128) -> Result<()> { self.formatter .write_number_str(&mut self.writer, &value.to_string()) .map_err(Error::io) } } #[inline] fn serialize_f32(self, value: f32) -> Result<()> { match value.classify() { FpCategory::Nan | FpCategory::Infinite => { tri!(self .formatter .write_null(&mut self.writer) .map_err(Error::io)); } _ => { tri!(self .formatter .write_f32(&mut self.writer, value) .map_err(Error::io)); } } Ok(()) } #[inline] fn serialize_f64(self, value: f64) -> Result<()> { match value.classify() { FpCategory::Nan | FpCategory::Infinite => { tri!(self .formatter .write_null(&mut self.writer) .map_err(Error::io)); } _ => { tri!(self .formatter .write_f64(&mut self.writer, value) .map_err(Error::io)); } } Ok(()) } #[inline] fn serialize_char(self, value: char) -> Result<()> { // A char encoded as UTF-8 takes 4 bytes at most. let mut buf = [0; 4]; self.serialize_str(value.encode_utf8(&mut buf)) } #[inline] fn serialize_str(self, value: &str) -> Result<()> { tri!(format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io)); Ok(()) } #[inline] fn serialize_bytes(self, value: &[u8]) -> Result<()> { use serde::ser::SerializeSeq; let mut seq = tri!(self.serialize_seq(Some(value.len()))); for byte in value { tri!(seq.serialize_element(byte)); } seq.end() } #[inline] fn serialize_unit(self) -> Result<()> { tri!(self .formatter .write_null(&mut self.writer) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_unit_struct(self, _name: &'static str) -> Result<()> { self.serialize_unit() } #[inline] fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<()> { self.serialize_str(variant) } /// Serialize newtypes without an object wrapper. #[inline] fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> Result<()> where T: Serialize, { value.serialize(self) } #[inline] fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T, ) -> Result<()> where T: Serialize, { tri!(self .formatter .begin_object(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .begin_object_key(&mut self.writer, true) .map_err(Error::io)); tri!(self.serialize_str(variant)); tri!(self .formatter .end_object_key(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .begin_object_value(&mut self.writer) .map_err(Error::io)); tri!(value.serialize(&mut *self)); tri!(self .formatter .end_object_value(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .end_object(&mut self.writer) .map_err(Error::io)); Ok(()) } #[inline] fn serialize_none(self) -> Result<()> { self.serialize_unit() } #[inline] fn serialize_some(self, value: &T) -> Result<()> where T: Serialize, { value.serialize(self) } #[inline] fn serialize_seq(self, len: Option) -> Result { if len == Some(0) { tri!(self .formatter .begin_array(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .end_array(&mut self.writer) .map_err(Error::io)); Ok(Compound::Map { ser: self, state: State::Empty, }) } else { tri!(self .formatter .begin_array(&mut self.writer) .map_err(Error::io)); Ok(Compound::Map { ser: self, state: State::First, }) } } #[inline] fn serialize_tuple(self, len: usize) -> Result { self.serialize_seq(Some(len)) } #[inline] fn serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result { self.serialize_seq(Some(len)) } #[inline] fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result { tri!(self .formatter .begin_object(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .begin_object_key(&mut self.writer, true) .map_err(Error::io)); tri!(self.serialize_str(variant)); tri!(self .formatter .end_object_key(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .begin_object_value(&mut self.writer) .map_err(Error::io)); self.serialize_seq(Some(len)) } #[inline] fn serialize_map(self, len: Option) -> Result { if len == Some(0) { tri!(self .formatter .begin_object(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .end_object(&mut self.writer) .map_err(Error::io)); Ok(Compound::Map { ser: self, state: State::Empty, }) } else { tri!(self .formatter .begin_object(&mut self.writer) .map_err(Error::io)); Ok(Compound::Map { ser: self, state: State::First, }) } } #[inline] fn serialize_struct(self, name: &'static str, len: usize) -> Result { match name { #[cfg(feature = "arbitrary_precision")] crate::number::TOKEN => Ok(Compound::Number { ser: self }), #[cfg(feature = "raw_value")] crate::raw::TOKEN => Ok(Compound::RawValue { ser: self }), _ => self.serialize_map(Some(len)), } } #[inline] fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result { tri!(self .formatter .begin_object(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .begin_object_key(&mut self.writer, true) .map_err(Error::io)); tri!(self.serialize_str(variant)); tri!(self .formatter .end_object_key(&mut self.writer) .map_err(Error::io)); tri!(self .formatter .begin_object_value(&mut self.writer) .map_err(Error::io)); self.serialize_map(Some(len)) } fn collect_str(self, value: &T) -> Result where T: fmt::Display, { use self::fmt::Write; struct Adapter<'ser, W: 'ser, F: 'ser> { writer: &'ser mut W, formatter: &'ser mut F, error: Option, } impl<'ser, W, F> Write for Adapter<'ser, W, F> where W: io::Write, F: Formatter, { fn write_str(&mut self, s: &str) -> fmt::Result { assert!(self.error.is_none()); match format_escaped_str_contents(self.writer, self.formatter, s) { Ok(()) => Ok(()), Err(err) => { self.error = Some(err); Err(fmt::Error) } } } } tri!(self .formatter .begin_string(&mut self.writer) .map_err(Error::io)); { let mut adapter = Adapter { writer: &mut self.writer, formatter: &mut self.formatter, error: None, }; match write!(adapter, "{}", value) { Ok(()) => assert!(adapter.error.is_none()), Err(fmt::Error) => { return Err(Error::io(adapter.error.expect("there should be an error"))); } } } tri!(self .formatter .end_string(&mut self.writer) .map_err(Error::io)); Ok(()) } } // Not public API. Should be pub(crate). #[doc(hidden)] #[derive(Eq, PartialEq)] pub enum State { Empty, First, Rest, } // Not public API. Should be pub(crate). #[doc(hidden)] pub enum Compound<'a, W: 'a, F: 'a> { Map { ser: &'a mut Serializer, state: State, }, #[cfg(feature = "arbitrary_precision")] Number { ser: &'a mut Serializer }, #[cfg(feature = "raw_value")] RawValue { ser: &'a mut Serializer }, } impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize, { match *self { Compound::Map { ref mut ser, ref mut state, } => { tri!(ser .formatter .begin_array_value(&mut ser.writer, *state == State::First) .map_err(Error::io)); *state = State::Rest; tri!(value.serialize(&mut **ser)); tri!(ser .formatter .end_array_value(&mut ser.writer) .map_err(Error::io)); Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } #[inline] fn end(self) -> Result<()> { match self { Compound::Map { ser, state } => { match state { State::Empty => {} _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)), } Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } } impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<()> where T: Serialize, { ser::SerializeSeq::serialize_element(self, value) } #[inline] fn end(self) -> Result<()> { ser::SerializeSeq::end(self) } } impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize, { ser::SerializeSeq::serialize_element(self, value) } #[inline] fn end(self) -> Result<()> { ser::SerializeSeq::end(self) } } impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<()> where T: Serialize, { ser::SerializeSeq::serialize_element(self, value) } #[inline] fn end(self) -> Result<()> { match self { Compound::Map { ser, state } => { match state { State::Empty => {} _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)), } tri!(ser .formatter .end_object_value(&mut ser.writer) .map_err(Error::io)); tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)); Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } } impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_key(&mut self, key: &T) -> Result<()> where T: Serialize, { match *self { Compound::Map { ref mut ser, ref mut state, } => { tri!(ser .formatter .begin_object_key(&mut ser.writer, *state == State::First) .map_err(Error::io)); *state = State::Rest; tri!(key.serialize(MapKeySerializer { ser: *ser })); tri!(ser .formatter .end_object_key(&mut ser.writer) .map_err(Error::io)); Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } #[inline] fn serialize_value(&mut self, value: &T) -> Result<()> where T: Serialize, { match *self { Compound::Map { ref mut ser, .. } => { tri!(ser .formatter .begin_object_value(&mut ser.writer) .map_err(Error::io)); tri!(value.serialize(&mut **ser)); tri!(ser .formatter .end_object_value(&mut ser.writer) .map_err(Error::io)); Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } #[inline] fn end(self) -> Result<()> { match self { Compound::Map { ser, state } => { match state { State::Empty => {} _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)), } Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } } impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<()> where T: Serialize, { match *self { Compound::Map { .. } => { tri!(ser::SerializeMap::serialize_key(self, key)); ser::SerializeMap::serialize_value(self, value) } #[cfg(feature = "arbitrary_precision")] Compound::Number { ref mut ser, .. } => { if key == crate::number::TOKEN { tri!(value.serialize(NumberStrEmitter(&mut *ser))); Ok(()) } else { Err(invalid_number()) } } #[cfg(feature = "raw_value")] Compound::RawValue { ref mut ser, .. } => { if key == crate::raw::TOKEN { tri!(value.serialize(RawValueStrEmitter(&mut *ser))); Ok(()) } else { Err(invalid_raw_value()) } } } } #[inline] fn end(self) -> Result<()> { match self { Compound::Map { .. } => ser::SerializeMap::end(self), #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => Ok(()), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => Ok(()), } } } impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<()> where T: Serialize, { match *self { Compound::Map { .. } => ser::SerializeStruct::serialize_field(self, key, value), #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } #[inline] fn end(self) -> Result<()> { match self { Compound::Map { ser, state } => { match state { State::Empty => {} _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)), } tri!(ser .formatter .end_object_value(&mut ser.writer) .map_err(Error::io)); tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)); Ok(()) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] Compound::RawValue { .. } => unreachable!(), } } } struct MapKeySerializer<'a, W: 'a, F: 'a> { ser: &'a mut Serializer, } #[cfg(feature = "arbitrary_precision")] fn invalid_number() -> Error { Error::syntax(ErrorCode::InvalidNumber, 0, 0) } #[cfg(feature = "raw_value")] fn invalid_raw_value() -> Error { Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0) } fn key_must_be_a_string() -> Error { Error::syntax(ErrorCode::KeyMustBeAString, 0, 0) } impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F> where W: io::Write, F: Formatter, { type Ok = (); type Error = Error; #[inline] fn serialize_str(self, value: &str) -> Result<()> { self.ser.serialize_str(value) } #[inline] fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<()> { self.ser.serialize_str(variant) } #[inline] fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> Result<()> where T: Serialize, { value.serialize(self) } type SerializeSeq = Impossible<(), Error>; type SerializeTuple = Impossible<(), Error>; type SerializeTupleStruct = Impossible<(), Error>; type SerializeTupleVariant = Impossible<(), Error>; type SerializeMap = Impossible<(), Error>; type SerializeStruct = Impossible<(), Error>; type SerializeStructVariant = Impossible<(), Error>; fn serialize_bool(self, _value: bool) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_i8(self, value: i8) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_i8(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } fn serialize_i16(self, value: i16) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_i16(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } fn serialize_i32(self, value: i32) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_i32(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } fn serialize_i64(self, value: i64) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_i64(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } serde_if_integer128! { fn serialize_i128(self, value: i128) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_number_str(&mut self.ser.writer, &value.to_string()) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } } fn serialize_u8(self, value: u8) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_u8(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } fn serialize_u16(self, value: u16) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_u16(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } fn serialize_u32(self, value: u32) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_u32(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } fn serialize_u64(self, value: u64) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_u64(&mut self.ser.writer, value) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } serde_if_integer128! { fn serialize_u128(self, value: u128) -> Result<()> { tri!(self .ser .formatter .begin_string(&mut self.ser.writer) .map_err(Error::io)); tri!(self .ser .formatter .write_number_str(&mut self.ser.writer, &value.to_string()) .map_err(Error::io)); tri!(self .ser .formatter .end_string(&mut self.ser.writer) .map_err(Error::io)); Ok(()) } } fn serialize_f32(self, _value: f32) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_f64(self, _value: f64) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_char(self, value: char) -> Result<()> { self.ser.serialize_str(&value.to_string()) } fn serialize_bytes(self, _value: &[u8]) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_unit(self) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_unit_struct(self, _name: &'static str) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T, ) -> Result<()> where T: Serialize, { Err(key_must_be_a_string()) } fn serialize_none(self) -> Result<()> { Err(key_must_be_a_string()) } fn serialize_some(self, _value: &T) -> Result<()> where T: Serialize, { Err(key_must_be_a_string()) } fn serialize_seq(self, _len: Option) -> Result { Err(key_must_be_a_string()) } fn serialize_tuple(self, _len: usize) -> Result { Err(key_must_be_a_string()) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } fn serialize_map(self, _len: Option) -> Result { Err(key_must_be_a_string()) } fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { Err(key_must_be_a_string()) } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } } #[cfg(feature = "arbitrary_precision")] struct NumberStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer); #[cfg(feature = "arbitrary_precision")] impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W, F> { type Ok = (); type Error = Error; type SerializeSeq = Impossible<(), Error>; type SerializeTuple = Impossible<(), Error>; type SerializeTupleStruct = Impossible<(), Error>; type SerializeTupleVariant = Impossible<(), Error>; type SerializeMap = Impossible<(), Error>; type SerializeStruct = Impossible<(), Error>; type SerializeStructVariant = Impossible<(), Error>; fn serialize_bool(self, _v: bool) -> Result { Err(invalid_number()) } fn serialize_i8(self, _v: i8) -> Result { Err(invalid_number()) } fn serialize_i16(self, _v: i16) -> Result { Err(invalid_number()) } fn serialize_i32(self, _v: i32) -> Result { Err(invalid_number()) } fn serialize_i64(self, _v: i64) -> Result { Err(invalid_number()) } serde_if_integer128! { fn serialize_i128(self, _v: i128) -> Result { Err(invalid_number()) } } fn serialize_u8(self, _v: u8) -> Result { Err(invalid_number()) } fn serialize_u16(self, _v: u16) -> Result { Err(invalid_number()) } fn serialize_u32(self, _v: u32) -> Result { Err(invalid_number()) } fn serialize_u64(self, _v: u64) -> Result { Err(invalid_number()) } serde_if_integer128! { fn serialize_u128(self, _v: u128) -> Result { Err(invalid_number()) } } fn serialize_f32(self, _v: f32) -> Result { Err(invalid_number()) } fn serialize_f64(self, _v: f64) -> Result { Err(invalid_number()) } fn serialize_char(self, _v: char) -> Result { Err(invalid_number()) } fn serialize_str(self, value: &str) -> Result { let NumberStrEmitter(serializer) = self; serializer .formatter .write_number_str(&mut serializer.writer, value) .map_err(Error::io) } fn serialize_bytes(self, _value: &[u8]) -> Result { Err(invalid_number()) } fn serialize_none(self) -> Result { Err(invalid_number()) } fn serialize_some(self, _value: &T) -> Result where T: Serialize, { Err(invalid_number()) } fn serialize_unit(self) -> Result { Err(invalid_number()) } fn serialize_unit_struct(self, _name: &'static str) -> Result { Err(invalid_number()) } fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, ) -> Result { Err(invalid_number()) } fn serialize_newtype_struct( self, _name: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(invalid_number()) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(invalid_number()) } fn serialize_seq(self, _len: Option) -> Result { Err(invalid_number()) } fn serialize_tuple(self, _len: usize) -> Result { Err(invalid_number()) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } fn serialize_map(self, _len: Option) -> Result { Err(invalid_number()) } fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { Err(invalid_number()) } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } } #[cfg(feature = "raw_value")] struct RawValueStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer); #[cfg(feature = "raw_value")] impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a, W, F> { type Ok = (); type Error = Error; type SerializeSeq = Impossible<(), Error>; type SerializeTuple = Impossible<(), Error>; type SerializeTupleStruct = Impossible<(), Error>; type SerializeTupleVariant = Impossible<(), Error>; type SerializeMap = Impossible<(), Error>; type SerializeStruct = Impossible<(), Error>; type SerializeStructVariant = Impossible<(), Error>; fn serialize_bool(self, _v: bool) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_i8(self, _v: i8) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_i16(self, _v: i16) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_i32(self, _v: i32) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_i64(self, _v: i64) -> Result { Err(ser::Error::custom("expected RawValue")) } serde_if_integer128! { fn serialize_i128(self, _v: i128) -> Result { Err(ser::Error::custom("expected RawValue")) } } fn serialize_u8(self, _v: u8) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_u16(self, _v: u16) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_u32(self, _v: u32) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_u64(self, _v: u64) -> Result { Err(ser::Error::custom("expected RawValue")) } serde_if_integer128! { fn serialize_u128(self, _v: u128) -> Result { Err(ser::Error::custom("expected RawValue")) } } fn serialize_f32(self, _v: f32) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_f64(self, _v: f64) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_char(self, _v: char) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_str(self, value: &str) -> Result { let RawValueStrEmitter(serializer) = self; serializer .formatter .write_raw_fragment(&mut serializer.writer, value) .map_err(Error::io) } fn serialize_bytes(self, _value: &[u8]) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_none(self) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_some(self, _value: &T) -> Result where T: Serialize, { Err(ser::Error::custom("expected RawValue")) } fn serialize_unit(self) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_unit_struct(self, _name: &'static str) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, ) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_newtype_struct( self, _name: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(ser::Error::custom("expected RawValue")) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(ser::Error::custom("expected RawValue")) } fn serialize_seq(self, _len: Option) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_tuple(self, _len: usize) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_map(self, _len: Option) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { Err(ser::Error::custom("expected RawValue")) } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(ser::Error::custom("expected RawValue")) } } /// Represents a character escape code in a type-safe manner. pub enum CharEscape { /// An escaped quote `"` Quote, /// An escaped reverse solidus `\` ReverseSolidus, /// An escaped solidus `/` Solidus, /// An escaped backspace character (usually escaped as `\b`) Backspace, /// An escaped form feed character (usually escaped as `\f`) FormFeed, /// An escaped line feed character (usually escaped as `\n`) LineFeed, /// An escaped carriage return character (usually escaped as `\r`) CarriageReturn, /// An escaped tab character (usually escaped as `\t`) Tab, /// An escaped ASCII plane control character (usually escaped as /// `\u00XX` where `XX` are two hex characters) AsciiControl(u8), } impl CharEscape { #[inline] fn from_escape_table(escape: u8, byte: u8) -> CharEscape { match escape { self::BB => CharEscape::Backspace, self::TT => CharEscape::Tab, self::NN => CharEscape::LineFeed, self::FF => CharEscape::FormFeed, self::RR => CharEscape::CarriageReturn, self::QU => CharEscape::Quote, self::BS => CharEscape::ReverseSolidus, self::UU => CharEscape::AsciiControl(byte), _ => unreachable!(), } } } /// This trait abstracts away serializing the JSON control characters, which allows the user to /// optionally pretty print the JSON output. pub trait Formatter { /// Writes a `null` value to the specified writer. #[inline] fn write_null(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"null") } /// Writes a `true` or `false` value to the specified writer. #[inline] fn write_bool(&mut self, writer: &mut W, value: bool) -> io::Result<()> where W: io::Write, { let s = if value { b"true" as &[u8] } else { b"false" as &[u8] }; writer.write_all(s) } /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i8(&mut self, writer: &mut W, value: i8) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i16(&mut self, writer: &mut W, value: i16) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i32(&mut self, writer: &mut W, value: i32) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `-123` to the specified writer. #[inline] fn write_i64(&mut self, writer: &mut W, value: i64) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u8(&mut self, writer: &mut W, value: u8) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u16(&mut self, writer: &mut W, value: u16) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u32(&mut self, writer: &mut W, value: u32) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes an integer value like `123` to the specified writer. #[inline] fn write_u64(&mut self, writer: &mut W, value: u64) -> io::Result<()> where W: io::Write, { let mut buffer = itoa::Buffer::new(); let s = buffer.format(value); writer.write_all(s.as_bytes()) } /// Writes a floating point value like `-31.26e+12` to the specified writer. #[inline] fn write_f32(&mut self, writer: &mut W, value: f32) -> io::Result<()> where W: io::Write, { let mut buffer = ryu::Buffer::new(); let s = buffer.format_finite(value); writer.write_all(s.as_bytes()) } /// Writes a floating point value like `-31.26e+12` to the specified writer. #[inline] fn write_f64(&mut self, writer: &mut W, value: f64) -> io::Result<()> where W: io::Write, { let mut buffer = ryu::Buffer::new(); let s = buffer.format_finite(value); writer.write_all(s.as_bytes()) } /// Writes a number that has already been rendered to a string. #[inline] fn write_number_str(&mut self, writer: &mut W, value: &str) -> io::Result<()> where W: io::Write, { writer.write_all(value.as_bytes()) } /// Called before each series of `write_string_fragment` and /// `write_char_escape`. Writes a `"` to the specified writer. #[inline] fn begin_string(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"\"") } /// Called after each series of `write_string_fragment` and /// `write_char_escape`. Writes a `"` to the specified writer. #[inline] fn end_string(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"\"") } /// Writes a string fragment that doesn't need any escaping to the /// specified writer. #[inline] fn write_string_fragment(&mut self, writer: &mut W, fragment: &str) -> io::Result<()> where W: io::Write, { writer.write_all(fragment.as_bytes()) } /// Writes a character escape code to the specified writer. #[inline] fn write_char_escape( &mut self, writer: &mut W, char_escape: CharEscape, ) -> io::Result<()> where W: io::Write, { use self::CharEscape::*; let s = match char_escape { Quote => b"\\\"", ReverseSolidus => b"\\\\", Solidus => b"\\/", Backspace => b"\\b", FormFeed => b"\\f", LineFeed => b"\\n", CarriageReturn => b"\\r", Tab => b"\\t", AsciiControl(byte) => { static HEX_DIGITS: [u8; 16] = *b"0123456789abcdef"; let bytes = &[ b'\\', b'u', b'0', b'0', HEX_DIGITS[(byte >> 4) as usize], HEX_DIGITS[(byte & 0xF) as usize], ]; return writer.write_all(bytes); } }; writer.write_all(s) } /// Called before every array. Writes a `[` to the specified /// writer. #[inline] fn begin_array(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"[") } /// Called after every array. Writes a `]` to the specified /// writer. #[inline] fn end_array(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"]") } /// Called before every array value. Writes a `,` if needed to /// the specified writer. #[inline] fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: io::Write, { if first { Ok(()) } else { writer.write_all(b",") } } /// Called after every array value. #[inline] fn end_array_value(&mut self, _writer: &mut W) -> io::Result<()> where W: io::Write, { Ok(()) } /// Called before every object. Writes a `{` to the specified /// writer. #[inline] fn begin_object(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"{") } /// Called after every object. Writes a `}` to the specified /// writer. #[inline] fn end_object(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b"}") } /// Called before every object key. #[inline] fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: io::Write, { if first { Ok(()) } else { writer.write_all(b",") } } /// Called after every object key. A `:` should be written to the /// specified writer by either this method or /// `begin_object_value`. #[inline] fn end_object_key(&mut self, _writer: &mut W) -> io::Result<()> where W: io::Write, { Ok(()) } /// Called before every object value. A `:` should be written to /// the specified writer by either this method or /// `end_object_key`. #[inline] fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b":") } /// Called after every object value. #[inline] fn end_object_value(&mut self, _writer: &mut W) -> io::Result<()> where W: io::Write, { Ok(()) } /// Writes a raw JSON fragment that doesn't need any escaping to the /// specified writer. #[inline] fn write_raw_fragment(&mut self, writer: &mut W, fragment: &str) -> io::Result<()> where W: io::Write, { writer.write_all(fragment.as_bytes()) } } /// This structure compacts a JSON value with no extra whitespace. #[derive(Clone, Debug)] pub struct CompactFormatter; impl Formatter for CompactFormatter {} /// This structure pretty prints a JSON value to make it human readable. #[derive(Clone, Debug)] pub struct PrettyFormatter<'a> { current_indent: usize, has_value: bool, indent: &'a [u8], } impl<'a> PrettyFormatter<'a> { /// Construct a pretty printer formatter that defaults to using two spaces for indentation. pub fn new() -> Self { PrettyFormatter::with_indent(b" ") } /// Construct a pretty printer formatter that uses the `indent` string for indentation. pub fn with_indent(indent: &'a [u8]) -> Self { PrettyFormatter { current_indent: 0, has_value: false, indent: indent, } } } impl<'a> Default for PrettyFormatter<'a> { fn default() -> Self { PrettyFormatter::new() } } impl<'a> Formatter for PrettyFormatter<'a> { #[inline] fn begin_array(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { self.current_indent += 1; self.has_value = false; writer.write_all(b"[") } #[inline] fn end_array(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { self.current_indent -= 1; if self.has_value { tri!(writer.write_all(b"\n")); tri!(indent(writer, self.current_indent, self.indent)); } writer.write_all(b"]") } #[inline] fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: io::Write, { if first { tri!(writer.write_all(b"\n")); } else { tri!(writer.write_all(b",\n")); } tri!(indent(writer, self.current_indent, self.indent)); Ok(()) } #[inline] fn end_array_value(&mut self, _writer: &mut W) -> io::Result<()> where W: io::Write, { self.has_value = true; Ok(()) } #[inline] fn begin_object(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { self.current_indent += 1; self.has_value = false; writer.write_all(b"{") } #[inline] fn end_object(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { self.current_indent -= 1; if self.has_value { tri!(writer.write_all(b"\n")); tri!(indent(writer, self.current_indent, self.indent)); } writer.write_all(b"}") } #[inline] fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: io::Write, { if first { tri!(writer.write_all(b"\n")); } else { tri!(writer.write_all(b",\n")); } indent(writer, self.current_indent, self.indent) } #[inline] fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> where W: io::Write, { writer.write_all(b": ") } #[inline] fn end_object_value(&mut self, _writer: &mut W) -> io::Result<()> where W: io::Write, { self.has_value = true; Ok(()) } } fn format_escaped_str( writer: &mut W, formatter: &mut F, value: &str, ) -> io::Result<()> where W: io::Write, F: Formatter, { tri!(formatter.begin_string(writer)); tri!(format_escaped_str_contents(writer, formatter, value)); tri!(formatter.end_string(writer)); Ok(()) } fn format_escaped_str_contents( writer: &mut W, formatter: &mut F, value: &str, ) -> io::Result<()> where W: io::Write, F: Formatter, { let bytes = value.as_bytes(); let mut start = 0; for (i, &byte) in bytes.iter().enumerate() { let escape = ESCAPE[byte as usize]; if escape == 0 { continue; } if start < i { tri!(formatter.write_string_fragment(writer, &value[start..i])); } let char_escape = CharEscape::from_escape_table(escape, byte); tri!(formatter.write_char_escape(writer, char_escape)); start = i + 1; } if start != bytes.len() { tri!(formatter.write_string_fragment(writer, &value[start..])); } Ok(()) } const BB: u8 = b'b'; // \x08 const TT: u8 = b't'; // \x09 const NN: u8 = b'n'; // \x0A const FF: u8 = b'f'; // \x0C const RR: u8 = b'r'; // \x0D const QU: u8 = b'"'; // \x22 const BS: u8 = b'\\'; // \x5C const UU: u8 = b'u'; // \x00...\x1F except the ones above const __: u8 = 0; // Lookup table of escape sequences. A value of b'x' at index i means that byte // i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped. static ESCAPE: [u8; 256] = [ // 1 2 3 4 5 6 7 8 9 A B C D E F UU, UU, UU, UU, UU, UU, UU, UU, BB, TT, NN, UU, FF, RR, UU, UU, // 0 UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, // 1 __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4 __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F ]; /// Serialize the given data structure as JSON into the IO stream. /// /// # Errors /// /// Serialization can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_writer(writer: W, value: &T) -> Result<()> where W: io::Write, T: Serialize, { let mut ser = Serializer::new(writer); tri!(value.serialize(&mut ser)); Ok(()) } /// Serialize the given data structure as pretty-printed JSON into the IO /// stream. /// /// # Errors /// /// Serialization can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_writer_pretty(writer: W, value: &T) -> Result<()> where W: io::Write, T: Serialize, { let mut ser = Serializer::pretty(writer); tri!(value.serialize(&mut ser)); Ok(()) } /// Serialize the given data structure as a JSON byte vector. /// /// # Errors /// /// Serialization can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_vec(value: &T) -> Result> where T: Serialize, { let mut writer = Vec::with_capacity(128); tri!(to_writer(&mut writer, value)); Ok(writer) } /// Serialize the given data structure as a pretty-printed JSON byte vector. /// /// # Errors /// /// Serialization can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_vec_pretty(value: &T) -> Result> where T: Serialize, { let mut writer = Vec::with_capacity(128); tri!(to_writer_pretty(&mut writer, value)); Ok(writer) } /// Serialize the given data structure as a String of JSON. /// /// # Errors /// /// Serialization can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_string(value: &T) -> Result where T: Serialize, { let vec = tri!(to_vec(value)); let string = unsafe { // We do not emit invalid UTF-8. String::from_utf8_unchecked(vec) }; Ok(string) } /// Serialize the given data structure as a pretty-printed String of JSON. /// /// # Errors /// /// Serialization can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. #[inline] pub fn to_string_pretty(value: &T) -> Result where T: Serialize, { let vec = tri!(to_vec_pretty(value)); let string = unsafe { // We do not emit invalid UTF-8. String::from_utf8_unchecked(vec) }; Ok(string) } fn indent(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()> where W: io::Write, { for _ in 0..n { tri!(wr.write_all(s)); } Ok(()) } serde_json-1.0.45/src/value/de.rs010064400017500001750000001176011361214360700150270ustar0000000000000000use crate::error::Error; use crate::lib::str::FromStr; use crate::lib::*; use crate::map::Map; use crate::number::Number; use crate::value::Value; use serde::de::{ self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor, }; use serde::{forward_to_deserialize_any, serde_if_integer128}; #[cfg(feature = "arbitrary_precision")] use crate::number::NumberFromString; impl<'de> Deserialize<'de> for Value { #[inline] fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de>, { struct ValueVisitor; impl<'de> Visitor<'de> for ValueVisitor { type Value = Value; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("any valid JSON value") } #[inline] fn visit_bool(self, value: bool) -> Result { Ok(Value::Bool(value)) } #[inline] fn visit_i64(self, value: i64) -> Result { Ok(Value::Number(value.into())) } #[inline] fn visit_u64(self, value: u64) -> Result { Ok(Value::Number(value.into())) } #[inline] fn visit_f64(self, value: f64) -> Result { Ok(Number::from_f64(value).map_or(Value::Null, Value::Number)) } #[inline] fn visit_str(self, value: &str) -> Result where E: serde::de::Error, { self.visit_string(String::from(value)) } #[inline] fn visit_string(self, value: String) -> Result { Ok(Value::String(value)) } #[inline] fn visit_none(self) -> Result { Ok(Value::Null) } #[inline] fn visit_some(self, deserializer: D) -> Result where D: serde::Deserializer<'de>, { Deserialize::deserialize(deserializer) } #[inline] fn visit_unit(self) -> Result { Ok(Value::Null) } #[inline] fn visit_seq(self, mut visitor: V) -> Result where V: SeqAccess<'de>, { let mut vec = Vec::new(); while let Some(elem) = tri!(visitor.next_element()) { vec.push(elem); } Ok(Value::Array(vec)) } fn visit_map(self, mut visitor: V) -> Result where V: MapAccess<'de>, { match visitor.next_key_seed(KeyClassifier)? { #[cfg(feature = "arbitrary_precision")] Some(KeyClass::Number) => { let number: NumberFromString = visitor.next_value()?; Ok(Value::Number(number.value)) } #[cfg(feature = "raw_value")] Some(KeyClass::RawValue) => { let value = visitor.next_value_seed(crate::raw::BoxedFromString)?; crate::from_str(value.get()).map_err(de::Error::custom) } Some(KeyClass::Map(first_key)) => { let mut values = Map::new(); values.insert(first_key, tri!(visitor.next_value())); while let Some((key, value)) = tri!(visitor.next_entry()) { values.insert(key, value); } Ok(Value::Object(values)) } None => Ok(Value::Object(Map::new())), } } } deserializer.deserialize_any(ValueVisitor) } } impl FromStr for Value { type Err = Error; fn from_str(s: &str) -> Result { super::super::de::from_str(s) } } macro_rules! deserialize_prim_number { ($method:ident) => { #[cfg(not(feature = "arbitrary_precision"))] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Number(n) => n.deserialize_any(visitor), _ => Err(self.invalid_type(&visitor)), } } #[cfg(feature = "arbitrary_precision")] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Number(n) => n.$method(visitor), _ => self.deserialize_any(visitor), } } } } fn visit_array<'de, V>(array: Vec, visitor: V) -> Result where V: Visitor<'de>, { let len = array.len(); let mut deserializer = SeqDeserializer::new(array); let seq = tri!(visitor.visit_seq(&mut deserializer)); let remaining = deserializer.iter.len(); if remaining == 0 { Ok(seq) } else { Err(serde::de::Error::invalid_length( len, &"fewer elements in array", )) } } fn visit_object<'de, V>(object: Map, visitor: V) -> Result where V: Visitor<'de>, { let len = object.len(); let mut deserializer = MapDeserializer::new(object); let map = tri!(visitor.visit_map(&mut deserializer)); let remaining = deserializer.iter.len(); if remaining == 0 { Ok(map) } else { Err(serde::de::Error::invalid_length( len, &"fewer elements in map", )) } } impl<'de> serde::Deserializer<'de> for Value { type Error = Error; #[inline] fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Null => visitor.visit_unit(), Value::Bool(v) => visitor.visit_bool(v), Value::Number(n) => n.deserialize_any(visitor), Value::String(v) => visitor.visit_string(v), Value::Array(v) => visit_array(v, visitor), Value::Object(v) => visit_object(v, visitor), } } deserialize_prim_number!(deserialize_i8); deserialize_prim_number!(deserialize_i16); deserialize_prim_number!(deserialize_i32); deserialize_prim_number!(deserialize_i64); deserialize_prim_number!(deserialize_u8); deserialize_prim_number!(deserialize_u16); deserialize_prim_number!(deserialize_u32); deserialize_prim_number!(deserialize_u64); deserialize_prim_number!(deserialize_f32); deserialize_prim_number!(deserialize_f64); serde_if_integer128! { deserialize_prim_number!(deserialize_i128); deserialize_prim_number!(deserialize_u128); } #[inline] fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Null => visitor.visit_none(), _ => visitor.visit_some(self), } } #[inline] fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { let (variant, value) = match self { Value::Object(value) => { let mut iter = value.into_iter(); let (variant, value) = match iter.next() { Some(v) => v, None => { return Err(serde::de::Error::invalid_value( Unexpected::Map, &"map with a single key", )); } }; // enums are encoded in json as maps with a single key:value pair if iter.next().is_some() { return Err(serde::de::Error::invalid_value( Unexpected::Map, &"map with a single key", )); } (variant, Some(value)) } Value::String(variant) => (variant, None), other => { return Err(serde::de::Error::invalid_type( other.unexpected(), &"string or map", )); } }; visitor.visit_enum(EnumDeserializer { variant: variant, value: value, }) } #[inline] fn deserialize_newtype_struct( self, name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { #[cfg(feature = "raw_value")] { if name == crate::raw::TOKEN { return visitor.visit_map(crate::raw::OwnedRawDeserializer { raw_value: Some(self.to_string()), }); } } let _ = name; visitor.visit_newtype_struct(self) } fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Bool(v) => visitor.visit_bool(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_char(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_string(visitor) } fn deserialize_str(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_string(visitor) } fn deserialize_string(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::String(v) => visitor.visit_string(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_bytes(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_byte_buf(visitor) } fn deserialize_byte_buf(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::String(v) => visitor.visit_string(v), Value::Array(v) => visit_array(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Null => visitor.visit_unit(), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_unit_struct( self, _name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { self.deserialize_unit(visitor) } fn deserialize_seq(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Array(v) => visit_array(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_tuple(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_tuple_struct( self, _name: &'static str, _len: usize, visitor: V, ) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_map(self, visitor: V) -> Result where V: Visitor<'de>, { match self { Value::Object(v) => visit_object(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_struct( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match self { Value::Array(v) => visit_array(v, visitor), Value::Object(v) => visit_object(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_identifier(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_string(visitor) } fn deserialize_ignored_any(self, visitor: V) -> Result where V: Visitor<'de>, { drop(self); visitor.visit_unit() } } struct EnumDeserializer { variant: String, value: Option, } impl<'de> EnumAccess<'de> for EnumDeserializer { type Error = Error; type Variant = VariantDeserializer; fn variant_seed(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error> where V: DeserializeSeed<'de>, { let variant = self.variant.into_deserializer(); let visitor = VariantDeserializer { value: self.value }; seed.deserialize(variant).map(|v| (v, visitor)) } } impl<'de> IntoDeserializer<'de, Error> for Value { type Deserializer = Self; fn into_deserializer(self) -> Self::Deserializer { self } } struct VariantDeserializer { value: Option, } impl<'de> VariantAccess<'de> for VariantDeserializer { type Error = Error; fn unit_variant(self) -> Result<(), Error> { match self.value { Some(value) => Deserialize::deserialize(value), None => Ok(()), } } fn newtype_variant_seed(self, seed: T) -> Result where T: DeserializeSeed<'de>, { match self.value { Some(value) => seed.deserialize(value), None => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"newtype variant", )), } } fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { match self.value { Some(Value::Array(v)) => { serde::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor) } Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"tuple variant", )), None => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"tuple variant", )), } } fn struct_variant( self, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match self.value { Some(Value::Object(v)) => { serde::Deserializer::deserialize_any(MapDeserializer::new(v), visitor) } Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"struct variant", )), _ => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"struct variant", )), } } } struct SeqDeserializer { iter: vec::IntoIter, } impl SeqDeserializer { fn new(vec: Vec) -> Self { SeqDeserializer { iter: vec.into_iter(), } } } impl<'de> serde::Deserializer<'de> for SeqDeserializer { type Error = Error; #[inline] fn deserialize_any(mut self, visitor: V) -> Result where V: Visitor<'de>, { let len = self.iter.len(); if len == 0 { visitor.visit_unit() } else { let ret = tri!(visitor.visit_seq(&mut self)); let remaining = self.iter.len(); if remaining == 0 { Ok(ret) } else { Err(serde::de::Error::invalid_length( len, &"fewer elements in array", )) } } } forward_to_deserialize_any! { bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct map struct enum identifier ignored_any } } impl<'de> SeqAccess<'de> for SeqDeserializer { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result, Error> where T: DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), None => Ok(None), } } fn size_hint(&self) -> Option { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } struct MapDeserializer { iter: as IntoIterator>::IntoIter, value: Option, } impl MapDeserializer { fn new(map: Map) -> Self { MapDeserializer { iter: map.into_iter(), value: None, } } } impl<'de> MapAccess<'de> for MapDeserializer { type Error = Error; fn next_key_seed(&mut self, seed: T) -> Result, Error> where T: DeserializeSeed<'de>, { match self.iter.next() { Some((key, value)) => { self.value = Some(value); let key_de = MapKeyDeserializer { key: Cow::Owned(key), }; seed.deserialize(key_de).map(Some) } None => Ok(None), } } fn next_value_seed(&mut self, seed: T) -> Result where T: DeserializeSeed<'de>, { match self.value.take() { Some(value) => seed.deserialize(value), None => Err(serde::de::Error::custom("value is missing")), } } fn size_hint(&self) -> Option { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } impl<'de> serde::Deserializer<'de> for MapDeserializer { type Error = Error; #[inline] fn deserialize_any(self, visitor: V) -> Result 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 } } macro_rules! deserialize_value_ref_number { ($method:ident) => { #[cfg(not(feature = "arbitrary_precision"))] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Number(ref n) => n.deserialize_any(visitor), _ => Err(self.invalid_type(&visitor)), } } #[cfg(feature = "arbitrary_precision")] fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Number(ref n) => n.$method(visitor), _ => self.deserialize_any(visitor), } } } } fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result where V: Visitor<'de>, { let len = array.len(); let mut deserializer = SeqRefDeserializer::new(array); let seq = tri!(visitor.visit_seq(&mut deserializer)); let remaining = deserializer.iter.len(); if remaining == 0 { Ok(seq) } else { Err(serde::de::Error::invalid_length( len, &"fewer elements in array", )) } } fn visit_object_ref<'de, V>(object: &'de Map, visitor: V) -> Result where V: Visitor<'de>, { let len = object.len(); let mut deserializer = MapRefDeserializer::new(object); let map = tri!(visitor.visit_map(&mut deserializer)); let remaining = deserializer.iter.len(); if remaining == 0 { Ok(map) } else { Err(serde::de::Error::invalid_length( len, &"fewer elements in map", )) } } impl<'de> serde::Deserializer<'de> for &'de Value { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Null => visitor.visit_unit(), Value::Bool(v) => visitor.visit_bool(v), Value::Number(ref n) => n.deserialize_any(visitor), Value::String(ref v) => visitor.visit_borrowed_str(v), Value::Array(ref v) => visit_array_ref(v, visitor), Value::Object(ref v) => visit_object_ref(v, visitor), } } deserialize_value_ref_number!(deserialize_i8); deserialize_value_ref_number!(deserialize_i16); deserialize_value_ref_number!(deserialize_i32); deserialize_value_ref_number!(deserialize_i64); deserialize_value_ref_number!(deserialize_u8); deserialize_value_ref_number!(deserialize_u16); deserialize_value_ref_number!(deserialize_u32); deserialize_value_ref_number!(deserialize_u64); deserialize_value_ref_number!(deserialize_f32); deserialize_value_ref_number!(deserialize_f64); serde_if_integer128! { deserialize_prim_number!(deserialize_i128); deserialize_prim_number!(deserialize_u128); } fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Null => visitor.visit_none(), _ => visitor.visit_some(self), } } fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { let (variant, value) = match *self { Value::Object(ref value) => { let mut iter = value.into_iter(); let (variant, value) = match iter.next() { Some(v) => v, None => { return Err(serde::de::Error::invalid_value( Unexpected::Map, &"map with a single key", )); } }; // enums are encoded in json as maps with a single key:value pair if iter.next().is_some() { return Err(serde::de::Error::invalid_value( Unexpected::Map, &"map with a single key", )); } (variant, Some(value)) } Value::String(ref variant) => (variant, None), ref other => { return Err(serde::de::Error::invalid_type( other.unexpected(), &"string or map", )); } }; visitor.visit_enum(EnumRefDeserializer { variant: variant, value: value, }) } #[inline] fn deserialize_newtype_struct( self, name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { #[cfg(feature = "raw_value")] { if name == crate::raw::TOKEN { return visitor.visit_map(crate::raw::OwnedRawDeserializer { raw_value: Some(self.to_string()), }); } } let _ = name; visitor.visit_newtype_struct(self) } fn deserialize_bool(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Bool(v) => visitor.visit_bool(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_char(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_str(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::String(ref v) => visitor.visit_borrowed_str(v), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_string(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_bytes(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::String(ref v) => visitor.visit_borrowed_str(v), Value::Array(ref v) => visit_array_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_byte_buf(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_bytes(visitor) } fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Null => visitor.visit_unit(), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_unit_struct( self, _name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { self.deserialize_unit(visitor) } fn deserialize_seq(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Array(ref v) => visit_array_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_tuple(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_tuple_struct( self, _name: &'static str, _len: usize, visitor: V, ) -> Result where V: Visitor<'de>, { self.deserialize_seq(visitor) } fn deserialize_map(self, visitor: V) -> Result where V: Visitor<'de>, { match *self { Value::Object(ref v) => visit_object_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_struct( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match *self { Value::Array(ref v) => visit_array_ref(v, visitor), Value::Object(ref v) => visit_object_ref(v, visitor), _ => Err(self.invalid_type(&visitor)), } } fn deserialize_identifier(self, visitor: V) -> Result where V: Visitor<'de>, { self.deserialize_str(visitor) } fn deserialize_ignored_any(self, visitor: V) -> Result where V: Visitor<'de>, { visitor.visit_unit() } } struct EnumRefDeserializer<'de> { variant: &'de str, value: Option<&'de Value>, } impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> { type Error = Error; type Variant = VariantRefDeserializer<'de>; fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant), Error> where V: DeserializeSeed<'de>, { let variant = self.variant.into_deserializer(); let visitor = VariantRefDeserializer { value: self.value }; seed.deserialize(variant).map(|v| (v, visitor)) } } struct VariantRefDeserializer<'de> { value: Option<&'de Value>, } impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> { type Error = Error; fn unit_variant(self) -> Result<(), Error> { match self.value { Some(value) => Deserialize::deserialize(value), None => Ok(()), } } fn newtype_variant_seed(self, seed: T) -> Result where T: DeserializeSeed<'de>, { match self.value { Some(value) => seed.deserialize(value), None => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"newtype variant", )), } } fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: Visitor<'de>, { match self.value { Some(&Value::Array(ref v)) => { serde::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor) } Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"tuple variant", )), None => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"tuple variant", )), } } fn struct_variant( self, _fields: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { match self.value { Some(&Value::Object(ref v)) => { serde::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor) } Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"struct variant", )), _ => Err(serde::de::Error::invalid_type( Unexpected::UnitVariant, &"struct variant", )), } } } struct SeqRefDeserializer<'de> { iter: slice::Iter<'de, Value>, } impl<'de> SeqRefDeserializer<'de> { fn new(slice: &'de [Value]) -> Self { SeqRefDeserializer { iter: slice.iter() } } } impl<'de> serde::Deserializer<'de> for SeqRefDeserializer<'de> { type Error = Error; #[inline] fn deserialize_any(mut self, visitor: V) -> Result where V: Visitor<'de>, { let len = self.iter.len(); if len == 0 { visitor.visit_unit() } else { let ret = tri!(visitor.visit_seq(&mut self)); let remaining = self.iter.len(); if remaining == 0 { Ok(ret) } else { Err(serde::de::Error::invalid_length( len, &"fewer elements in array", )) } } } forward_to_deserialize_any! { bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct map struct enum identifier ignored_any } } impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result, Error> where T: DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), None => Ok(None), } } fn size_hint(&self) -> Option { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } struct MapRefDeserializer<'de> { iter: <&'de Map as IntoIterator>::IntoIter, value: Option<&'de Value>, } impl<'de> MapRefDeserializer<'de> { fn new(map: &'de Map) -> Self { MapRefDeserializer { iter: map.into_iter(), value: None, } } } impl<'de> MapAccess<'de> for MapRefDeserializer<'de> { type Error = Error; fn next_key_seed(&mut self, seed: T) -> Result, Error> where T: DeserializeSeed<'de>, { match self.iter.next() { Some((key, value)) => { self.value = Some(value); let key_de = MapKeyDeserializer { key: Cow::Borrowed(&**key), }; seed.deserialize(key_de).map(Some) } None => Ok(None), } } fn next_value_seed(&mut self, seed: T) -> Result where T: DeserializeSeed<'de>, { match self.value.take() { Some(value) => seed.deserialize(value), None => Err(serde::de::Error::custom("value is missing")), } } fn size_hint(&self) -> Option { match self.iter.size_hint() { (lower, Some(upper)) if lower == upper => Some(upper), _ => None, } } } impl<'de> serde::Deserializer<'de> for MapRefDeserializer<'de> { type Error = Error; #[inline] fn deserialize_any(self, visitor: V) -> Result 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 } } struct MapKeyDeserializer<'de> { key: Cow<'de, str>, } macro_rules! deserialize_integer_key { ($method:ident => $visit:ident) => { fn $method(self, visitor: V) -> Result where V: Visitor<'de>, { match (self.key.parse(), self.key) { (Ok(integer), _) => visitor.$visit(integer), (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s), (Err(_), Cow::Owned(s)) => visitor.visit_string(s), } } } } impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: Visitor<'de>, { BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor) } deserialize_integer_key!(deserialize_i8 => visit_i8); deserialize_integer_key!(deserialize_i16 => visit_i16); deserialize_integer_key!(deserialize_i32 => visit_i32); deserialize_integer_key!(deserialize_i64 => visit_i64); deserialize_integer_key!(deserialize_u8 => visit_u8); deserialize_integer_key!(deserialize_u16 => visit_u16); deserialize_integer_key!(deserialize_u32 => visit_u32); deserialize_integer_key!(deserialize_u64 => visit_u64); serde_if_integer128! { deserialize_integer_key!(deserialize_i128 => visit_i128); deserialize_integer_key!(deserialize_u128 => visit_u128); } #[inline] fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>, { // Map keys cannot be null. visitor.visit_some(self) } #[inline] fn deserialize_newtype_struct( self, _name: &'static str, visitor: V, ) -> Result where V: Visitor<'de>, { visitor.visit_newtype_struct(self) } fn deserialize_enum( self, name: &'static str, variants: &'static [&'static str], visitor: V, ) -> Result where V: Visitor<'de>, { self.key .into_deserializer() .deserialize_enum(name, variants, visitor) } forward_to_deserialize_any! { bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple tuple_struct map struct identifier ignored_any } } struct KeyClassifier; enum KeyClass { Map(String), #[cfg(feature = "arbitrary_precision")] Number, #[cfg(feature = "raw_value")] RawValue, } impl<'de> DeserializeSeed<'de> for KeyClassifier { type Value = KeyClass; fn deserialize(self, deserializer: D) -> Result where D: serde::Deserializer<'de>, { deserializer.deserialize_str(self) } } impl<'de> Visitor<'de> for KeyClassifier { type Value = KeyClass; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a string key") } fn visit_str(self, s: &str) -> Result where E: de::Error, { match s { #[cfg(feature = "arbitrary_precision")] crate::number::TOKEN => Ok(KeyClass::Number), #[cfg(feature = "raw_value")] crate::raw::TOKEN => Ok(KeyClass::RawValue), _ => Ok(KeyClass::Map(s.to_owned())), } } fn visit_string(self, s: String) -> Result where E: de::Error, { match s.as_str() { #[cfg(feature = "arbitrary_precision")] crate::number::TOKEN => Ok(KeyClass::Number), #[cfg(feature = "raw_value")] crate::raw::TOKEN => Ok(KeyClass::RawValue), _ => Ok(KeyClass::Map(s)), } } } impl Value { #[cold] fn invalid_type(&self, exp: &dyn Expected) -> E where E: serde::de::Error, { serde::de::Error::invalid_type(self.unexpected(), exp) } #[cold] fn unexpected(&self) -> Unexpected { match *self { Value::Null => Unexpected::Unit, Value::Bool(b) => Unexpected::Bool(b), Value::Number(ref n) => n.unexpected(), Value::String(ref s) => Unexpected::Str(s), Value::Array(_) => Unexpected::Seq, Value::Object(_) => Unexpected::Map, } } } struct BorrowedCowStrDeserializer<'de> { value: Cow<'de, str>, } impl<'de> BorrowedCowStrDeserializer<'de> { fn new(value: Cow<'de, str>) -> Self { BorrowedCowStrDeserializer { value: value } } } impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> { type Error = Error; fn deserialize_any(self, visitor: V) -> Result where V: de::Visitor<'de>, { match self.value { Cow::Borrowed(string) => visitor.visit_borrowed_str(string), Cow::Owned(string) => visitor.visit_string(string), } } fn deserialize_enum( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result where V: de::Visitor<'de>, { visitor.visit_enum(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 identifier ignored_any } } impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> { type Error = Error; type Variant = UnitOnly; fn variant_seed(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> where T: de::DeserializeSeed<'de>, { let value = seed.deserialize(self)?; Ok((value, UnitOnly)) } } struct UnitOnly; impl<'de> de::VariantAccess<'de> for UnitOnly { type Error = Error; fn unit_variant(self) -> Result<(), Self::Error> { Ok(()) } fn newtype_variant_seed(self, _seed: T) -> Result where T: de::DeserializeSeed<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"newtype variant", )) } fn tuple_variant(self, _len: usize, _visitor: V) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"tuple variant", )) } fn struct_variant( self, _fields: &'static [&'static str], _visitor: V, ) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type( Unexpected::UnitVariant, &"struct variant", )) } } serde_json-1.0.45/src/value/from.rs010064400017500001750000000115151361214160200153700ustar0000000000000000use super::Value; use crate::lib::iter::FromIterator; use crate::lib::*; use crate::map::Map; use crate::number::Number; #[cfg(feature = "arbitrary_precision")] use serde::serde_if_integer128; macro_rules! from_integer { ($($ty:ident)*) => { $( impl From<$ty> for Value { fn from(n: $ty) -> Self { Value::Number(n.into()) } } )* }; } from_integer! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize } #[cfg(feature = "arbitrary_precision")] serde_if_integer128! { from_integer! { i128 u128 } } impl From for Value { /// Convert 32-bit floating point number to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let f: f32 = 13.37; /// let x: Value = f.into(); /// ``` fn from(f: f32) -> Self { From::from(f as f64) } } impl From for Value { /// Convert 64-bit floating point number to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let f: f64 = 13.37; /// let x: Value = f.into(); /// ``` fn from(f: f64) -> Self { Number::from_f64(f).map_or(Value::Null, Value::Number) } } impl From for Value { /// Convert boolean to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let b = false; /// let x: Value = b.into(); /// ``` fn from(f: bool) -> Self { Value::Bool(f) } } impl From for Value { /// Convert `String` to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let s: String = "lorem".to_string(); /// let x: Value = s.into(); /// ``` fn from(f: String) -> Self { Value::String(f) } } impl<'a> From<&'a str> for Value { /// Convert string slice to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let s: &str = "lorem"; /// let x: Value = s.into(); /// ``` fn from(f: &str) -> Self { Value::String(f.to_string()) } } impl<'a> From> for Value { /// Convert copy-on-write string to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// use std::borrow::Cow; /// /// let s: Cow = Cow::Borrowed("lorem"); /// let x: Value = s.into(); /// ``` /// /// ``` /// use serde_json::Value; /// use std::borrow::Cow; /// /// let s: Cow = Cow::Owned("lorem".to_string()); /// let x: Value = s.into(); /// ``` fn from(f: Cow<'a, str>) -> Self { Value::String(f.into_owned()) } } impl From> for Value { /// Convert map (with string keys) to `Value` /// /// # Examples /// /// ``` /// use serde_json::{Map, Value}; /// /// let mut m = Map::new(); /// m.insert("Lorem".to_string(), "ipsum".into()); /// let x: Value = m.into(); /// ``` fn from(f: Map) -> Self { Value::Object(f) } } impl> From> for Value { /// Convert a `Vec` to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let v = vec!["lorem", "ipsum", "dolor"]; /// let x: Value = v.into(); /// ``` fn from(f: Vec) -> Self { Value::Array(f.into_iter().map(Into::into).collect()) } } impl<'a, T: Clone + Into> From<&'a [T]> for Value { /// Convert a slice to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let v: &[&str] = &["lorem", "ipsum", "dolor"]; /// let x: Value = v.into(); /// ``` fn from(f: &'a [T]) -> Self { Value::Array(f.iter().cloned().map(Into::into).collect()) } } impl> FromIterator for Value { /// Convert an iteratable type to a `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let v = std::iter::repeat(42).take(5); /// let x: Value = v.collect(); /// ``` /// /// ``` /// use serde_json::Value; /// /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"]; /// let x: Value = v.into_iter().collect(); /// ``` /// /// ``` /// use std::iter::FromIterator; /// use serde_json::Value; /// /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]); /// ``` fn from_iter>(iter: I) -> Self { Value::Array(iter.into_iter().map(Into::into).collect()) } } impl From<()> for Value { /// Convert `()` to `Value` /// /// # Examples /// /// ``` /// use serde_json::Value; /// /// let u = (); /// let x: Value = u.into(); /// ``` fn from((): ()) -> Self { Value::Null } } serde_json-1.0.45/src/value/index.rs010064400017500001750000000210541361214167400155440ustar0000000000000000use super::Value; use crate::lib::*; use crate::map::Map; /// A type that can be used to index into a `serde_json::Value`. /// /// The [`get`] and [`get_mut`] methods of `Value` accept any type that /// implements `Index`, as does the [square-bracket indexing operator]. This /// trait is implemented for strings which are used as the index into a JSON /// map, and for `usize` which is used as the index into a JSON array. /// /// [`get`]: ../enum.Value.html#method.get /// [`get_mut`]: ../enum.Value.html#method.get_mut /// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E /// /// This trait is sealed and cannot be implemented for types outside of /// `serde_json`. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// let data = json!({ "inner": [1, 2, 3] }); /// /// // Data is a JSON map so it can be indexed with a string. /// let inner = &data["inner"]; /// /// // Inner is a JSON array so it can be indexed with an integer. /// let first = &inner[0]; /// /// assert_eq!(first, 1); /// ``` pub trait Index: private::Sealed { /// Return None if the key is not already in the array or object. #[doc(hidden)] fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>; /// Return None if the key is not already in the array or object. #[doc(hidden)] fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>; /// Panic if array index out of bounds. If key is not already in the object, /// insert it with a value of null. Panic if Value is a type that cannot be /// indexed into, except if Value is null then it can be treated as an empty /// object. #[doc(hidden)] fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value; } impl Index for usize { fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> { match *v { Value::Array(ref vec) => vec.get(*self), _ => None, } } fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> { match *v { Value::Array(ref mut vec) => vec.get_mut(*self), _ => None, } } fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value { match *v { Value::Array(ref mut vec) => { let len = vec.len(); vec.get_mut(*self).unwrap_or_else(|| { panic!( "cannot access index {} of JSON array of length {}", self, len ) }) } _ => panic!("cannot access index {} of JSON {}", self, Type(v)), } } } impl Index for str { fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> { match *v { Value::Object(ref map) => map.get(self), _ => None, } } fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> { match *v { Value::Object(ref mut map) => map.get_mut(self), _ => None, } } fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value { if let Value::Null = *v { *v = Value::Object(Map::new()); } match *v { Value::Object(ref mut map) => map.entry(self.to_owned()).or_insert(Value::Null), _ => panic!("cannot access key {:?} in JSON {}", self, Type(v)), } } } impl Index for String { fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> { self[..].index_into(v) } fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> { self[..].index_into_mut(v) } fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value { self[..].index_or_insert(v) } } impl<'a, T: ?Sized> Index for &'a T where T: Index, { fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> { (**self).index_into(v) } fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> { (**self).index_into_mut(v) } fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value { (**self).index_or_insert(v) } } // Prevent users from implementing the Index trait. mod private { pub trait Sealed {} impl Sealed for usize {} impl Sealed for str {} impl Sealed for super::String {} impl<'a, T: ?Sized> Sealed for &'a T where T: Sealed {} } /// Used in panic messages. struct Type<'a>(&'a Value); impl<'a> fmt::Display for Type<'a> { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { match *self.0 { Value::Null => formatter.write_str("null"), Value::Bool(_) => formatter.write_str("boolean"), Value::Number(_) => formatter.write_str("number"), Value::String(_) => formatter.write_str("string"), Value::Array(_) => formatter.write_str("array"), Value::Object(_) => formatter.write_str("object"), } } } // The usual semantics of Index is to panic on invalid indexing. // // That said, the usual semantics are for things like Vec and BTreeMap which // have different use cases than Value. If you are working with a Vec, you know // that you are working with a Vec and you can get the len of the Vec and make // sure your indices are within bounds. The Value use cases are more // loosey-goosey. You got some JSON from an endpoint and you want to pull values // out of it. Outside of this Index impl, you already have the option of using // value.as_array() and working with the Vec directly, or matching on // Value::Array and getting the Vec directly. The Index impl means you can skip // that and index directly into the thing using a concise syntax. You don't have // to check the type, you don't have to check the len, it is all about what you // expect the Value to look like. // // Basically the use cases that would be well served by panicking here are // better served by using one of the other approaches: get and get_mut, // as_array, or match. The value of this impl is that it adds a way of working // with Value that is not well served by the existing approaches: concise and // careless and sometimes that is exactly what you want. impl ops::Index for Value where I: Index, { type Output = Value; /// Index into a `serde_json::Value` using the syntax `value[0]` or /// `value["k"]`. /// /// Returns `Value::Null` if the type of `self` does not match the type of /// the index, for example if the index is a string and `self` is an array /// or a number. Also returns `Value::Null` if the given key does not exist /// in the map or the given index is not within the bounds of the array. /// /// For retrieving deeply nested values, you should have a look at the /// `Value::pointer` method. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// let data = json!({ /// "x": { /// "y": ["z", "zz"] /// } /// }); /// /// assert_eq!(data["x"]["y"], json!(["z", "zz"])); /// assert_eq!(data["x"]["y"][0], json!("z")); /// /// assert_eq!(data["a"], json!(null)); // returns null for undefined values /// assert_eq!(data["a"]["b"], json!(null)); // does not panic /// ``` fn index(&self, index: I) -> &Value { static NULL: Value = Value::Null; index.index_into(self).unwrap_or(&NULL) } } impl ops::IndexMut for Value where I: Index, { /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or /// `value["k"] = ...`. /// /// If the index is a number, the value must be an array of length bigger /// than the index. Indexing into a value that is not an array or an array /// that is too small will panic. /// /// If the index is a string, the value must be an object or null which is /// treated like an empty object. If the key is not already present in the /// object, it will be inserted with a value of null. Indexing into a value /// that is neither an object nor null will panic. /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// let mut data = json!({ "x": 0 }); /// /// // replace an existing key /// data["x"] = json!(1); /// /// // insert a new key /// data["y"] = json!([false, false, false]); /// /// // replace an array value /// data["y"][0] = json!(true); /// /// // inserted a deeply nested key /// data["a"]["b"]["c"]["d"] = json!(true); /// /// println!("{}", data); /// ``` fn index_mut(&mut self, index: I) -> &mut Value { index.index_or_insert(self) } } serde_json-1.0.45/src/value/mod.rs010064400017500001750000000715241361214160200152120ustar0000000000000000//! The Value enum, a loosely typed way of representing any valid JSON value. //! //! # Constructing JSON //! //! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value` //! objects with very natural JSON syntax. //! //! ``` //! use serde_json::json; //! //! fn main() { //! // The type of `john` is `serde_json::Value` //! let john = json!({ //! "name": "John Doe", //! "age": 43, //! "phones": [ //! "+44 1234567", //! "+44 2345678" //! ] //! }); //! //! println!("first phone number: {}", john["phones"][0]); //! //! // Convert to a string of JSON and print it out //! println!("{}", john.to_string()); //! } //! ``` //! //! The `Value::to_string()` function converts a `serde_json::Value` into a //! `String` of JSON text. //! //! One neat thing about the `json!` macro is that variables and expressions can //! be interpolated directly into the JSON value as you are building it. Serde //! will check at compile time that the value you are interpolating is able to //! be represented as JSON. //! //! ``` //! # use serde_json::json; //! # //! # fn random_phone() -> u16 { 0 } //! # //! let full_name = "John Doe"; //! let age_last_year = 42; //! //! // The type of `john` is `serde_json::Value` //! let john = json!({ //! "name": full_name, //! "age": age_last_year + 1, //! "phones": [ //! format!("+44 {}", random_phone()) //! ] //! }); //! ``` //! //! A string of JSON data can be parsed into a `serde_json::Value` by the //! [`serde_json::from_str`][from_str] function. There is also //! [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` and //! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or //! a TCP stream. //! //! ``` //! use serde_json::{json, Value, Error}; //! //! fn untyped_example() -> Result<(), Error> { //! // Some JSON input data as a &str. Maybe this comes from the user. //! let data = r#" //! { //! "name": "John Doe", //! "age": 43, //! "phones": [ //! "+44 1234567", //! "+44 2345678" //! ] //! }"#; //! //! // Parse the string of data into serde_json::Value. //! let v: Value = serde_json::from_str(data)?; //! //! // Access parts of the data by indexing with square brackets. //! println!("Please call {} at the number {}", v["name"], v["phones"][0]); //! //! Ok(()) //! } //! # //! # untyped_example().unwrap(); //! ``` //! //! [macro]: https://docs.serde.rs/serde_json/macro.json.html //! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html //! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html //! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html use self::ser::Serializer; use crate::error::Error; use crate::io; use crate::lib::*; use serde::de::DeserializeOwned; use serde::ser::Serialize; pub use self::index::Index; pub use crate::map::Map; pub use crate::number::Number; #[cfg(feature = "raw_value")] pub use crate::raw::RawValue; /// Represents any valid JSON value. /// /// See the `serde_json::value` module documentation for usage examples. #[derive(Clone, PartialEq)] pub enum Value { /// Represents a JSON null value. /// /// ``` /// # use serde_json::json; /// # /// let v = json!(null); /// ``` Null, /// Represents a JSON boolean. /// /// ``` /// # use serde_json::json; /// # /// let v = json!(true); /// ``` Bool(bool), /// Represents a JSON number, whether integer or floating point. /// /// ``` /// # use serde_json::json; /// # /// let v = json!(12.5); /// ``` Number(Number), /// Represents a JSON string. /// /// ``` /// # use serde_json::json; /// # /// let v = json!("a string"); /// ``` String(String), /// Represents a JSON array. /// /// ``` /// # use serde_json::json; /// # /// let v = json!(["an", "array"]); /// ``` Array(Vec), /// Represents a JSON object. /// /// By default the map is backed by a BTreeMap. Enable the `preserve_order` /// feature of serde_json to use IndexMap instead, which preserves /// entries in the order they are inserted into the map. In particular, this /// allows JSON data to be deserialized into a Value and serialized to a /// string while retaining the order of map keys in the input. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "an": "object" }); /// ``` Object(Map), } impl Debug for Value { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { match *self { Value::Null => formatter.debug_tuple("Null").finish(), Value::Bool(v) => formatter.debug_tuple("Bool").field(&v).finish(), Value::Number(ref v) => Debug::fmt(v, formatter), Value::String(ref v) => formatter.debug_tuple("String").field(v).finish(), Value::Array(ref v) => formatter.debug_tuple("Array").field(v).finish(), Value::Object(ref v) => formatter.debug_tuple("Object").field(v).finish(), } } } struct WriterFormatter<'a, 'b: 'a> { inner: &'a mut fmt::Formatter<'b>, } impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> { fn write(&mut self, buf: &[u8]) -> io::Result { fn io_error(_: E) -> io::Error { // Error value does not matter because fmt::Display impl below just // maps it to fmt::Error io::Error::new(io::ErrorKind::Other, "fmt error") } let s = tri!(str::from_utf8(buf).map_err(io_error)); tri!(self.inner.write_str(s).map_err(io_error)); Ok(buf.len()) } fn flush(&mut self) -> io::Result<()> { Ok(()) } } impl fmt::Display for Value { /// Display a JSON value as a string. /// /// ``` /// # use serde_json::json; /// # /// let json = json!({ "city": "London", "street": "10 Downing Street" }); /// /// // Compact format: /// // /// // {"city":"London","street":"10 Downing Street"} /// let compact = format!("{}", json); /// assert_eq!(compact, /// "{\"city\":\"London\",\"street\":\"10 Downing Street\"}"); /// /// // Pretty format: /// // /// // { /// // "city": "London", /// // "street": "10 Downing Street" /// // } /// let pretty = format!("{:#}", json); /// assert_eq!(pretty, /// "{\n \"city\": \"London\",\n \"street\": \"10 Downing Street\"\n}"); /// ``` fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let alternate = f.alternate(); let mut wr = WriterFormatter { inner: f }; if alternate { // {:#} super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error) } else { // {} super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error) } } } fn parse_index(s: &str) -> Option { if s.starts_with('+') || (s.starts_with('0') && s.len() != 1) { return None; } s.parse().ok() } impl Value { /// Index into a JSON array or map. A string index can be used to access a /// value in a map, and a usize index can be used to access an element of an /// array. /// /// Returns `None` if the type of `self` does not match the type of the /// index, for example if the index is a string and `self` is an array or a /// number. Also returns `None` if the given key does not exist in the map /// or the given index is not within the bounds of the array. /// /// ``` /// # use serde_json::json; /// # /// let object = json!({ "A": 65, "B": 66, "C": 67 }); /// assert_eq!(*object.get("A").unwrap(), json!(65)); /// /// let array = json!([ "A", "B", "C" ]); /// assert_eq!(*array.get(2).unwrap(), json!("C")); /// /// assert_eq!(array.get("A"), None); /// ``` /// /// Square brackets can also be used to index into a value in a more concise /// way. This returns `Value::Null` in cases where `get` would have returned /// `None`. /// /// ``` /// # use serde_json::json; /// # /// let object = json!({ /// "A": ["a", "á", "à"], /// "B": ["b", "b́"], /// "C": ["c", "ć", "ć̣", "ḉ"], /// }); /// assert_eq!(object["B"][0], json!("b")); /// /// assert_eq!(object["D"], json!(null)); /// assert_eq!(object[0]["x"]["y"]["z"], json!(null)); /// ``` pub fn get(&self, index: I) -> Option<&Value> { index.index_into(self) } /// Mutably index into a JSON array or map. A string index can be used to /// access a value in a map, and a usize index can be used to access an /// element of an array. /// /// Returns `None` if the type of `self` does not match the type of the /// index, for example if the index is a string and `self` is an array or a /// number. Also returns `None` if the given key does not exist in the map /// or the given index is not within the bounds of the array. /// /// ``` /// # use serde_json::json; /// # /// let mut object = json!({ "A": 65, "B": 66, "C": 67 }); /// *object.get_mut("A").unwrap() = json!(69); /// /// let mut array = json!([ "A", "B", "C" ]); /// *array.get_mut(2).unwrap() = json!("D"); /// ``` pub fn get_mut(&mut self, index: I) -> Option<&mut Value> { index.index_into_mut(self) } /// Returns true if the `Value` is an Object. Returns false otherwise. /// /// For any Value on which `is_object` returns true, `as_object` and /// `as_object_mut` are guaranteed to return the map representation of the /// object. /// /// ``` /// # use serde_json::json; /// # /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] }); /// /// assert!(obj.is_object()); /// assert!(obj["a"].is_object()); /// /// // array, not an object /// assert!(!obj["b"].is_object()); /// ``` pub fn is_object(&self) -> bool { self.as_object().is_some() } /// If the `Value` is an Object, returns the associated Map. Returns None /// otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] }); /// /// // The length of `{"nested": true}` is 1 entry. /// assert_eq!(v["a"].as_object().unwrap().len(), 1); /// /// // The array `["an", "array"]` is not an object. /// assert_eq!(v["b"].as_object(), None); /// ``` pub fn as_object(&self) -> Option<&Map> { match *self { Value::Object(ref map) => Some(map), _ => None, } } /// If the `Value` is an Object, returns the associated mutable Map. /// Returns None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let mut v = json!({ "a": { "nested": true } }); /// /// v["a"].as_object_mut().unwrap().clear(); /// assert_eq!(v, json!({ "a": {} })); /// ``` pub fn as_object_mut(&mut self) -> Option<&mut Map> { match *self { Value::Object(ref mut map) => Some(map), _ => None, } } /// Returns true if the `Value` is an Array. Returns false otherwise. /// /// For any Value on which `is_array` returns true, `as_array` and /// `as_array_mut` are guaranteed to return the vector representing the /// array. /// /// ``` /// # use serde_json::json; /// # /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } }); /// /// assert!(obj["a"].is_array()); /// /// // an object, not an array /// assert!(!obj["b"].is_array()); /// ``` pub fn is_array(&self) -> bool { self.as_array().is_some() } /// If the `Value` is an Array, returns the associated vector. Returns None /// otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } }); /// /// // The length of `["an", "array"]` is 2 elements. /// assert_eq!(v["a"].as_array().unwrap().len(), 2); /// /// // The object `{"an": "object"}` is not an array. /// assert_eq!(v["b"].as_array(), None); /// ``` pub fn as_array(&self) -> Option<&Vec> { match *self { Value::Array(ref array) => Some(&*array), _ => None, } } /// If the `Value` is an Array, returns the associated mutable vector. /// Returns None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let mut v = json!({ "a": ["an", "array"] }); /// /// v["a"].as_array_mut().unwrap().clear(); /// assert_eq!(v, json!({ "a": [] })); /// ``` pub fn as_array_mut(&mut self) -> Option<&mut Vec> { match *self { Value::Array(ref mut list) => Some(list), _ => None, } } /// Returns true if the `Value` is a String. Returns false otherwise. /// /// For any Value on which `is_string` returns true, `as_str` is guaranteed /// to return the string slice. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": "some string", "b": false }); /// /// assert!(v["a"].is_string()); /// /// // The boolean `false` is not a string. /// assert!(!v["b"].is_string()); /// ``` pub fn is_string(&self) -> bool { self.as_str().is_some() } /// If the `Value` is a String, returns the associated str. Returns None /// otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": "some string", "b": false }); /// /// assert_eq!(v["a"].as_str(), Some("some string")); /// /// // The boolean `false` is not a string. /// assert_eq!(v["b"].as_str(), None); /// /// // JSON values are printed in JSON representation, so strings are in quotes. /// // /// // The value is: "some string" /// println!("The value is: {}", v["a"]); /// /// // Rust strings are printed without quotes. /// // /// // The value is: some string /// println!("The value is: {}", v["a"].as_str().unwrap()); /// ``` pub fn as_str(&self) -> Option<&str> { match *self { Value::String(ref s) => Some(s), _ => None, } } /// Returns true if the `Value` is a Number. Returns false otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 1, "b": "2" }); /// /// assert!(v["a"].is_number()); /// /// // The string `"2"` is a string, not a number. /// assert!(!v["b"].is_number()); /// ``` pub fn is_number(&self) -> bool { match *self { Value::Number(_) => true, _ => false, } } /// Returns true if the `Value` is an integer between `i64::MIN` and /// `i64::MAX`. /// /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to /// return the integer value. /// /// ``` /// # use serde_json::json; /// # /// let big = i64::max_value() as u64 + 10; /// let v = json!({ "a": 64, "b": big, "c": 256.0 }); /// /// assert!(v["a"].is_i64()); /// /// // Greater than i64::MAX. /// assert!(!v["b"].is_i64()); /// /// // Numbers with a decimal point are not considered integers. /// assert!(!v["c"].is_i64()); /// ``` pub fn is_i64(&self) -> bool { match *self { Value::Number(ref n) => n.is_i64(), _ => false, } } /// Returns true if the `Value` is an integer between zero and `u64::MAX`. /// /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to /// return the integer value. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 64, "b": -64, "c": 256.0 }); /// /// assert!(v["a"].is_u64()); /// /// // Negative integer. /// assert!(!v["b"].is_u64()); /// /// // Numbers with a decimal point are not considered integers. /// assert!(!v["c"].is_u64()); /// ``` pub fn is_u64(&self) -> bool { match *self { Value::Number(ref n) => n.is_u64(), _ => false, } } /// Returns true if the `Value` is a number that can be represented by f64. /// /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to /// return the floating point value. /// /// Currently this function returns true if and only if both `is_i64` and /// `is_u64` return false but this is not a guarantee in the future. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 256.0, "b": 64, "c": -64 }); /// /// assert!(v["a"].is_f64()); /// /// // Integers. /// assert!(!v["b"].is_f64()); /// assert!(!v["c"].is_f64()); /// ``` pub fn is_f64(&self) -> bool { match *self { Value::Number(ref n) => n.is_f64(), _ => false, } } /// If the `Value` is an integer, represent it as i64 if possible. Returns /// None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let big = i64::max_value() as u64 + 10; /// let v = json!({ "a": 64, "b": big, "c": 256.0 }); /// /// assert_eq!(v["a"].as_i64(), Some(64)); /// assert_eq!(v["b"].as_i64(), None); /// assert_eq!(v["c"].as_i64(), None); /// ``` pub fn as_i64(&self) -> Option { match *self { Value::Number(ref n) => n.as_i64(), _ => None, } } /// If the `Value` is an integer, represent it as u64 if possible. Returns /// None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 64, "b": -64, "c": 256.0 }); /// /// assert_eq!(v["a"].as_u64(), Some(64)); /// assert_eq!(v["b"].as_u64(), None); /// assert_eq!(v["c"].as_u64(), None); /// ``` pub fn as_u64(&self) -> Option { match *self { Value::Number(ref n) => n.as_u64(), _ => None, } } /// If the `Value` is a number, represent it as f64 if possible. Returns /// None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": 256.0, "b": 64, "c": -64 }); /// /// assert_eq!(v["a"].as_f64(), Some(256.0)); /// assert_eq!(v["b"].as_f64(), Some(64.0)); /// assert_eq!(v["c"].as_f64(), Some(-64.0)); /// ``` pub fn as_f64(&self) -> Option { match *self { Value::Number(ref n) => n.as_f64(), _ => None, } } /// Returns true if the `Value` is a Boolean. Returns false otherwise. /// /// For any Value on which `is_boolean` returns true, `as_bool` is /// guaranteed to return the boolean value. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": false, "b": "false" }); /// /// assert!(v["a"].is_boolean()); /// /// // The string `"false"` is a string, not a boolean. /// assert!(!v["b"].is_boolean()); /// ``` pub fn is_boolean(&self) -> bool { self.as_bool().is_some() } /// If the `Value` is a Boolean, returns the associated bool. Returns None /// otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": false, "b": "false" }); /// /// assert_eq!(v["a"].as_bool(), Some(false)); /// /// // The string `"false"` is a string, not a boolean. /// assert_eq!(v["b"].as_bool(), None); /// ``` pub fn as_bool(&self) -> Option { match *self { Value::Bool(b) => Some(b), _ => None, } } /// Returns true if the `Value` is a Null. Returns false otherwise. /// /// For any Value on which `is_null` returns true, `as_null` is guaranteed /// to return `Some(())`. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": null, "b": false }); /// /// assert!(v["a"].is_null()); /// /// // The boolean `false` is not null. /// assert!(!v["b"].is_null()); /// ``` pub fn is_null(&self) -> bool { self.as_null().is_some() } /// If the `Value` is a Null, returns (). Returns None otherwise. /// /// ``` /// # use serde_json::json; /// # /// let v = json!({ "a": null, "b": false }); /// /// assert_eq!(v["a"].as_null(), Some(())); /// /// // The boolean `false` is not null. /// assert_eq!(v["b"].as_null(), None); /// ``` pub fn as_null(&self) -> Option<()> { match *self { Value::Null => Some(()), _ => None, } } /// Looks up a value by a JSON Pointer. /// /// JSON Pointer defines a string syntax for identifying a specific value /// within a JavaScript Object Notation (JSON) document. /// /// A Pointer is a Unicode string with the reference tokens separated by `/`. /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The /// addressed value is returned and if there is no such value `None` is /// returned. /// /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901). /// /// # Examples /// /// ``` /// # use serde_json::json; /// # /// let data = json!({ /// "x": { /// "y": ["z", "zz"] /// } /// }); /// /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz")); /// assert_eq!(data.pointer("/a/b/c"), None); /// ``` pub fn pointer(&self, pointer: &str) -> Option<&Value> { if pointer == "" { return Some(self); } if !pointer.starts_with('/') { return None; } let tokens = pointer .split('/') .skip(1) .map(|x| x.replace("~1", "/").replace("~0", "~")); let mut target = self; for token in tokens { let target_opt = match *target { Value::Object(ref map) => map.get(&token), Value::Array(ref list) => parse_index(&token).and_then(|x| list.get(x)), _ => return None, }; if let Some(t) = target_opt { target = t; } else { return None; } } Some(target) } /// Looks up a value by a JSON Pointer and returns a mutable reference to /// that value. /// /// JSON Pointer defines a string syntax for identifying a specific value /// within a JavaScript Object Notation (JSON) document. /// /// A Pointer is a Unicode string with the reference tokens separated by `/`. /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The /// addressed value is returned and if there is no such value `None` is /// returned. /// /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901). /// /// # Example of Use /// /// ``` /// use serde_json::Value; /// /// fn main() { /// let s = r#"{"x": 1.0, "y": 2.0}"#; /// let mut value: Value = serde_json::from_str(s).unwrap(); /// /// // Check value using read-only pointer /// assert_eq!(value.pointer("/x"), Some(&1.0.into())); /// // Change value with direct assignment /// *value.pointer_mut("/x").unwrap() = 1.5.into(); /// // Check that new value was written /// assert_eq!(value.pointer("/x"), Some(&1.5.into())); /// // Or change the value only if it exists /// value.pointer_mut("/x").map(|v| *v = 1.5.into()); /// /// // "Steal" ownership of a value. Can replace with any valid Value. /// let old_x = value.pointer_mut("/x").map(Value::take).unwrap(); /// assert_eq!(old_x, 1.5); /// assert_eq!(value.pointer("/x").unwrap(), &Value::Null); /// } /// ``` pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value> { if pointer == "" { return Some(self); } if !pointer.starts_with('/') { return None; } let tokens = pointer .split('/') .skip(1) .map(|x| x.replace("~1", "/").replace("~0", "~")); let mut target = self; for token in tokens { // borrow checker gets confused about `target` being mutably borrowed too many times because of the loop // this once-per-loop binding makes the scope clearer and circumvents the error let target_once = target; let target_opt = match *target_once { Value::Object(ref mut map) => map.get_mut(&token), Value::Array(ref mut list) => { parse_index(&token).and_then(move |x| list.get_mut(x)) } _ => return None, }; if let Some(t) = target_opt { target = t; } else { return None; } } Some(target) } /// Takes the value out of the `Value`, leaving a `Null` in its place. /// /// ``` /// # use serde_json::json; /// # /// let mut v = json!({ "x": "y" }); /// assert_eq!(v["x"].take(), json!("y")); /// assert_eq!(v, json!({ "x": null })); /// ``` pub fn take(&mut self) -> Value { mem::replace(self, Value::Null) } } /// The default value is `Value::Null`. /// /// This is useful for handling omitted `Value` fields when deserializing. /// /// # Examples /// /// ``` /// # use serde::Deserialize; /// use serde_json::Value; /// /// #[derive(Deserialize)] /// struct Settings { /// level: i32, /// #[serde(default)] /// extras: Value, /// } /// /// # fn try_main() -> Result<(), serde_json::Error> { /// let data = r#" { "level": 42 } "#; /// let s: Settings = serde_json::from_str(data)?; /// /// assert_eq!(s.level, 42); /// assert_eq!(s.extras, Value::Null); /// # /// # Ok(()) /// # } /// # /// # try_main().unwrap() /// ``` impl Default for Value { fn default() -> Value { Value::Null } } mod de; mod from; mod index; mod partial_eq; mod ser; /// Convert a `T` into `serde_json::Value` which is an enum that can represent /// any valid JSON data. /// /// # Example /// /// ``` /// use serde::Serialize; /// use serde_json::json; /// /// use std::error::Error; /// /// #[derive(Serialize)] /// struct User { /// fingerprint: String, /// location: String, /// } /// /// fn compare_json_values() -> Result<(), Box> { /// let u = User { /// fingerprint: "0xF9BA143B95FF6D82".to_owned(), /// location: "Menlo Park, CA".to_owned(), /// }; /// /// // The type of `expected` is `serde_json::Value` /// let expected = json!({ /// "fingerprint": "0xF9BA143B95FF6D82", /// "location": "Menlo Park, CA", /// }); /// /// let v = serde_json::to_value(u).unwrap(); /// assert_eq!(v, expected); /// /// Ok(()) /// } /// # /// # compare_json_values().unwrap(); /// ``` /// /// # Errors /// /// This conversion can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. /// /// ``` /// use std::collections::BTreeMap; /// /// fn main() { /// // The keys in this map are vectors, not strings. /// let mut map = BTreeMap::new(); /// map.insert(vec![32, 64], "x86"); /// /// println!("{}", serde_json::to_value(map).unwrap_err()); /// } /// ``` // Taking by value is more friendly to iterator adapters, option and result // consumers, etc. See https://github.com/serde-rs/json/pull/149. pub fn to_value(value: T) -> Result where T: Serialize, { value.serialize(Serializer) } /// Interpret a `serde_json::Value` as an instance of type `T`. /// /// # Example /// /// ``` /// use serde::Deserialize; /// use serde_json::json; /// /// #[derive(Deserialize, Debug)] /// struct User { /// fingerprint: String, /// location: String, /// } /// /// fn main() { /// // The type of `j` is `serde_json::Value` /// let j = json!({ /// "fingerprint": "0xF9BA143B95FF6D82", /// "location": "Menlo Park, CA" /// }); /// /// let u: User = serde_json::from_value(j).unwrap(); /// println!("{:#?}", u); /// } /// ``` /// /// # Errors /// /// This conversion can fail if the structure of the Value does not match the /// structure expected by `T`, for example if `T` is a struct type but the Value /// contains something other than a JSON map. It can also fail if the structure /// is correct but `T`'s implementation of `Deserialize` decides that something /// is wrong with the data, for example required struct fields are missing from /// the JSON map or some number is too big to fit in the expected primitive /// type. pub fn from_value(value: Value) -> Result where T: DeserializeOwned, { T::deserialize(value) } serde_json-1.0.45/src/value/partial_eq.rs010064400017500001750000000042131361214163400165500ustar0000000000000000use super::Value; use crate::lib::*; fn eq_i64(value: &Value, other: i64) -> bool { value.as_i64().map_or(false, |i| i == other) } fn eq_u64(value: &Value, other: u64) -> bool { value.as_u64().map_or(false, |i| i == other) } fn eq_f64(value: &Value, other: f64) -> bool { value.as_f64().map_or(false, |i| i == other) } fn eq_bool(value: &Value, other: bool) -> bool { value.as_bool().map_or(false, |i| i == other) } fn eq_str(value: &Value, other: &str) -> bool { value.as_str().map_or(false, |i| i == other) } impl PartialEq for Value { fn eq(&self, other: &str) -> bool { eq_str(self, other) } } impl<'a> PartialEq<&'a str> for Value { fn eq(&self, other: &&str) -> bool { eq_str(self, *other) } } impl PartialEq for str { fn eq(&self, other: &Value) -> bool { eq_str(other, self) } } impl<'a> PartialEq for &'a str { fn eq(&self, other: &Value) -> bool { eq_str(other, *self) } } impl PartialEq for Value { fn eq(&self, other: &String) -> bool { eq_str(self, other.as_str()) } } impl PartialEq for String { fn eq(&self, other: &Value) -> bool { eq_str(other, self.as_str()) } } macro_rules! partialeq_numeric { ($($eq:ident [$($ty:ty)*])*) => { $($( impl PartialEq<$ty> for Value { fn eq(&self, other: &$ty) -> bool { $eq(self, *other as _) } } impl PartialEq for $ty { fn eq(&self, other: &Value) -> bool { $eq(other, *self as _) } } impl<'a> PartialEq<$ty> for &'a Value { fn eq(&self, other: &$ty) -> bool { $eq(*self, *other as _) } } impl<'a> PartialEq<$ty> for &'a mut Value { fn eq(&self, other: &$ty) -> bool { $eq(*self, *other as _) } } )*)* } } partialeq_numeric! { eq_i64[i8 i16 i32 i64 isize] eq_u64[u8 u16 u32 u64 usize] eq_f64[f32 f64] eq_bool[bool] } serde_json-1.0.45/src/value/ser.rs010064400017500001750000000657151361214167400152420ustar0000000000000000use crate::error::{Error, ErrorCode}; use crate::lib::*; use crate::map::Map; use crate::number::Number; use crate::value::{to_value, Value}; use serde::ser::{Impossible, Serialize}; #[cfg(feature = "arbitrary_precision")] use serde::serde_if_integer128; impl Serialize for Value { #[inline] fn serialize(&self, serializer: S) -> Result where S: ::serde::Serializer, { match *self { Value::Null => serializer.serialize_unit(), Value::Bool(b) => serializer.serialize_bool(b), Value::Number(ref n) => n.serialize(serializer), Value::String(ref s) => serializer.serialize_str(s), Value::Array(ref v) => v.serialize(serializer), Value::Object(ref m) => { use serde::ser::SerializeMap; let mut map = tri!(serializer.serialize_map(Some(m.len()))); for (k, v) in m { tri!(map.serialize_key(k)); tri!(map.serialize_value(v)); } map.end() } } } } pub struct Serializer; impl serde::Serializer for Serializer { type Ok = Value; type Error = Error; type SerializeSeq = SerializeVec; type SerializeTuple = SerializeVec; type SerializeTupleStruct = SerializeVec; type SerializeTupleVariant = SerializeTupleVariant; type SerializeMap = SerializeMap; type SerializeStruct = SerializeMap; type SerializeStructVariant = SerializeStructVariant; #[inline] fn serialize_bool(self, value: bool) -> Result { Ok(Value::Bool(value)) } #[inline] fn serialize_i8(self, value: i8) -> Result { self.serialize_i64(value as i64) } #[inline] fn serialize_i16(self, value: i16) -> Result { self.serialize_i64(value as i64) } #[inline] fn serialize_i32(self, value: i32) -> Result { self.serialize_i64(value as i64) } fn serialize_i64(self, value: i64) -> Result { Ok(Value::Number(value.into())) } #[cfg(feature = "arbitrary_precision")] serde_if_integer128! { fn serialize_i128(self, value: i128) -> Result { Ok(Value::Number(value.into())) } } #[inline] fn serialize_u8(self, value: u8) -> Result { self.serialize_u64(value as u64) } #[inline] fn serialize_u16(self, value: u16) -> Result { self.serialize_u64(value as u64) } #[inline] fn serialize_u32(self, value: u32) -> Result { self.serialize_u64(value as u64) } #[inline] fn serialize_u64(self, value: u64) -> Result { Ok(Value::Number(value.into())) } #[cfg(feature = "arbitrary_precision")] serde_if_integer128! { fn serialize_u128(self, value: u128) -> Result { Ok(Value::Number(value.into())) } } #[inline] fn serialize_f32(self, value: f32) -> Result { self.serialize_f64(value as f64) } #[inline] fn serialize_f64(self, value: f64) -> Result { Ok(Number::from_f64(value).map_or(Value::Null, Value::Number)) } #[inline] fn serialize_char(self, value: char) -> Result { let mut s = String::new(); s.push(value); self.serialize_str(&s) } #[inline] fn serialize_str(self, value: &str) -> Result { Ok(Value::String(value.to_owned())) } fn serialize_bytes(self, value: &[u8]) -> Result { let vec = value.iter().map(|&b| Value::Number(b.into())).collect(); Ok(Value::Array(vec)) } #[inline] fn serialize_unit(self) -> Result { Ok(Value::Null) } #[inline] fn serialize_unit_struct(self, _name: &'static str) -> Result { self.serialize_unit() } #[inline] fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result { self.serialize_str(variant) } #[inline] fn serialize_newtype_struct( self, _name: &'static str, value: &T, ) -> Result where T: Serialize, { value.serialize(self) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T, ) -> Result where T: Serialize, { let mut values = Map::new(); values.insert(String::from(variant), tri!(to_value(&value))); Ok(Value::Object(values)) } #[inline] fn serialize_none(self) -> Result { self.serialize_unit() } #[inline] fn serialize_some(self, value: &T) -> Result where T: Serialize, { value.serialize(self) } fn serialize_seq(self, len: Option) -> Result { Ok(SerializeVec { vec: Vec::with_capacity(len.unwrap_or(0)), }) } fn serialize_tuple(self, len: usize) -> Result { self.serialize_seq(Some(len)) } fn serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result { self.serialize_seq(Some(len)) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result { Ok(SerializeTupleVariant { name: String::from(variant), vec: Vec::with_capacity(len), }) } fn serialize_map(self, _len: Option) -> Result { Ok(SerializeMap::Map { map: Map::new(), next_key: None, }) } fn serialize_struct( self, name: &'static str, len: usize, ) -> Result { match name { #[cfg(feature = "arbitrary_precision")] crate::number::TOKEN => Ok(SerializeMap::Number { out_value: None }), #[cfg(feature = "raw_value")] crate::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }), _ => self.serialize_map(Some(len)), } } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, _len: usize, ) -> Result { Ok(SerializeStructVariant { name: String::from(variant), map: Map::new(), }) } } pub struct SerializeVec { vec: Vec, } pub struct SerializeTupleVariant { name: String, vec: Vec, } pub enum SerializeMap { Map { map: Map, next_key: Option, }, #[cfg(feature = "arbitrary_precision")] Number { out_value: Option }, #[cfg(feature = "raw_value")] RawValue { out_value: Option }, } pub struct SerializeStructVariant { name: String, map: Map, } impl serde::ser::SerializeSeq for SerializeVec { type Ok = Value; type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<(), Error> where T: Serialize, { self.vec.push(tri!(to_value(&value))); Ok(()) } fn end(self) -> Result { Ok(Value::Array(self.vec)) } } impl serde::ser::SerializeTuple for SerializeVec { type Ok = Value; type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<(), Error> where T: Serialize, { serde::ser::SerializeSeq::serialize_element(self, value) } fn end(self) -> Result { serde::ser::SerializeSeq::end(self) } } impl serde::ser::SerializeTupleStruct for SerializeVec { type Ok = Value; type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<(), Error> where T: Serialize, { serde::ser::SerializeSeq::serialize_element(self, value) } fn end(self) -> Result { serde::ser::SerializeSeq::end(self) } } impl serde::ser::SerializeTupleVariant for SerializeTupleVariant { type Ok = Value; type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<(), Error> where T: Serialize, { self.vec.push(tri!(to_value(&value))); Ok(()) } fn end(self) -> Result { let mut object = Map::new(); object.insert(self.name, Value::Array(self.vec)); Ok(Value::Object(object)) } } impl serde::ser::SerializeMap for SerializeMap { type Ok = Value; type Error = Error; fn serialize_key(&mut self, key: &T) -> Result<(), Error> where T: Serialize, { match *self { SerializeMap::Map { ref mut next_key, .. } => { *next_key = Some(tri!(key.serialize(MapKeySerializer))); Ok(()) } #[cfg(feature = "arbitrary_precision")] SerializeMap::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] SerializeMap::RawValue { .. } => unreachable!(), } } fn serialize_value(&mut self, value: &T) -> Result<(), Error> where T: Serialize, { match *self { SerializeMap::Map { ref mut map, ref mut next_key, } => { let key = next_key.take(); // Panic because this indicates a bug in the program rather than an // expected failure. let key = key.expect("serialize_value called before serialize_key"); map.insert(key, tri!(to_value(&value))); Ok(()) } #[cfg(feature = "arbitrary_precision")] SerializeMap::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] SerializeMap::RawValue { .. } => unreachable!(), } } fn end(self) -> Result { match self { SerializeMap::Map { map, .. } => Ok(Value::Object(map)), #[cfg(feature = "arbitrary_precision")] SerializeMap::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] SerializeMap::RawValue { .. } => unreachable!(), } } } struct MapKeySerializer; fn key_must_be_a_string() -> Error { Error::syntax(ErrorCode::KeyMustBeAString, 0, 0) } impl serde::Serializer for MapKeySerializer { type Ok = String; type Error = Error; type SerializeSeq = Impossible; type SerializeTuple = Impossible; type SerializeTupleStruct = Impossible; type SerializeTupleVariant = Impossible; type SerializeMap = Impossible; type SerializeStruct = Impossible; type SerializeStructVariant = Impossible; #[inline] fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result { Ok(variant.to_owned()) } #[inline] fn serialize_newtype_struct( self, _name: &'static str, value: &T, ) -> Result where T: Serialize, { value.serialize(self) } fn serialize_bool(self, _value: bool) -> Result { Err(key_must_be_a_string()) } fn serialize_i8(self, value: i8) -> Result { Ok(value.to_string()) } fn serialize_i16(self, value: i16) -> Result { Ok(value.to_string()) } fn serialize_i32(self, value: i32) -> Result { Ok(value.to_string()) } fn serialize_i64(self, value: i64) -> Result { Ok(value.to_string()) } fn serialize_u8(self, value: u8) -> Result { Ok(value.to_string()) } fn serialize_u16(self, value: u16) -> Result { Ok(value.to_string()) } fn serialize_u32(self, value: u32) -> Result { Ok(value.to_string()) } fn serialize_u64(self, value: u64) -> Result { Ok(value.to_string()) } fn serialize_f32(self, _value: f32) -> Result { Err(key_must_be_a_string()) } fn serialize_f64(self, _value: f64) -> Result { Err(key_must_be_a_string()) } #[inline] fn serialize_char(self, value: char) -> Result { Ok({ let mut s = String::new(); s.push(value); s }) } #[inline] fn serialize_str(self, value: &str) -> Result { Ok(value.to_owned()) } fn serialize_bytes(self, _value: &[u8]) -> Result { Err(key_must_be_a_string()) } fn serialize_unit(self) -> Result { Err(key_must_be_a_string()) } fn serialize_unit_struct(self, _name: &'static str) -> Result { Err(key_must_be_a_string()) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(key_must_be_a_string()) } fn serialize_none(self) -> Result { Err(key_must_be_a_string()) } fn serialize_some(self, _value: &T) -> Result where T: Serialize, { Err(key_must_be_a_string()) } fn serialize_seq(self, _len: Option) -> Result { Err(key_must_be_a_string()) } fn serialize_tuple(self, _len: usize) -> Result { Err(key_must_be_a_string()) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } fn serialize_map(self, _len: Option) -> Result { Err(key_must_be_a_string()) } fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(key_must_be_a_string()) } } impl serde::ser::SerializeStruct for SerializeMap { type Ok = Value; type Error = Error; fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> where T: Serialize, { match *self { SerializeMap::Map { .. } => { tri!(serde::ser::SerializeMap::serialize_key(self, key)); serde::ser::SerializeMap::serialize_value(self, value) } #[cfg(feature = "arbitrary_precision")] SerializeMap::Number { ref mut out_value } => { if key == crate::number::TOKEN { *out_value = Some(value.serialize(NumberValueEmitter)?); Ok(()) } else { Err(invalid_number()) } } #[cfg(feature = "raw_value")] SerializeMap::RawValue { ref mut out_value } => { if key == crate::raw::TOKEN { *out_value = Some(value.serialize(RawValueEmitter)?); Ok(()) } else { Err(invalid_raw_value()) } } } } fn end(self) -> Result { match self { SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self), #[cfg(feature = "arbitrary_precision")] SerializeMap::Number { out_value, .. } => { Ok(out_value.expect("number value was not emitted")) } #[cfg(feature = "raw_value")] SerializeMap::RawValue { out_value, .. } => { Ok(out_value.expect("raw value was not emitted")) } } } } impl serde::ser::SerializeStructVariant for SerializeStructVariant { type Ok = Value; type Error = Error; fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> where T: Serialize, { self.map.insert(String::from(key), tri!(to_value(&value))); Ok(()) } fn end(self) -> Result { let mut object = Map::new(); object.insert(self.name, Value::Object(self.map)); Ok(Value::Object(object)) } } #[cfg(feature = "arbitrary_precision")] struct NumberValueEmitter; #[cfg(feature = "arbitrary_precision")] fn invalid_number() -> Error { Error::syntax(ErrorCode::InvalidNumber, 0, 0) } #[cfg(feature = "arbitrary_precision")] impl serde::ser::Serializer for NumberValueEmitter { type Ok = Value; type Error = Error; type SerializeSeq = Impossible; type SerializeTuple = Impossible; type SerializeTupleStruct = Impossible; type SerializeTupleVariant = Impossible; type SerializeMap = Impossible; type SerializeStruct = Impossible; type SerializeStructVariant = Impossible; fn serialize_bool(self, _v: bool) -> Result { Err(invalid_number()) } fn serialize_i8(self, _v: i8) -> Result { Err(invalid_number()) } fn serialize_i16(self, _v: i16) -> Result { Err(invalid_number()) } fn serialize_i32(self, _v: i32) -> Result { Err(invalid_number()) } fn serialize_i64(self, _v: i64) -> Result { Err(invalid_number()) } fn serialize_u8(self, _v: u8) -> Result { Err(invalid_number()) } fn serialize_u16(self, _v: u16) -> Result { Err(invalid_number()) } fn serialize_u32(self, _v: u32) -> Result { Err(invalid_number()) } fn serialize_u64(self, _v: u64) -> Result { Err(invalid_number()) } fn serialize_f32(self, _v: f32) -> Result { Err(invalid_number()) } fn serialize_f64(self, _v: f64) -> Result { Err(invalid_number()) } fn serialize_char(self, _v: char) -> Result { Err(invalid_number()) } fn serialize_str(self, value: &str) -> Result { let n = tri!(value.to_owned().parse()); Ok(Value::Number(n)) } fn serialize_bytes(self, _value: &[u8]) -> Result { Err(invalid_number()) } fn serialize_none(self) -> Result { Err(invalid_number()) } fn serialize_some(self, _value: &T) -> Result where T: Serialize, { Err(invalid_number()) } fn serialize_unit(self) -> Result { Err(invalid_number()) } fn serialize_unit_struct(self, _name: &'static str) -> Result { Err(invalid_number()) } fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, ) -> Result { Err(invalid_number()) } fn serialize_newtype_struct( self, _name: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(invalid_number()) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(invalid_number()) } fn serialize_seq(self, _len: Option) -> Result { Err(invalid_number()) } fn serialize_tuple(self, _len: usize) -> Result { Err(invalid_number()) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } fn serialize_map(self, _len: Option) -> Result { Err(invalid_number()) } fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(invalid_number()) } } #[cfg(feature = "raw_value")] struct RawValueEmitter; #[cfg(feature = "raw_value")] fn invalid_raw_value() -> Error { Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0) } #[cfg(feature = "raw_value")] impl serde::ser::Serializer for RawValueEmitter { type Ok = Value; type Error = Error; type SerializeSeq = Impossible; type SerializeTuple = Impossible; type SerializeTupleStruct = Impossible; type SerializeTupleVariant = Impossible; type SerializeMap = Impossible; type SerializeStruct = Impossible; type SerializeStructVariant = Impossible; fn serialize_bool(self, _v: bool) -> Result { Err(invalid_raw_value()) } fn serialize_i8(self, _v: i8) -> Result { Err(invalid_raw_value()) } fn serialize_i16(self, _v: i16) -> Result { Err(invalid_raw_value()) } fn serialize_i32(self, _v: i32) -> Result { Err(invalid_raw_value()) } fn serialize_i64(self, _v: i64) -> Result { Err(invalid_raw_value()) } fn serialize_u8(self, _v: u8) -> Result { Err(invalid_raw_value()) } fn serialize_u16(self, _v: u16) -> Result { Err(invalid_raw_value()) } fn serialize_u32(self, _v: u32) -> Result { Err(invalid_raw_value()) } fn serialize_u64(self, _v: u64) -> Result { Err(invalid_raw_value()) } fn serialize_f32(self, _v: f32) -> Result { Err(invalid_raw_value()) } fn serialize_f64(self, _v: f64) -> Result { Err(invalid_raw_value()) } fn serialize_char(self, _v: char) -> Result { Err(invalid_raw_value()) } fn serialize_str(self, value: &str) -> Result { crate::from_str(value) } fn serialize_bytes(self, _value: &[u8]) -> Result { Err(invalid_raw_value()) } fn serialize_none(self) -> Result { Err(invalid_raw_value()) } fn serialize_some(self, _value: &T) -> Result where T: Serialize, { Err(invalid_raw_value()) } fn serialize_unit(self) -> Result { Err(invalid_raw_value()) } fn serialize_unit_struct(self, _name: &'static str) -> Result { Err(invalid_raw_value()) } fn serialize_unit_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, ) -> Result { Err(invalid_raw_value()) } fn serialize_newtype_struct( self, _name: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(invalid_raw_value()) } fn serialize_newtype_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T, ) -> Result where T: Serialize, { Err(invalid_raw_value()) } fn serialize_seq(self, _len: Option) -> Result { Err(invalid_raw_value()) } fn serialize_tuple(self, _len: usize) -> Result { Err(invalid_raw_value()) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(invalid_raw_value()) } fn serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(invalid_raw_value()) } fn serialize_map(self, _len: Option) -> Result { Err(invalid_raw_value()) } fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result { Err(invalid_raw_value()) } fn serialize_struct_variant( self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { Err(invalid_raw_value()) } } serde_json-1.0.45/.cargo_vcs_info.json0000644000000001121361216173500133530ustar00{ "git": { "sha1": "a39bcade70cc4e7d2f2f957fa738d3dc54b5338c" } }