sval 2.19.0

Streaming, structured value serialization
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

#[macro_use]
extern crate sval_derive_macros;

pub fn get_i32<'sval>(field: &str, value: impl sval::Value) -> Option<i32> {
    struct Extract<'a> {
        depth: usize,
        field: &'a str,
        matched_field: bool,
        extracted: Option<i32>,
    }

    impl<'a, 'sval> sval::Stream<'sval> for Extract<'a> {
        fn record_value_begin(
            &mut self,
            _: Option<&sval::Tag>,
            label: &sval::Label,
        ) -> sval::Result {
            self.matched_field = label.as_str() == self.field;
            Ok(())
        }

        fn record_value_end(&mut self, _: Option<&sval::Tag>, _: &sval::Label) -> sval::Result {
            Ok(())
        }

        fn i64(&mut self, v: i64) -> sval::Result {
            if self.matched_field {
                self.extracted = v.try_into().ok();
            }

            Ok(())
        }

        fn null(&mut self) -> sval::Result {
            Ok(())
        }

        fn bool(&mut self, _: bool) -> sval::Result {
            Ok(())
        }

        fn text_begin(&mut self, _: Option<usize>) -> sval::Result {
            Ok(())
        }

        fn text_fragment_computed(&mut self, _: &str) -> sval::Result {
            Ok(())
        }

        fn text_end(&mut self) -> sval::Result {
            Ok(())
        }

        fn f64(&mut self, _: f64) -> sval::Result {
            Ok(())
        }

        fn seq_begin(&mut self, _: Option<usize>) -> sval::Result {
            self.depth += 1;

            Ok(())
        }

        fn seq_value_begin(&mut self) -> sval::Result {
            Ok(())
        }

        fn seq_value_end(&mut self) -> sval::Result {
            Ok(())
        }

        fn seq_end(&mut self) -> sval::Result {
            self.depth -= 1;

            Ok(())
        }
    }

    let mut stream = Extract {
        depth: 0,
        field,
        matched_field: false,
        extracted: None,
    };

    sval::stream(&mut stream, &value).ok()?;
    stream.extracted
}

#[derive(Value)]
struct MyData {
    field_0: bool,
    field_1: i32,
}

fn main() {
    let data = MyData {
        field_0: true,
        field_1: 42,
    };

    assert_eq!(Some(42), get_i32("field_1", data));
}