diff options
Diffstat (limited to '')
-rw-r--r-- | vendor/serde_json/src/de.rs | 154 | ||||
-rw-r--r-- | vendor/serde_json/src/lib.rs | 6 | ||||
-rw-r--r-- | vendor/serde_json/src/map.rs | 10 | ||||
-rw-r--r-- | vendor/serde_json/src/number.rs | 37 | ||||
-rw-r--r-- | vendor/serde_json/src/ser.rs | 382 | ||||
-rw-r--r-- | vendor/serde_json/src/value/de.rs | 27 | ||||
-rw-r--r-- | vendor/serde_json/src/value/from.rs | 9 | ||||
-rw-r--r-- | vendor/serde_json/src/value/ser.rs | 15 |
8 files changed, 258 insertions, 382 deletions
diff --git a/vendor/serde_json/src/de.rs b/vendor/serde_json/src/de.rs index ffd0d48c2..88d0f2624 100644 --- a/vendor/serde_json/src/de.rs +++ b/vendor/serde_json/src/de.rs @@ -14,7 +14,7 @@ use core::marker::PhantomData; use core::result; use core::str::FromStr; use serde::de::{self, Expected, Unexpected}; -use serde::{forward_to_deserialize_any, serde_if_integer128}; +use serde::forward_to_deserialize_any; #[cfg(feature = "arbitrary_precision")] use crate::number::NumberDeserializer; @@ -335,31 +335,25 @@ impl<'de, R: Read<'de>> Deserializer<R> { } } - 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(()), - } + 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' => { + } + 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); - 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)) } + Ok(()) } + _ => Err(self.error(ErrorCode::InvalidNumber)), } } @@ -457,30 +451,33 @@ impl<'de, R: Read<'de>> Deserializer<R> { &mut self, positive: bool, mut significand: u64, - mut exponent: i32, + exponent_before_decimal_point: i32, ) -> Result<f64> { self.eat_char(); + let mut exponent_after_decimal_point = 0; while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { let digit = (c - b'0') as u64; if overflow!(significand * 10 + digit, u64::max_value()) { + let exponent = exponent_before_decimal_point + exponent_after_decimal_point; return self.parse_decimal_overflow(positive, significand, exponent); } self.eat_char(); significand = significand * 10 + digit; - exponent -= 1; + exponent_after_decimal_point -= 1; } // Error if there is not at least one digit after the decimal point. - if exponent == 0 { + if exponent_after_decimal_point == 0 { match tri!(self.peek()) { Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)), None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)), } } + let exponent = exponent_before_decimal_point + exponent_after_decimal_point; match tri!(self.peek_or_null()) { b'e' | b'E' => self.parse_exponent(positive, significand, exponent), _ => self.f64_from_parts(positive, significand, exponent), @@ -1437,67 +1434,65 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> { val } - serde_if_integer128! { - fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value> - 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)); - } - }; + fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value> + where + V: de::Visitor<'de>, + { + let mut buf = String::new(); - tri!(self.scan_integer128(&mut buf)); + match tri!(self.parse_whitespace()) { + Some(b'-') => { + self.eat_char(); + buf.push('-'); + } + Some(_) => {} + None => { + return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); + } + }; - let value = match buf.parse() { - Ok(int) => visitor.visit_i128(int), - Err(_) => { - return Err(self.error(ErrorCode::NumberOutOfRange)); - } - }; + tri!(self.scan_integer128(&mut buf)); - match value { - Ok(value) => Ok(value), - Err(err) => Err(self.fix_position(err)), + 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<V>(self, visitor: V) -> Result<V::Value> - 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)); - } + fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value> + 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)); - } - }; + let mut buf = String::new(); + tri!(self.scan_integer128(&mut buf)); - match value { - Ok(value) => Ok(value), - Err(err) => Err(self.fix_position(err)), + 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)), } } @@ -2164,15 +2159,12 @@ where 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_i128 => visit_i128); 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); - } + deserialize_integer_key!(deserialize_u128 => visit_u128); #[inline] fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> diff --git a/vendor/serde_json/src/lib.rs b/vendor/serde_json/src/lib.rs index 3a1983c3f..fdd95a121 100644 --- a/vendor/serde_json/src/lib.rs +++ b/vendor/serde_json/src/lib.rs @@ -279,8 +279,8 @@ //! # 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: +//! without the rest of the Rust standard library. Disable the default "std" +//! feature and enable the "alloc" feature: //! //! ```toml //! [dependencies] @@ -300,7 +300,7 @@ //! [macro]: https://docs.serde.rs/serde_json/macro.json.html //! [`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-core -#![doc(html_root_url = "https://docs.rs/serde_json/1.0.86")] +#![doc(html_root_url = "https://docs.rs/serde_json/1.0.91")] // Ignored clippy lints #![allow( clippy::collapsible_else_if, diff --git a/vendor/serde_json/src/map.rs b/vendor/serde_json/src/map.rs index 87cf54566..3e8a3814c 100644 --- a/vendor/serde_json/src/map.rs +++ b/vendor/serde_json/src/map.rs @@ -197,9 +197,8 @@ impl Map<String, Value> { #[inline] pub fn append(&mut self, other: &mut Self) { #[cfg(feature = "preserve_order")] - for (k, v) in mem::replace(&mut other.map, MapImpl::default()) { - self.map.insert(k, v); - } + self.map + .extend(mem::replace(&mut other.map, MapImpl::default())); #[cfg(not(feature = "preserve_order"))] self.map.append(&mut other.map); } @@ -304,6 +303,11 @@ impl Clone for Map<String, Value> { map: self.map.clone(), } } + + #[inline] + fn clone_from(&mut self, source: &Self) { + self.map.clone_from(&source.map); + } } impl PartialEq for Map<String, Value> { diff --git a/vendor/serde_json/src/number.rs b/vendor/serde_json/src/number.rs index 3c8f6f1bf..21a76411c 100644 --- a/vendor/serde_json/src/number.rs +++ b/vendor/serde_json/src/number.rs @@ -12,10 +12,7 @@ use core::hash::{Hash, Hasher}; use serde::de::{self, Unexpected, Visitor}; #[cfg(feature = "arbitrary_precision")] use serde::de::{IntoDeserializer, MapAccess}; -use serde::{ - forward_to_deserialize_any, serde_if_integer128, Deserialize, Deserializer, Serialize, - Serializer, -}; +use serde::{forward_to_deserialize_any, Deserialize, Deserializer, Serialize, Serializer}; #[cfg(feature = "arbitrary_precision")] pub(crate) const TOKEN: &str = "$serde_json::private::Number"; @@ -540,18 +537,15 @@ impl<'de> Deserializer<'de> for Number { deserialize_number!(deserialize_i16 => visit_i16); deserialize_number!(deserialize_i32 => visit_i32); deserialize_number!(deserialize_i64 => visit_i64); + deserialize_number!(deserialize_i128 => visit_i128); 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_u128 => visit_u128); 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 @@ -568,18 +562,15 @@ impl<'de, 'a> Deserializer<'de> for &'a Number { deserialize_number!(deserialize_i16 => visit_i16); deserialize_number!(deserialize_i32 => visit_i32); deserialize_number!(deserialize_i64 => visit_i64); + deserialize_number!(deserialize_i128 => visit_i128); 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_u128 => visit_u128); 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 @@ -731,21 +722,9 @@ 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<i128> for Number { - fn from(i: i128) -> Self { - let n = itoa::Buffer::new().format(i).to_owned(); - Number { n } - } - } - - impl From<u128> for Number { - fn from(u: u128) -> Self { - let n = itoa::Buffer::new().format(u).to_owned(); - Number { n } - } - } -} +impl_from_unsigned!(u128); +#[cfg(feature = "arbitrary_precision")] +impl_from_signed!(i128); impl Number { #[cfg(not(feature = "arbitrary_precision"))] diff --git a/vendor/serde_json/src/ser.rs b/vendor/serde_json/src/ser.rs index 64cb00e1a..80c2deb0c 100644 --- a/vendor/serde_json/src/ser.rs +++ b/vendor/serde_json/src/ser.rs @@ -7,7 +7,6 @@ use alloc::vec::Vec; use core::fmt::{self, Display}; use core::num::FpCategory; use serde::ser::{self, Impossible, Serialize}; -use serde::serde_if_integer128; /// A structure for serializing Rust values into JSON. #[cfg_attr(docsrs, doc(cfg(feature = "std")))] @@ -75,137 +74,105 @@ where #[inline] fn serialize_bool(self, value: bool) -> Result<()> { - tri!(self - .formatter + self.formatter .write_bool(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_i8(self, value: i8) -> Result<()> { - tri!(self - .formatter + self.formatter .write_i8(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_i16(self, value: i16) -> Result<()> { - tri!(self - .formatter + self.formatter .write_i16(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_i32(self, value: i32) -> Result<()> { - tri!(self - .formatter + self.formatter .write_i32(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_i64(self, value: i64) -> Result<()> { - tri!(self - .formatter + self.formatter .write_i64(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } - 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) - } + fn serialize_i128(self, value: i128) -> Result<()> { + self.formatter + .write_i128(&mut self.writer, value) + .map_err(Error::io) } #[inline] fn serialize_u8(self, value: u8) -> Result<()> { - tri!(self - .formatter + self.formatter .write_u8(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_u16(self, value: u16) -> Result<()> { - tri!(self - .formatter + self.formatter .write_u16(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_u32(self, value: u32) -> Result<()> { - tri!(self - .formatter + self.formatter .write_u32(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] fn serialize_u64(self, value: u64) -> Result<()> { - tri!(self - .formatter + self.formatter .write_u64(&mut self.writer, value) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } - 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) - } + fn serialize_u128(self, value: u128) -> Result<()> { + self.formatter + .write_u128(&mut self.writer, value) + .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)); - } + FpCategory::Nan | FpCategory::Infinite => self + .formatter + .write_null(&mut self.writer) + .map_err(Error::io), + _ => 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)); - } + FpCategory::Nan | FpCategory::Infinite => self + .formatter + .write_null(&mut self.writer) + .map_err(Error::io), + _ => self + .formatter + .write_f64(&mut self.writer, value) + .map_err(Error::io), } - Ok(()) } #[inline] @@ -217,8 +184,7 @@ where #[inline] fn serialize_str(self, value: &str) -> Result<()> { - tri!(format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io)); - Ok(()) + format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io) } #[inline] @@ -233,11 +199,9 @@ where #[inline] fn serialize_unit(self) -> Result<()> { - tri!(self - .formatter + self.formatter .write_null(&mut self.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] @@ -297,11 +261,9 @@ where .formatter .end_object_value(&mut self.writer) .map_err(Error::io)); - tri!(self - .formatter + self.formatter .end_object(&mut self.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[inline] @@ -490,11 +452,9 @@ where } } } - tri!(self - .formatter + self.formatter .end_string(&mut self.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } } @@ -541,11 +501,9 @@ where .map_err(Error::io)); *state = State::Rest; tri!(value.serialize(&mut **ser)); - tri!(ser - .formatter + ser.formatter .end_array_value(&mut ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), @@ -557,13 +515,10 @@ where #[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(()) - } + Compound::Map { ser, state } => match state { + State::Empty => Ok(()), + _ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io), + }, #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] @@ -644,8 +599,7 @@ where .formatter .end_object_value(&mut ser.writer) .map_err(Error::io)); - tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)); - Ok(()) + ser.formatter.end_object(&mut ser.writer).map_err(Error::io) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), @@ -678,11 +632,9 @@ where tri!(key.serialize(MapKeySerializer { ser: *ser })); - tri!(ser - .formatter + ser.formatter .end_object_key(&mut ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), @@ -703,11 +655,9 @@ where .begin_object_value(&mut ser.writer) .map_err(Error::io)); tri!(value.serialize(&mut **ser)); - tri!(ser - .formatter + ser.formatter .end_object_value(&mut ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), @@ -719,13 +669,10 @@ where #[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(()) - } + Compound::Map { ser, state } => match state { + State::Empty => Ok(()), + _ => ser.formatter.end_object(&mut ser.writer).map_err(Error::io), + }, #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), #[cfg(feature = "raw_value")] @@ -752,8 +699,7 @@ where #[cfg(feature = "arbitrary_precision")] Compound::Number { ser, .. } => { if key == crate::number::TOKEN { - tri!(value.serialize(NumberStrEmitter(ser))); - Ok(()) + value.serialize(NumberStrEmitter(ser)) } else { Err(invalid_number()) } @@ -761,8 +707,7 @@ where #[cfg(feature = "raw_value")] Compound::RawValue { ser, .. } => { if key == crate::raw::TOKEN { - tri!(value.serialize(RawValueStrEmitter(ser))); - Ok(()) + value.serialize(RawValueStrEmitter(ser)) } else { Err(invalid_raw_value()) } @@ -816,8 +761,7 @@ where .formatter .end_object_value(&mut ser.writer) .map_err(Error::io)); - tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)); - Ok(()) + ser.formatter.end_object(&mut ser.writer).map_err(Error::io) } #[cfg(feature = "arbitrary_precision")] Compound::Number { .. } => unreachable!(), @@ -899,12 +843,10 @@ where .formatter .write_i8(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } fn serialize_i16(self, value: i16) -> Result<()> { @@ -918,12 +860,10 @@ where .formatter .write_i16(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } fn serialize_i32(self, value: i32) -> Result<()> { @@ -937,12 +877,10 @@ where .formatter .write_i32(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } fn serialize_i64(self, value: i64) -> Result<()> { @@ -956,33 +894,27 @@ where .formatter .write_i64(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } - 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_i128(self, value: i128) -> Result<()> { + tri!(self + .ser + .formatter + .begin_string(&mut self.ser.writer) + .map_err(Error::io)); + tri!(self + .ser + .formatter + .write_i128(&mut self.ser.writer, value) + .map_err(Error::io)); + self.ser + .formatter + .end_string(&mut self.ser.writer) + .map_err(Error::io) } fn serialize_u8(self, value: u8) -> Result<()> { @@ -996,12 +928,10 @@ where .formatter .write_u8(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } fn serialize_u16(self, value: u16) -> Result<()> { @@ -1015,12 +945,10 @@ where .formatter .write_u16(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } fn serialize_u32(self, value: u32) -> Result<()> { @@ -1034,12 +962,10 @@ where .formatter .write_u32(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } fn serialize_u64(self, value: u64) -> Result<()> { @@ -1053,33 +979,27 @@ where .formatter .write_u64(&mut self.ser.writer, value) .map_err(Error::io)); - tri!(self - .ser + self.ser .formatter .end_string(&mut self.ser.writer) - .map_err(Error::io)); - Ok(()) + .map_err(Error::io) } - 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_u128(self, value: u128) -> Result<()> { + tri!(self + .ser + .formatter + .begin_string(&mut self.ser.writer) + .map_err(Error::io)); + tri!(self + .ser + .formatter + .write_u128(&mut self.ser.writer, value) + .map_err(Error::io)); + self.ser + .formatter + .end_string(&mut self.ser.writer) + .map_err(Error::io) } fn serialize_f32(self, _value: f32) -> Result<()> { @@ -1218,10 +1138,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W, Err(invalid_number()) } - serde_if_integer128! { - fn serialize_i128(self, _v: i128) -> Result<()> { - Err(invalid_number()) - } + fn serialize_i128(self, _v: i128) -> Result<()> { + Err(invalid_number()) } fn serialize_u8(self, _v: u8) -> Result<()> { @@ -1240,10 +1158,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W, Err(invalid_number()) } - serde_if_integer128! { - fn serialize_u128(self, _v: u128) -> Result<()> { - Err(invalid_number()) - } + fn serialize_u128(self, _v: u128) -> Result<()> { + Err(invalid_number()) } fn serialize_f32(self, _v: f32) -> Result<()> { @@ -1399,10 +1315,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a, Err(ser::Error::custom("expected RawValue")) } - serde_if_integer128! { - fn serialize_i128(self, _v: i128) -> Result<()> { - Err(ser::Error::custom("expected RawValue")) - } + fn serialize_i128(self, _v: i128) -> Result<()> { + Err(ser::Error::custom("expected RawValue")) } fn serialize_u8(self, _v: u8) -> Result<()> { @@ -1421,10 +1335,8 @@ impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a, Err(ser::Error::custom("expected RawValue")) } - serde_if_integer128! { - fn serialize_u128(self, _v: u128) -> Result<()> { - Err(ser::Error::custom("expected RawValue")) - } + fn serialize_u128(self, _v: u128) -> Result<()> { + Err(ser::Error::custom("expected RawValue")) } fn serialize_f32(self, _v: f32) -> Result<()> { @@ -1661,6 +1573,17 @@ pub trait Formatter { writer.write_all(s.as_bytes()) } + /// Writes an integer value like `-123` to the specified writer. + #[inline] + fn write_i128<W>(&mut self, writer: &mut W, value: i128) -> io::Result<()> + where + W: ?Sized + 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<W>(&mut self, writer: &mut W, value: u8) -> io::Result<()> @@ -1705,6 +1628,17 @@ pub trait Formatter { writer.write_all(s.as_bytes()) } + /// Writes an integer value like `123` to the specified writer. + #[inline] + fn write_u128<W>(&mut self, writer: &mut W, value: u128) -> io::Result<()> + where + W: ?Sized + 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<W>(&mut self, writer: &mut W, value: f32) -> io::Result<()> @@ -1985,13 +1919,8 @@ impl<'a> Formatter for PrettyFormatter<'a> { where W: ?Sized + 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(()) + tri!(writer.write_all(if first { b"\n" } else { b",\n" })); + indent(writer, self.current_indent, self.indent) } #[inline] @@ -2033,11 +1962,7 @@ impl<'a> Formatter for PrettyFormatter<'a> { where W: ?Sized + io::Write, { - if first { - tri!(writer.write_all(b"\n")); - } else { - tri!(writer.write_all(b",\n")); - } + tri!(writer.write_all(if first { b"\n" } else { b",\n" })); indent(writer, self.current_indent, self.indent) } @@ -2066,8 +1991,7 @@ where { tri!(formatter.begin_string(writer)); tri!(format_escaped_str_contents(writer, formatter, value)); - tri!(formatter.end_string(writer)); - Ok(()) + formatter.end_string(writer) } fn format_escaped_str_contents<W, F>( @@ -2099,11 +2023,11 @@ where start = i + 1; } - if start != bytes.len() { - tri!(formatter.write_string_fragment(writer, &value[start..])); + if start == bytes.len() { + return Ok(()); } - Ok(()) + formatter.write_string_fragment(writer, &value[start..]) } const BB: u8 = b'b'; // \x08 @@ -2152,8 +2076,7 @@ where T: ?Sized + Serialize, { let mut ser = Serializer::new(writer); - tri!(value.serialize(&mut ser)); - Ok(()) + value.serialize(&mut ser) } /// Serialize the given data structure as pretty-printed JSON into the IO @@ -2171,8 +2094,7 @@ where T: ?Sized + Serialize, { let mut ser = Serializer::pretty(writer); - tri!(value.serialize(&mut ser)); - Ok(()) + value.serialize(&mut ser) } /// Serialize the given data structure as a JSON byte vector. diff --git a/vendor/serde_json/src/value/de.rs b/vendor/serde_json/src/value/de.rs index cc1d38565..9c266d08a 100644 --- a/vendor/serde_json/src/value/de.rs +++ b/vendor/serde_json/src/value/de.rs @@ -14,7 +14,7 @@ use serde::de::{ self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor, }; -use serde::{forward_to_deserialize_any, serde_if_integer128}; +use serde::forward_to_deserialize_any; #[cfg(feature = "arbitrary_precision")] use crate::number::NumberFromString; @@ -228,18 +228,15 @@ impl<'de> serde::Deserializer<'de> for Value { deserialize_number!(deserialize_i16); deserialize_number!(deserialize_i32); deserialize_number!(deserialize_i64); + deserialize_number!(deserialize_i128); deserialize_number!(deserialize_u8); deserialize_number!(deserialize_u16); deserialize_number!(deserialize_u32); deserialize_number!(deserialize_u64); + deserialize_number!(deserialize_u128); deserialize_number!(deserialize_f32); deserialize_number!(deserialize_f64); - serde_if_integer128! { - deserialize_number!(deserialize_i128); - deserialize_number!(deserialize_u128); - } - #[inline] fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where @@ -724,18 +721,15 @@ impl<'de> serde::Deserializer<'de> for &'de Value { deserialize_value_ref_number!(deserialize_i16); deserialize_value_ref_number!(deserialize_i32); deserialize_value_ref_number!(deserialize_i64); + deserialize_number!(deserialize_i128); 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_number!(deserialize_u128); deserialize_value_ref_number!(deserialize_f32); deserialize_value_ref_number!(deserialize_f64); - serde_if_integer128! { - deserialize_number!(deserialize_i128); - deserialize_number!(deserialize_u128); - } - fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where V: Visitor<'de>, @@ -1000,7 +994,7 @@ impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> { V: Visitor<'de>, { match self.value { - Some(&Value::Array(ref v)) => { + Some(Value::Array(v)) => { if v.is_empty() { visitor.visit_unit() } else { @@ -1027,7 +1021,7 @@ impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> { V: Visitor<'de>, { match self.value { - Some(&Value::Object(ref v)) => visit_object_ref(v, visitor), + Some(Value::Object(v)) => visit_object_ref(v, visitor), Some(other) => Err(serde::de::Error::invalid_type( other.unexpected(), &"struct variant", @@ -1156,15 +1150,12 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> { 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_i128 => visit_i128); 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); - } + deserialize_integer_key!(deserialize_u128 => visit_u128); #[inline] fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> diff --git a/vendor/serde_json/src/value/from.rs b/vendor/serde_json/src/value/from.rs index 858a6e48a..c5a6a3960 100644 --- a/vendor/serde_json/src/value/from.rs +++ b/vendor/serde_json/src/value/from.rs @@ -6,9 +6,6 @@ use alloc::string::{String, ToString}; use alloc::vec::Vec; use core::iter::FromIterator; -#[cfg(feature = "arbitrary_precision")] -use serde::serde_if_integer128; - macro_rules! from_integer { ($($ty:ident)*) => { $( @@ -27,10 +24,8 @@ from_integer! { } #[cfg(feature = "arbitrary_precision")] -serde_if_integer128! { - from_integer! { - i128 u128 - } +from_integer! { + i128 u128 } impl From<f32> for Value { diff --git a/vendor/serde_json/src/value/ser.rs b/vendor/serde_json/src/value/ser.rs index 37e495f65..892a63d5f 100644 --- a/vendor/serde_json/src/value/ser.rs +++ b/vendor/serde_json/src/value/ser.rs @@ -9,9 +9,6 @@ use core::fmt::Display; use core::result; use serde::ser::{Impossible, Serialize}; -#[cfg(feature = "arbitrary_precision")] -use serde::serde_if_integer128; - impl Serialize for Value { #[inline] fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error> @@ -96,10 +93,8 @@ impl serde::Serializer for Serializer { } #[cfg(feature = "arbitrary_precision")] - serde_if_integer128! { - fn serialize_i128(self, value: i128) -> Result<Value> { - Ok(Value::Number(value.into())) - } + fn serialize_i128(self, value: i128) -> Result<Value> { + Ok(Value::Number(value.into())) } #[inline] @@ -123,10 +118,8 @@ impl serde::Serializer for Serializer { } #[cfg(feature = "arbitrary_precision")] - serde_if_integer128! { - fn serialize_u128(self, value: u128) -> Result<Value> { - Ok(Value::Number(value.into())) - } + fn serialize_u128(self, value: u128) -> Result<Value> { + Ok(Value::Number(value.into())) } #[inline] |