rust-lcm-codec 0.2.1

Rust support for reading and writing the LCM data format
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

extern crate generated;
extern crate rust_lcm_codec;

type TestError = rust_lcm_codec::CodecError<
    rust_lcm_codec::BufferReaderError,
    rust_lcm_codec::BufferWriterError,
>;
#[test]
fn nested_list_round_trip_happy_path() -> Result<(), TestError> {
    #[derive(Default, Debug, PartialEq)]
    struct Message {
        arbitrary: u8,
        segments: Vec<Segment>,
    }
    #[derive(Default, Debug, PartialEq)]
    struct Segment {
        singles: Vec<i32>,
        pairs: Vec<(i64, f64)>,
    }

    let input = Message {
        arbitrary: 1,
        segments: vec![
            Segment {
                singles: vec![2, 3, 4],
                pairs: vec![(5, 6.0), (7, 8.0)],
            },
            Segment {
                singles: vec![9, 10, 11, 12],
                pairs: vec![(13, 14.0)],
            },
        ],
    };
    let mut buf = [0u8; 256];
    {
        let mut w = rust_lcm_codec::BufferWriter::new(&mut buf);
        let pw = generated::nested_list::begin_nested_list_t_write(&mut w)?;
        let mut pw: generated::nested_list::nested_list_t_write_segments<_> = pw
            .write_arbitrary(input.arbitrary)?
            .write_nsegments(input.segments.len() as i32)?;
        // Use the point-list writer at the array-writing state as an iterator
        // that generates single-value-writing delegates
        for (item_writer, segment) in (&mut pw).zip(&input.segments) {
            item_writer.write(|segment_writer| {
                let mut sw = segment_writer.write_nsingles(segment.singles.len() as i32)?;
                for (singles_writer, single) in (&mut sw).zip(&segment.singles) {
                    singles_writer.write(*single)?;
                }
                let sw = sw.done()?;
                let mut sw = sw.write_npairs(segment.pairs.len() as i32)?;
                for (pair_writer, pair) in (&mut sw).zip(&segment.pairs) {
                    pair_writer.write(|pw| {
                        let pw = pw.write_left(pair.0)?;
                        let pw = pw.write_right(pair.1)?;
                        Ok(pw)
                    })?;
                }
                let sw = sw.done()?;
                Ok(sw)
            })?;
        }
        //let pw: generated::nested_list::nested_list_t_Write_points<_> = pw;
        let _write_done: generated::nested_list::nested_list_t_write_done<_> = pw.done()?;
    }
    let mut r = rust_lcm_codec::BufferReader::new(&mut buf);
    let pr = generated::nested_list::begin_nested_list_t_read(&mut r)?;
    let mut output = Message::default();
    let (found_arbitrary, pr) = pr.read_arbitrary()?;
    output.arbitrary = found_arbitrary;
    let (_, mut pr) = pr.read_nsegments()?;
    for item_reader in &mut pr {
        let mut segment = Segment::default();
        item_reader.read(|segment_reader| {
            let (_, mut segment_reader) = segment_reader.read_nsingles()?;
            for single_reader in &mut segment_reader {
                segment.singles.push(single_reader.read()?);
            }
            let (_, mut segment_reader) = segment_reader.done()?.read_npairs()?;
            for pair_reader in &mut segment_reader {
                let mut left = Default::default();
                let mut right = Default::default();
                pair_reader.read(|pair_reader| {
                    let (l, pair_reader) = pair_reader.read_left()?;
                    left = l;
                    let (r, pair_reader) = pair_reader.read_right()?;
                    right = r;
                    Ok(pair_reader)
                })?;
                segment.pairs.push((left, right));
            }
            Ok(segment_reader.done()?)
        })?;
        output.segments.push(segment);
    }
    assert_eq!(output, input);
    Ok(())
}