struson 0.7.2

A low-level streaming JSON reader and writer
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

use std::error::Error;

use criterion::{Criterion, criterion_group, criterion_main};
use serde::Serialize;
use struson::writer::{JsonStreamWriter, JsonWriter, WriterSettings};

#[derive(Serialize, Clone)]
struct StructValue {
    bool_value: bool,
    integer: u32,
    float: f64,
    string: &'static str,
}

fn benchmark_struct(c: &mut Criterion) {
    let mut group = c.benchmark_group("write-structs");
    let values: Vec<StructValue> = std::iter::repeat_n(
        StructValue {
            bool_value: true,
            integer: 123456,
            float: 123.4567,
            string: "a string value with some text",
        },
        10_000,
    )
    .collect();

    fn struson_write(
        mut json_writer: impl JsonWriter,
        values: &Vec<StructValue>,
    ) -> Result<(), Box<dyn Error>> {
        // Hopefully this is a fair comparison with how Serde behaves
        json_writer.begin_array()?;
        for value in values {
            json_writer.begin_object()?;

            json_writer.name("bool_value")?;
            json_writer.bool_value(value.bool_value)?;

            json_writer.name("integer")?;
            json_writer.number_value(value.integer)?;

            json_writer.name("float")?;
            json_writer.fp_number_value(value.float)?;

            json_writer.name("string")?;
            json_writer.string_value(value.string)?;

            json_writer.end_object()?;
        }
        json_writer.end_array()?;

        json_writer.finish_document()?;
        Ok(())
    }

    group.bench_with_input("struson", &values, |b, values| {
        b.iter(|| {
            let mut writer = Vec::new();
            let json_writer = JsonStreamWriter::new(&mut writer);
            struson_write(json_writer, values).unwrap();
            writer
        })
    });
    group.bench_with_input("struson (pretty)", &values, |b, values| {
        b.iter(|| {
            let mut writer = Vec::new();
            let json_writer = JsonStreamWriter::new_custom(
                &mut writer,
                WriterSettings {
                    pretty_print: true,
                    ..Default::default()
                },
            );
            struson_write(json_writer, values).unwrap();
            writer
        })
    });

    group.bench_with_input("serde", &values, |b, values| {
        b.iter(|| {
            let mut writer = Vec::new();
            serde_json::to_writer(&mut writer, &values).unwrap();
            writer
        })
    });
    group.bench_with_input("serde (pretty)", &values, |b, values| {
        b.iter(|| {
            let mut writer = Vec::new();
            serde_json::to_writer_pretty(&mut writer, &values).unwrap();
            writer
        })
    });

    group.finish();
}

criterion_group!(
    benches,
    // Benchmark functions
    benchmark_struct
);
criterion_main!(benches);