mavio 0.5.10

Minimalistic MAVLink client that supports `no-std` and `no-alloc` targets.
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

use embedded_io_async::ReadExactError;

use crate::error::{IoError, IoErrorKind};
use crate::io::{AsyncRead, AsyncWrite};

/// Adapter for [`embedded_io_async::Read`] that produces [`AsyncRead`].
pub struct EmbeddedIoAsyncReader<R: embedded_io_async::Read> {
    reader: R,
}

impl<R: embedded_io_async::Read> EmbeddedIoAsyncReader<R> {
    /// Wraps an instance of [`embedded_io_async::Read`].
    #[inline(always)]
    pub fn new(reader: R) -> Self {
        Self { reader }
    }

    /// Extracts an instance of [`embedded_io_async::Read`].
    #[inline(always)]
    pub fn extract(self) -> R {
        self.reader
    }
}

impl<R: embedded_io_async::Read> From<R> for EmbeddedIoAsyncReader<R> {
    fn from(value: R) -> Self {
        Self::new(value)
    }
}

impl<R: embedded_io_async::Read> AsyncRead<IoError> for EmbeddedIoAsyncReader<R> {
    #[inline(always)]
    async fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> Result<(), IoError> {
        self.reader.read_exact(buf).await.map_err(|err| match err {
            ReadExactError::UnexpectedEof => IoError::from(IoErrorKind::UnexpectedEof),
            ReadExactError::Other(err) => IoError::from_embedded_io_error(err),
        })
    }
}

/// Adapter for [`embedded_io_async::Write`] that produces [`AsyncWrite`].
pub struct EmbeddedIoAsyncWriter<W: embedded_io_async::Write> {
    writer: W,
}

impl<W: embedded_io_async::Write> EmbeddedIoAsyncWriter<W> {
    /// Wraps an instance of [`embedded_io_async::Write`].
    #[inline(always)]
    pub fn new(writer: W) -> Self {
        Self { writer }
    }

    /// Extracts an instance of [`embedded_io_async::Write`].
    #[inline(always)]
    pub fn extract(self) -> W {
        self.writer
    }
}

impl<W: embedded_io_async::Write> AsyncWrite<IoError> for EmbeddedIoAsyncWriter<W> {
    #[inline(always)]
    async fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> Result<(), IoError> {
        self.writer
            .write_all(buf)
            .await
            .map_err(IoError::from_embedded_io_error)
    }

    #[inline]
    async fn flush(&mut self) -> Result<(), IoError> {
        self.writer
            .flush()
            .await
            .map_err(IoError::from_embedded_io_error)
    }
}