#[cfg(target_has_atomic = "ptr")]
use alloc::sync::Arc;
use alloc::{
borrow::Cow,
boxed::Box,
collections::{BTreeMap, BTreeSet, VecDeque},
rc::Rc,
string::String,
vec::Vec,
};
use core::convert::Infallible;
use crate::{Array, Format, Number, Object, RawValue, Value, number, write};
pub(crate) trait Flush {
fn flush(&mut self, buf: &mut String);
}
pub(crate) struct Keep;
impl Flush for Keep {
#[inline]
fn flush(&mut self, _buf: &mut String) {}
}
#[cfg(feature = "std")]
pub(crate) struct IoSink<'a> {
pub(crate) writer: &'a mut dyn std::io::Write,
pub(crate) error: Option<std::io::Error>,
}
#[cfg(feature = "std")]
impl Flush for IoSink<'_> {
fn flush(&mut self, buf: &mut String) {
if self.error.is_none() {
if let Err(e) = self.writer.write_all(buf.as_bytes()) {
self.error = Some(e);
}
}
buf.clear();
}
}
pub(crate) struct Out<'w> {
pub(crate) buf: &'w mut String,
pub(crate) sink: &'w mut dyn Flush,
pub(crate) flush_at: usize,
pub(crate) format: Format,
pub(crate) depth: usize,
}
impl Out<'_> {
#[inline]
pub(crate) fn at(&mut self, depth: usize) -> Out<'_> {
Out {
buf: &mut *self.buf,
sink: &mut *self.sink,
flush_at: self.flush_at,
format: self.format,
depth,
}
}
#[inline]
fn done(&mut self) -> Written {
if self.buf.len() >= self.flush_at {
self.sink.flush(self.buf);
}
Written(())
}
}
#[must_use = "return it from `to_json`"]
#[derive(Debug)]
pub struct Written(pub(crate) ());
pub struct ValueWriter<'w> {
out: Out<'w>,
}
impl<'w> ValueWriter<'w> {
#[inline]
pub(crate) const fn new(out: Out<'w>) -> Self {
Self { out }
}
#[inline]
pub fn null(mut self) -> Written {
self.out.buf.push_str("null");
self.out.done()
}
#[inline]
pub fn bool(mut self, value: bool) -> Written {
if value {
self.out.buf.push_str("true");
} else {
self.out.buf.push_str("false");
}
self.out.done()
}
#[inline]
pub fn i64(mut self, value: i64) -> Written {
number::write_i64(self.out.buf, value);
self.out.done()
}
#[inline]
pub fn u64(mut self, value: u64) -> Written {
number::write_u64(self.out.buf, value);
self.out.done()
}
#[inline]
pub fn i128(mut self, value: i128) -> Written {
number::write_i128(self.out.buf, value);
self.out.done()
}
#[inline]
pub fn u128(mut self, value: u128) -> Written {
number::write_u128(self.out.buf, value);
self.out.done()
}
#[inline]
pub fn f64(mut self, value: f64) -> Written {
if !number::write_f64_as(self.out.buf, value, self.out.format) {
self.out.buf.push_str("null");
}
self.out.done()
}
#[inline]
pub fn f32(mut self, value: f32) -> Written {
if !number::write_f32_as(self.out.buf, value, self.out.format) {
self.out.buf.push_str("null");
}
self.out.done()
}
#[inline]
pub fn number(mut self, value: &Number<'_>) -> Written {
self.out.buf.push_str(value.as_str());
self.out.done()
}
#[inline]
pub fn str(mut self, value: &str) -> Written {
write::write_str(self.out.buf, value, self.out.format);
self.out.done()
}
#[inline]
pub fn raw(mut self, value: &RawValue<'_>) -> Written {
crate::write::write_raw(self.out.buf, value.as_str(), self.out.format);
self.out.done()
}
pub fn value(mut self, value: &Value<'_>) -> Written {
let Out {
buf,
sink,
flush_at,
format,
depth,
} = &mut self.out;
let Ok(()) = write::emit::<Infallible>(buf, value, *format, *depth, *flush_at, &mut |b| {
sink.flush(b);
Ok(())
});
self.out.done()
}
#[inline]
pub fn json<T: ToJson + ?Sized>(self, value: &T) -> Written {
value.to_json(self)
}
#[inline]
pub fn object(mut self, members: impl FnOnce(&mut ObjectWriter<'_>)) -> Written {
self.out.buf.push('{');
let depth = self.out.depth;
let mut object = ObjectWriter {
out: self.out.at(depth + 1),
first: true,
};
members(&mut object);
let empty = object.first;
self.close(empty, '}')
}
#[inline]
pub fn array(mut self, items: impl FnOnce(&mut ArrayWriter<'_>)) -> Written {
self.out.buf.push('[');
let depth = self.out.depth;
let mut array = ArrayWriter {
out: self.out.at(depth + 1),
first: true,
};
items(&mut array);
let empty = array.first;
self.close(empty, ']')
}
#[inline]
fn close(mut self, empty: bool, bracket: char) -> Written {
if !empty && self.out.format.pretty {
write::newline(self.out.buf, self.out.depth, self.out.format);
}
self.out.buf.push(bracket);
self.out.done()
}
}
pub struct ObjectWriter<'w> {
out: Out<'w>,
first: bool,
}
impl ObjectWriter<'_> {
#[inline(always)]
fn key(&mut self, key: &str) {
if !self.first {
self.out.buf.push(',');
}
self.first = false;
if self.out.format.pretty {
write::newline(self.out.buf, self.out.depth, self.out.format);
}
write::write_str(self.out.buf, key, self.out.format);
if self.out.format.pretty {
self.out.buf.push_str(": ");
} else {
self.out.buf.push(':');
}
}
#[inline]
pub fn member<T: ToJson + ?Sized>(&mut self, key: &str, value: &T) {
self.key(key);
let depth = self.out.depth;
let Written(()) = value.to_json(ValueWriter::new(self.out.at(depth)));
}
#[inline]
pub fn optional<T: ToJson + ?Sized>(&mut self, key: &str, value: &T) {
if !value.is_absent() {
self.member(key, value);
}
}
#[inline]
pub fn member_with(&mut self, key: &str, value: impl FnOnce(ValueWriter<'_>) -> Written) {
self.key(key);
let depth = self.out.depth;
let Written(()) = value(ValueWriter::new(self.out.at(depth)));
}
}
pub struct ArrayWriter<'w> {
out: Out<'w>,
first: bool,
}
impl ArrayWriter<'_> {
#[inline]
fn next(&mut self) -> ValueWriter<'_> {
if !self.first {
self.out.buf.push(',');
}
self.first = false;
let depth = self.out.depth;
if self.out.format.pretty {
write::newline(self.out.buf, depth, self.out.format);
}
ValueWriter::new(self.out.at(depth))
}
#[inline]
pub fn item<T: ToJson + ?Sized>(&mut self, value: &T) {
let Written(()) = value.to_json(self.next());
}
#[inline]
pub fn item_with(&mut self, value: impl FnOnce(ValueWriter<'_>) -> Written) {
let Written(()) = value(self.next());
}
pub fn items<I>(&mut self, items: I)
where
I: IntoIterator,
I::Item: ToJson,
{
for item in items {
self.item(&item);
}
}
}
pub trait ToJson {
fn to_json(&self, out: ValueWriter<'_>) -> Written;
#[inline]
fn is_absent(&self) -> bool {
false
}
}
pub trait ToJsonKey {
fn to_json_key(&self) -> Cow<'_, str>;
}
impl ToJson for bool {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.bool(*self)
}
}
macro_rules! to_json_integer {
($($t:ty => $method:ident as $via:ty),* $(,)?) => {$(
impl ToJson for $t {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.$method(<$via>::from(*self))
}
}
)*};
}
to_json_integer!(
i8 => i64 as i64, i16 => i64 as i64, i32 => i64 as i64, i64 => i64 as i64,
u8 => u64 as u64, u16 => u64 as u64, u32 => u64 as u64, u64 => u64 as u64,
i128 => i128 as i128, u128 => u128 as u128,
);
impl ToJson for isize {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
match i64::try_from(*self) {
Ok(n) => out.i64(n),
Err(_) => out.i128(*self as i128),
}
}
}
impl ToJson for usize {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
match u64::try_from(*self) {
Ok(n) => out.u64(n),
Err(_) => out.u128(*self as u128),
}
}
}
impl ToJson for f64 {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.f64(*self)
}
}
impl ToJson for f32 {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.f32(*self)
}
}
impl ToJson for str {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.str(self)
}
}
impl ToJson for String {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.str(self)
}
}
impl ToJson for Cow<'_, str> {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.str(self)
}
}
impl ToJson for char {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
let mut utf8 = [0u8; 4];
out.str(self.encode_utf8(&mut utf8))
}
}
impl ToJson for () {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.null()
}
}
impl<T: ToJson> ToJson for Option<T> {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
match self {
Some(value) => value.to_json(out),
None => out.null(),
}
}
#[inline]
fn is_absent(&self) -> bool {
self.is_none()
}
}
macro_rules! to_json_pointer {
($($t:ty),*) => {$(
impl<T: ToJson + ?Sized> ToJson for $t {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
(**self).to_json(out)
}
#[inline]
fn is_absent(&self) -> bool {
(**self).is_absent()
}
}
)*};
}
to_json_pointer!(&T, &mut T, Box<T>, Rc<T>);
#[cfg(target_has_atomic = "ptr")]
to_json_pointer!(Arc<T>);
impl<T: ToJson> ToJson for [T] {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.array(|a| a.items(self))
}
}
impl<T: ToJson, const N: usize> ToJson for [T; N] {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
self.as_slice().to_json(out)
}
}
impl<T: ToJson> ToJson for Vec<T> {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
self.as_slice().to_json(out)
}
}
impl<T: ToJson> ToJson for VecDeque<T> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.array(|a| a.items(self))
}
}
impl<T: ToJson> ToJson for BTreeSet<T> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.array(|a| a.items(self))
}
}
#[cfg(feature = "std")]
impl<T: ToJson, S> ToJson for std::collections::HashSet<T, S> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.array(|a| a.items(self))
}
}
macro_rules! to_json_tuple {
($(($($name:ident),+))*) => {$(
impl<$($name: ToJson),+> ToJson for ($($name,)+) {
#[allow(non_snake_case)]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
let ($($name,)+) = self;
out.array(|a| {
$(a.item($name);)+
})
}
}
)*};
}
to_json_tuple! {
(A)
(A, B)
(A, B, C)
(A, B, C, D)
(A, B, C, D, E)
(A, B, C, D, E, F)
(A, B, C, D, E, F, G)
(A, B, C, D, E, F, G, H)
}
impl<K: ToJsonKey, V: ToJson> ToJson for BTreeMap<K, V> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.object(|o| {
for (key, value) in self {
o.member(&key.to_json_key(), value);
}
})
}
}
#[cfg(feature = "std")]
impl<K: ToJsonKey, V: ToJson, S> ToJson for std::collections::HashMap<K, V, S> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.object(|o| {
for (key, value) in self {
o.member(&key.to_json_key(), value);
}
})
}
}
impl ToJson for Value<'_> {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.value(self)
}
}
impl ToJson for Number<'_> {
#[inline]
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.number(self)
}
}
impl ToJson for Array<'_> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.array(|a| a.items(self.iter()))
}
}
impl ToJson for Object<'_> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.object(|o| {
for (key, value) in self {
o.member(key, value);
}
})
}
}
impl ToJsonKey for str {
#[inline]
fn to_json_key(&self) -> Cow<'_, str> {
Cow::Borrowed(self)
}
}
impl ToJsonKey for String {
#[inline]
fn to_json_key(&self) -> Cow<'_, str> {
Cow::Borrowed(self)
}
}
impl ToJsonKey for Cow<'_, str> {
#[inline]
fn to_json_key(&self) -> Cow<'_, str> {
Cow::Borrowed(self)
}
}
impl ToJsonKey for Box<str> {
#[inline]
fn to_json_key(&self) -> Cow<'_, str> {
Cow::Borrowed(self)
}
}
impl ToJsonKey for char {
#[inline]
fn to_json_key(&self) -> Cow<'_, str> {
let mut utf8 = [0u8; 4];
Cow::Owned(String::from(&*self.encode_utf8(&mut utf8)))
}
}
impl<T: ToJsonKey + ?Sized> ToJsonKey for &T {
#[inline]
fn to_json_key(&self) -> Cow<'_, str> {
(**self).to_json_key()
}
}
#[cfg(test)]
mod tests {
use alloc::{string::ToString, vec};
use super::*;
use crate::{json, to_string, to_string_pretty};
#[test]
fn test_provided_impls_write_their_shapes() {
assert_eq!(
to_string(&(1u8, "two", 3.5f64, None::<u8>, ())),
r#"[1,"two",3.5,null,null]"#
);
assert_eq!(to_string(&[[1, 2], [3, 4]]), "[[1,2],[3,4]]");
assert_eq!(to_string(&Vec::<u8>::new()), "[]");
assert_eq!(to_string(&'q'), r#""q""#);
assert_eq!(to_string(&Box::new(Some(-7i32))), "-7");
assert_eq!(to_string(&Rc::new("rc")), r#""rc""#);
assert_eq!(to_string(&VecDeque::from(vec![true])), "[true]");
assert_eq!(to_string(&BTreeSet::from([2, 1])), "[1,2]");
let map: BTreeMap<&str, Vec<u8>> = [("b", vec![]), ("a", vec![1])].into_iter().collect();
assert_eq!(to_string(&map), r#"{"a":[1],"b":[]}"#);
let chars: BTreeMap<char, u8> = [('x', 1)].into_iter().collect();
assert_eq!(to_string(&chars), r#"{"x":1}"#);
let cow: BTreeMap<Cow<'_, str>, Box<str>> =
[(Cow::Borrowed("k"), Box::from("v"))].into_iter().collect();
assert_eq!(to_string(&cow), r#"{"k":"v"}"#);
let boxed: BTreeMap<Box<str>, String> =
[(Box::from("k"), "v".to_string())].into_iter().collect();
assert_eq!(to_string(&boxed), r#"{"k":"v"}"#);
assert_eq!(
to_string(&(isize::MIN, usize::MAX)),
alloc::format!("[{},{}]", isize::MIN, usize::MAX)
);
assert_eq!(to_string(&(1, 2, 3, 4, 5, 6, 7, 8)), "[1,2,3,4,5,6,7,8]");
assert_eq!(to_string(&f32::NAN), "null");
#[cfg(target_has_atomic = "ptr")]
assert_eq!(to_string(&Arc::new(1u8)), "1");
let mut n = 5u8;
assert_eq!(to_string(&&mut n), "5");
}
#[test]
fn test_crate_types_write_as_themselves() {
let v = json!({ "a": [1, "x", null, {}], "b": { "c": 2.50 } });
assert_eq!(to_string(&v), v.to_string());
let arr = v["a"].as_array().cloned().unwrap_or_default();
assert_eq!(to_string(&arr), r#"[1,"x",null,{}]"#);
let obj = v.as_object().cloned().unwrap_or_default();
assert_eq!(to_string(&obj), v.to_string());
assert_eq!(to_string_pretty(&obj), to_string_pretty(&v));
assert_eq!(to_string(&Number::from(3)), "3");
}
#[test]
fn test_values_nested_in_typed_output_keep_the_pretty_layout() {
struct Wrap<'a>(Value<'a>, Vec<u8>);
impl ToJson for Wrap<'_> {
fn to_json(&self, out: ValueWriter<'_>) -> Written {
out.object(|o| {
o.member("v", &self.0);
o.member("list", &self.1);
o.member_with("empty", |w| w.object(|_| {}));
o.member_with("none", |w| w.array(|_| {}));
})
}
}
let w = Wrap(json!({ "x": [1, { "y": [] }] }), vec![7]);
let expected = json!({
"v": { "x": [1, { "y": [] }] },
"list": [7],
"empty": {},
"none": [],
});
assert_eq!(to_string_pretty(&w), to_string_pretty(&expected));
assert_eq!(to_string(&w), to_string(&expected));
}
#[test]
fn test_dyn_to_json_and_absence() {
let parts: [&dyn ToJson; 3] = [&1u8, &"s", &None::<u8>];
assert_eq!(
to_string(&parts.as_slice().iter().collect::<Vec<_>>()),
r#"[1,"s",null]"#
);
let boxed: Box<Option<u8>> = Box::new(None);
assert!(boxed.is_absent());
assert!(!().is_absent());
}
#[cfg(feature = "std")]
#[test]
fn test_std_collections() {
let map: std::collections::HashMap<String, u8> =
[("k".to_string(), 1)].into_iter().collect();
assert_eq!(to_string(&map), r#"{"k":1}"#);
let set: std::collections::HashSet<u8> = [3].into_iter().collect();
assert_eq!(to_string(&set), "[3]");
}
}