parsely-rs 0.1.6

Macro-based struct serialization/deserialization
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

use parsely_rs::*;
#[parsely(alignment = 4)]
struct Foo {
    one: u8,
}
impl<B: BitBuf> ::parsely_rs::ParselyRead<B> for Foo {
    type Ctx = ();
    fn read<T: ::parsely_rs::ByteOrder>(
        buf: &mut B,
        (): (),
    ) -> ::parsely_rs::ParselyResult<Self> {
        let __bytes_read_before_Foo_read = buf.remaining_bytes();
        let one = u8::read::<T>(buf, ()).with_context(|| "Reading field 'one'")?;
        while (__bytes_read_before_Foo_read - buf.remaining_bytes()) % 4usize != 0 {
            buf.get_u8().context("consuming padding")?;
        }
        Ok(Self { one })
    }
}
impl<B: BitBufMut> ::parsely_rs::ParselyWrite<B> for Foo {
    type Ctx = ();
    fn write<T: ByteOrder>(&self, buf: &mut B, (): Self::Ctx) -> ParselyResult<()> {
        let __bytes_written_before_Foo_write = buf.remaining_mut_bytes();
        u8::write::<T>(&self.one, buf, ())
            .with_context(|| ::alloc::__export::must_use({
                let res = ::alloc::fmt::format(
                    format_args!("Writing field \'{0}\'", "one"),
                );
                res
            }))?;
        while (__bytes_written_before_Foo_write - buf.remaining_mut_bytes()) % 4usize
            != 0
        {
            buf.put_u8(0).context("adding padding")?;
        }
        Ok(())
    }
}
impl ::parsely_rs::StateSync for Foo {
    type SyncCtx = ();
    fn sync(&mut self, (): ()) -> ParselyResult<()> {
        self.one
            .sync(())
            .with_context(|| ::alloc::__export::must_use({
                let res = ::alloc::fmt::format(
                    format_args!("Syncing field \'{0}\'", "one"),
                );
                res
            }))?;
        Ok(())
    }
}