aboutsummaryrefslogtreecommitdiff
path: root/src/ser.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/ser.rs')
-rw-r--r--src/ser.rs406
1 files changed, 161 insertions, 245 deletions
diff --git a/src/ser.rs b/src/ser.rs
index db77cd8..80c2deb 100644
--- a/src/ser.rs
+++ b/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)
}
}
@@ -533,22 +493,17 @@ where
where
T: ?Sized + Serialize,
{
- match *self {
- Compound::Map {
- ref mut ser,
- ref mut state,
- } => {
+ match self {
+ Compound::Map { ser, 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
+ ser.formatter
.end_array_value(&mut ser.writer)
- .map_err(Error::io));
- Ok(())
+ .map_err(Error::io)
}
#[cfg(feature = "arbitrary_precision")]
Compound::Number { .. } => unreachable!(),
@@ -560,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")]
@@ -647,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!(),
@@ -671,11 +622,8 @@ where
where
T: ?Sized + Serialize,
{
- match *self {
- Compound::Map {
- ref mut ser,
- ref mut state,
- } => {
+ match self {
+ Compound::Map { ser, state } => {
tri!(ser
.formatter
.begin_object_key(&mut ser.writer, *state == State::First)
@@ -684,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!(),
@@ -702,18 +648,16 @@ where
where
T: ?Sized + Serialize,
{
- match *self {
- Compound::Map { ref mut ser, .. } => {
+ match self {
+ Compound::Map { ser, .. } => {
tri!(ser
.formatter
.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!(),
@@ -725,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")]
@@ -753,22 +694,20 @@ where
where
T: ?Sized + Serialize,
{
- match *self {
+ match self {
Compound::Map { .. } => ser::SerializeMap::serialize_entry(self, key, value),
#[cfg(feature = "arbitrary_precision")]
- Compound::Number { ref mut ser, .. } => {
+ Compound::Number { ser, .. } => {
if key == crate::number::TOKEN {
- tri!(value.serialize(NumberStrEmitter(ser)));
- Ok(())
+ value.serialize(NumberStrEmitter(ser))
} else {
Err(invalid_number())
}
}
#[cfg(feature = "raw_value")]
- Compound::RawValue { ref mut ser, .. } => {
+ Compound::RawValue { ser, .. } => {
if key == crate::raw::TOKEN {
- tri!(value.serialize(RawValueStrEmitter(ser)));
- Ok(())
+ value.serialize(RawValueStrEmitter(ser))
} else {
Err(invalid_raw_value())
}
@@ -822,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!(),
@@ -905,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<()> {
@@ -924,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<()> {
@@ -943,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<()> {
@@ -962,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<()> {
@@ -1002,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<()> {
@@ -1021,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<()> {
@@ -1040,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<()> {
@@ -1059,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<()> {
@@ -1224,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<()> {
@@ -1246,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<()> {
@@ -1405,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<()> {
@@ -1427,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<()> {
@@ -1667,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<()>
@@ -1711,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<()>
@@ -1991,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]
@@ -2039,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)
}
@@ -2072,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>(
@@ -2105,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
@@ -2158,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
@@ -2177,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.
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-20 03:03:50 +0000