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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use parsely_rs::*;
struct Foo {
    #[parsely_read(map = "|v: u8| { v.to_string() }")]
    #[parsely_write(map = "|v: &str| { v.parse::<u8>() }")]
    value: String,
}
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 value = {
            let original_value = ::parsely_rs::ParselyRead::read::<T>(buf, ())
                .with_context(|| ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(
                        format_args!("Reading raw value for field \'{0}\'", "value"),
                    );
                    res
                }))?;
            (|v: u8| { v.to_string() })(original_value)
                .into_parsely_result()
                .with_context(|| ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(
                        format_args!("Mapping raw value for field \'{0}\'", "value"),
                    );
                    res
                }))
        }
            .with_context(|| "Reading field 'value'")?;
        Ok(Self { value })
    }
}
impl<B: BitBufMut> ::parsely_rs::ParselyWrite<B> for Foo {
    type Ctx = ();
    fn write<T: ByteOrder>(&self, buf: &mut B, (): Self::Ctx) -> ParselyResult<()> {
        {
            let mapped_value = (|v: &str| { v.parse::<u8>() })(&self.value);
            let result = <_ as IntoWritableParselyResult<
                _,
                B,
            >>::into_writable_parsely_result(mapped_value)
                .with_context(|| ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(
                        format_args!("Mapping raw value for field \'{0}\'", "value"),
                    );
                    res
                }))?;
            ::parsely_rs::ParselyWrite::write::<T>(&result, buf, ())
                .with_context(|| ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(
                        format_args!("Writing mapped value for field \'{0}\'", "value"),
                    );
                    res
                }))?;
        }
        Ok(())
    }
}
impl ::parsely_rs::StateSync for Foo {
    type SyncCtx = ();
    fn sync(&mut self, (): ()) -> ParselyResult<()> {
        self.value
            .sync(())
            .with_context(|| ::alloc::__export::must_use({
                let res = ::alloc::fmt::format(
                    format_args!("Syncing field \'{0}\'", "value"),
                );
                res
            }))?;
        Ok(())
    }
}