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

use embedded_io::ReadExactError;

use crate::error::{IoError, IoErrorKind};
use crate::io::{Read, Write};

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

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

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

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

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

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

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

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

impl<W: embedded_io::Write> Write<IoError> for EmbeddedIoWriter<W> {
    #[inline(always)]
    fn write_all(&mut self, buf: &[u8]) -> Result<(), IoError> {
        self.writer
            .write_all(buf)
            .map_err(IoError::from_embedded_io_error)
    }

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