deser 0.9.1

An experimental serialization and deserialization library for Rust
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

use deser::Error;
use deser::State;
use deser::ser::{Chunk, MapEmitter, Serialize, SerializeDriver, SerializeHandle};
use std::collections::{BTreeMap, btree_map};

struct Flags(BTreeMap<u64, bool>);

impl Serialize for Flags {
    fn serialize(&self, state: &mut State) -> Result<Chunk<'_>, Error> {
        Ok(Chunk::map(
            FlagsMapEmitter {
                iter: self.0.iter(),
                value: None,
            },
            state,
        ))
    }
}

pub struct FlagsMapEmitter<'a> {
    iter: btree_map::Iter<'a, u64, bool>,
    value: Option<&'a bool>,
}

impl<'a> MapEmitter for FlagsMapEmitter<'a> {
    fn next_key(&mut self, state: &mut State) -> Result<Option<SerializeHandle<'_>>, Error> {
        Ok(if let Some((key, value)) = self.iter.next() {
            self.value = Some(value);
            Some(SerializeHandle::arena(key.to_string(), state))
        } else {
            None
        })
    }

    fn next_value(&mut self, _state: &mut State) -> Result<SerializeHandle<'_>, Error> {
        Ok(SerializeHandle::to(self.value.unwrap()))
    }
}

#[test]
fn test_as_string_map() {
    let mut events = Vec::new();
    let flags = Flags({
        let mut map = BTreeMap::new();
        map.insert(0, true);
        map.insert(1, true);
        map.insert(2, false);
        map
    });
    let mut driver = SerializeDriver::new(&flags);
    while let Some((event, _, _)) = driver.next().unwrap() {
        events.push(format!("{:?}", event));
    }

    assert_eq!(
        events,
        vec![
            "MapStart",
            "Atom(Str(\"0\"))",
            "Atom(Bool(true))",
            "Atom(Str(\"1\"))",
            "Atom(Bool(true))",
            "Atom(Str(\"2\"))",
            "Atom(Bool(false))",
            "MapEnd"
        ]
    );
}