framez 0.4.0

A zerocopy codec for encoding and decoding data in no_std environments.
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
98
99
100
101
102
103

#![allow(missing_docs)]

pub fn init_tracing() {
    tracing::subscriber::set_global_default(
        tracing_subscriber::fmt::Subscriber::builder()
            .with_max_level(tracing::Level::TRACE)
            .finish(),
    )
    .ok();
}

macro_rules! framed_read {
    ($items:ident, $expected:ident, $decoder:ident) => {
        framed_read!($items, $expected, $decoder, 1024, 1024);
    };
    ($items:ident, $expected:ident, $decoder:ident, $buffer_size:literal) => {
        framed_read!($items, $expected, $decoder, $buffer_size, 1024);
    };
    ($items:ident, $expected:ident, $decoder:ident, $buffer_size:literal $(, $err:ident )?) => {
        framed_read!($items, $expected, $decoder, $buffer_size, 1024 $(, $err )?);
    };
    ($items:ident, $expected:ident, $decoder:ident, $buffer_size:literal, $duplex_max_size:literal $(, $err:ident )?) => {
        let decoder_clone = $decoder.clone();
        let mut collected = Vec::<Vec<u8>>::new();

        let (read, mut write) = tokio::io::duplex($duplex_max_size);

        tokio::spawn(async move {
            for item in $items {
                write.write_all(item.as_ref()).await.expect("Must write");
            }
        });

        let buffer = &mut [0_u8; $buffer_size];
        let mut framer =
            crate::FramedRead::new(decoder_clone, embedded_io_adapters::tokio_1::FromTokio::new(read), buffer);

        while let Some(item) = $crate::next!(framer) {
            match item {
                Ok(item) => {
                    collected.push(item.into());
                }
                Err(_err) => {
                    #[cfg(not(feature = "defmt"))]
                    crate::logging::error!(target: "framez::test", "Error: {:?}", _err);

                    $(
                        assert!(matches!(_err, ReadError::$err));
                    )?

                    break;
                }
            }
        }

        assert_eq!($expected, collected);
    };
}

macro_rules! sink_stream {
    ($encoder:ident, $decoder:ident, $items:ident, $map:ident) => {
        let items_clone = $items.clone();

        let (read, write) = tokio::io::duplex(1024);

        tokio::spawn(async move {
            let buffer = &mut [0_u8; 1024];
            let mut writer = crate::FramedWrite::new(
                $encoder,
                embedded_io_adapters::tokio_1::FromTokio::new(write),
                buffer,
            );
            let sink = writer.sink();

            pin_mut!(sink);

            for item in items_clone.iter() {
                sink.send(item).await.expect("Must send");
            }
        });

        let buffer = &mut [0_u8; 1024];
        let mut framer = crate::FramedRead::new(
            $decoder,
            embedded_io_adapters::tokio_1::FromTokio::new(read),
            buffer,
        );

        let stream = framer.stream($map);

        let collected = stream
            .collect::<Vec<_>>()
            .await
            .into_iter()
            .flatten()
            .collect::<Vec<_>>();

        assert_eq!($items, collected);
    };
}

pub(crate) use framed_read;
pub(crate) use sink_stream;