minbin 0.1.1

Minimal, manual, no-std, zero-dependency, big-endian binary 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

use minbin::{read_bytes, write_bytes, BytesReader, BytesWriter, ToFromByteError, ToFromBytes};

struct ExampleStruct<'a> {
    uuid: u128,
    timestamp: i64,
    name: &'a str,
    reading: u16,
}

impl<'a> ToFromBytes<'a> for ExampleStruct<'a> {
    const MAX_BYTES: usize = 1_048_576;

    fn to_bytes(&self, writer: &mut BytesWriter<'a>) -> Result<(), ToFromByteError> {
        writer.write(&(self.uuid, self.timestamp, self.name, self.reading))?;

        Ok(())
    }

    fn from_bytes(reader: &mut BytesReader<'a>) -> Result<(Self, usize), ToFromByteError> {
        let (uuid, timestamp, name, reading) = reader.read()?;

        Ok((
            ExampleStruct {
                uuid,
                timestamp,
                name,
                reading,
            },
            reader.pos,
        ))
    }

    fn byte_count(&self) -> usize {
        (self.uuid, self.timestamp, self.name, self.reading).byte_count()
    }
}

#[test]
fn test_struct_stack() {
    let expected = ExampleStruct {
        uuid: 0,
        timestamp: 1,
        name: "example",
        reading: 2,
    };

    let mut buffer = [0u8; 1024];
    let write_pos = write_bytes(&expected, &mut buffer).unwrap();

    assert_eq!(expected.byte_count(), write_pos);

    let (actual, read_pos): (ExampleStruct, usize) = read_bytes(&buffer).unwrap();

    assert_eq!(expected.byte_count(), read_pos);
    assert_eq!(expected.uuid, actual.uuid);
    assert_eq!(expected.timestamp, actual.timestamp);
    assert_eq!(expected.name, actual.name);
    assert_eq!(expected.reading, actual.reading);
}

#[test]
fn test_struct_heap() {
    let expected = ExampleStruct {
        uuid: 0,
        timestamp: 1,
        name: "example",
        reading: 2,
    };

    let mut buffer = vec![0u8; expected.byte_count()];
    let write_pos = write_bytes(&expected, &mut buffer).unwrap();

    assert_eq!(expected.byte_count(), write_pos);

    let (actual, read_pos): (ExampleStruct, usize) = read_bytes(&buffer).unwrap();

    assert_eq!(expected.byte_count(), read_pos);
    assert_eq!(expected.uuid, actual.uuid);
    assert_eq!(expected.timestamp, actual.timestamp);
    assert_eq!(expected.name, actual.name);
    assert_eq!(expected.reading, actual.reading);
}