eventson 0.1.0

An event based JSON parser with competitive performance
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

use std::io::{Cursor, Read};

use eventson::{Event, Number, Parser};

struct FooBar {
    foo: u64,
    bar: u64,
}

fn main() {
    let input = r#"
        { "foo": 1, "bar": 3 }
        { "foo": 10, "bar": 12}
        { "foo": 8, "bar": 14}
    "#;

    let reader = Cursor::new(input);
    let mut parser = eventson::Parser::new(reader, 16, 8);
    let mut foo_bar = FooBar { foo: 0, bar: 0 };

    let mut foo_bar_diff = 0;
    let mut count = 0;
    while let Ok(event) = parser.next() {
        match event {
            Event::StartObject => {
                continue;
            }
            Event::ObjectKey(b"foo") => {
                foo_bar.foo = expect_float(&mut parser);
            }
            Event::ObjectKey(b"bar") => {
                foo_bar.bar = expect_float(&mut parser);
            }
            Event::EndObject => {
                foo_bar_diff += foo_bar.bar - foo_bar.foo;
                count += 1;
            }
            Event::Eof => {
                break;
            }
            _ => {
                panic!("Unexpected event: {:?}", event);
            }
        }
    }

    let very_useful_average = foo_bar_diff / count;
    println!("{very_useful_average}")
}

// TODO: What kinds of facilities like this should I include in the library?
fn expect_float<R: Read>(parser: &mut Parser<R>) -> u64 {
    match parser.next().unwrap() {
        Event::Number(Number::PositiveInt(n)) => n,
        event => {
            panic!("Unexpected event: {:?}", event);
        }
    }
}