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

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_round_trip_happy_path() -> Result<(), TestError> {
    let mut buf = [0u8; 256];
    {
        let mut w = rust_lcm_codec::BufferWriter::new(&mut buf);
        let pw = generated::nested::begin_local_nested_t_write(&mut w)?;
        let _write_done: generated::nested::local_nested_t_write_done<_> = pw
            .write_j(1)?
            .write_k(|local_primitive_write_ready| {
                Ok(local_primitive_write_ready.write_m(2)?.write_n(3)?)
            })?
            .write_p(4)?;
    }
    let mut r = rust_lcm_codec::BufferReader::new(&mut buf);
    let pr = generated::nested::begin_local_nested_t_read(&mut r)?;
    let mut found_m = Default::default();
    let mut found_n = Default::default();
    let (found_j, pr) = pr.read_j()?;
    let pr = pr.read_k(|field_reader| {
        let (m, field_reader) = field_reader.read_m()?;
        found_m = m; // Copy content out of the closure to the externally visible state
        let (n, field_reader) = field_reader.read_n()?;
        found_n = n;
        Ok(field_reader)
    })?;
    let (found_p, pr) = pr.read_p()?;
    let _read_done: generated::nested::local_nested_t_read_done<_> = pr;
    assert_eq!(1, found_j);
    assert_eq!(2, found_m);
    assert_eq!(3, found_n);
    assert_eq!(4, found_p);
    Ok(())
}

#[test]
fn nested_remote_package_field_round_trip_happy_path() -> Result<(), TestError> {
    let mut buf = [0u8; 256];
    {
        let mut w = rust_lcm_codec::BufferWriter::new(&mut buf);
        let pw = generated::nested::begin_remote_nested_t_write(&mut w)?;
        let _write_done: generated::nested::remote_nested_t_write_done<_> = pw
            .write_j(1)?
            .write_k(|local_primitive_write_ready| {
                Ok(local_primitive_write_ready
                    .write_utime(2)?
                    .write_degCelsius(3.0)?)
            })?
            .write_p(4)?;
    }
    let mut r = rust_lcm_codec::BufferReader::new(&mut buf);
    let pr = generated::nested::begin_remote_nested_t_read(&mut r)?;
    let mut found_utime = Default::default();
    let mut found_deg_celsius = Default::default();
    let (found_j, pr) = pr.read_j()?;
    let pr = pr.read_k(|field_reader| {
        let (utime, field_reader) = field_reader.read_utime()?;
        found_utime = utime; // Copy content out of the closure to the externally visible state
        let (deg_celsius, field_reader) = field_reader.read_degCelsius()?;
        found_deg_celsius = deg_celsius;
        Ok(field_reader)
    })?;
    let (found_p, pr) = pr.read_p()?;
    let _read_done: generated::nested::remote_nested_t_read_done<_> = pr;
    assert_eq!(1, found_j);
    assert_eq!(2, found_utime);
    assert_eq!(3.0, found_deg_celsius);
    assert_eq!(4, found_p);
    Ok(())
}
// TODO - test writer error piping