json-streaming 1.0.3

a library for reading and writing JSON from / to a stream without the need to materialize the data in memory. Provides both blocking and async APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

pub(crate) mod array;
pub(crate) mod io;
pub(crate) mod json_writer;
pub(crate) mod object;
pub(crate) mod read;

#[cfg(not(test))]
#[allow(unused_imports)]
pub use array::*;
#[allow(unused_imports)]
pub use io::*;
#[allow(unused_imports)]
pub use json_writer::*;
#[cfg(not(test))]
#[allow(unused_imports)]
pub use object::*;

#[allow(unused_imports)]
pub use read::*;


#[cfg(test)]
mod tests {
    use crate::nonblocking::json_writer::JsonWriter;
    use crate::nonblocking::object::JsonObject;
    use crate::shared::*;
    use std::io;

    async fn do_write_json<F: JsonFormatter>(o: &mut JsonObject<'_, '_, Vec<u8>, F, DefaultFloatFormat>) -> io::Result<()> {
        o.write_string_value("abc", "yo").await?;
        o.write_string_value("xyz", "yo").await?;

        let mut na = o.start_array("aaaa").await?;
        na.write_string_value("111").await?;
        na.write_string_value("11").await?;
        na.start_object().await?.end().await?;
        na.start_array().await?.end().await?;

        na.write_null_value().await?;
        na.write_bool_value(true).await?;
        na.write_bool_value(false).await?;
        na.write_i32_value(-23987).await?;
        na.write_u128_value(23987u128).await?;
        na.write_f64_value(23.235).await?;
        na.write_f64_value(f64::INFINITY).await?;
        na.write_f64_value(f64::NAN).await?;
        na.write_f32_value(23.235).await?;
        na.write_f32_value(f32::INFINITY).await?;
        na.write_f32_value(f32::NAN).await?;
        na.end().await?;

        let mut nested = o.start_object("ooo").await?;
        nested.write_string_value("lll", "whatever").await?;
        nested.start_array("ar").await?.end().await?;
        nested.end().await?;

        Ok(())
    }

    async fn do_test_combined<F: JsonFormatter>(mut writer: JsonWriter<'_, Vec<u8>, F, DefaultFloatFormat>, expected: &str) -> io::Result<()> {
        let mut root = JsonObject::new(&mut writer).await?;
        do_write_json(&mut root).await?;
        root.end().await?;

        let s = writer.into_inner()?.to_vec();
        let s = String::from_utf8(s).unwrap();

        assert_eq!(s, expected);
        Ok(())
    }

    #[tokio::test]
    async fn test_write_combined_compact() -> io::Result<()> {
        do_test_combined(JsonWriter::new_compact(&mut Vec::new()),
                         r#"{"abc":"yo","xyz":"yo","aaaa":["111","11",{},[],null,true,false,-23987,23987,23.235,null,null,23.235,null,null],"ooo":{"lll":"whatever","ar":[]}}"#
        ).await
    }

    #[tokio::test]
    async fn test_write_combined_pretty() -> io::Result<()> {
        do_test_combined(JsonWriter::new_pretty(&mut Vec::new()),
                         r#"{
  "abc": "yo",
  "xyz": "yo",
  "aaaa": [
    "111",
    "11",
    {},
    [],
    null,
    true,
    false,
    -23987,
    23987,
    23.235,
    null,
    null,
    23.235,
    null,
    null
  ],
  "ooo": {
    "lll": "whatever",
    "ar": []
  }
}"#
        ).await
    }
}