nojson 0.3.10

A flexible JSON library with no dependencies and no macros
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

use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};

fn gen_plain_ascii(len: usize) -> String {
    let base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ,.:;!?-_";
    base.chars().cycle().take(len).collect()
}

fn gen_mixed_escapes(len: usize) -> String {
    let base = "hello world\nthis has \"quotes\" and \\backslashes\r\nand\ttabs";
    base.chars().cycle().take(len).collect()
}

fn gen_unicode_heavy(len: usize) -> String {
    let chars = "あいうえおかきくけこ日本語テスト🎉🚀✨";
    chars.chars().cycle().take(len).collect()
}

fn bench_format(c: &mut Criterion) {
    let mut group = c.benchmark_group("format");

    // Plain ASCII string formatting
    for &len in &[64, 256, 1024] {
        let input = gen_plain_ascii(len);
        group.bench_with_input(
            BenchmarkId::new("plain_ascii", format!("{}B", len)),
            &input,
            |b, input| {
                b.iter(|| nojson::json(|f| f.value(input.as_str())).to_string());
            },
        );
    }

    // Mixed escapes
    let input = gen_mixed_escapes(256);
    group.bench_with_input(
        BenchmarkId::new("mixed_escapes", "256B"),
        &input,
        |b, input| {
            b.iter(|| nojson::json(|f| f.value(input.as_str())).to_string());
        },
    );

    // Unicode heavy
    let input = gen_unicode_heavy(200);
    group.bench_with_input(
        BenchmarkId::new("unicode_heavy", "200ch"),
        &input,
        |b, input| {
            b.iter(|| nojson::json(|f| f.value(input.as_str())).to_string());
        },
    );

    // Object with many string key-value pairs
    let keys: Vec<String> = (0..50).map(|i| format!("key_{}", i)).collect();
    let values: Vec<String> = (0..50)
        .map(|i| {
            format!(
                "This is value number {} with a reasonably long text content for benchmarking",
                i
            )
        })
        .collect();
    let pairs: Vec<(&str, &str)> = keys
        .iter()
        .zip(values.iter())
        .map(|(k, v)| (k.as_str(), v.as_str()))
        .collect();
    group.bench_with_input(
        BenchmarkId::new("object_formatting", "50pairs"),
        &pairs,
        |b, pairs| {
            b.iter(|| {
                nojson::json(|f| {
                    f.object(|f| {
                        for &(k, v) in pairs.iter() {
                            f.member(k, v)?;
                        }
                        Ok(())
                    })
                })
                .to_string()
            });
        },
    );

    group.finish();
}

criterion_group!(benches, bench_format);
criterion_main!(benches);