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

use futures::io::{AsyncReadExt, AsyncWriteExt};

use crate::io::{AsyncRead, AsyncWrite};

/// Adapter for [`futures::io::AsyncRead`] that produces [`AsyncRead`].
pub struct FuturesReader<R: futures::io::AsyncRead> {
    reader: R,
}

impl<R: futures::io::AsyncRead> FuturesReader<R> {
    /// Wraps an instance of [`futures::io::AsyncRead`].
    #[inline(always)]
    pub fn new(reader: R) -> Self {
        Self { reader }
    }

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

impl<R: futures::io::AsyncRead> From<R> for FuturesReader<R> {
    fn from(value: R) -> Self {
        Self::new(value)
    }
}

impl<R: futures::io::AsyncRead + Unpin> AsyncRead<std::io::Error> for FuturesReader<R> {
    #[inline(always)]
    async fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> Result<(), std::io::Error> {
        self.reader.read_exact(buf).await?;
        Ok(())
    }
}

/// Adapter for [`futures::io::AsyncWrite`] that produces [`AsyncWrite`].
pub struct FuturesWriter<W: futures::io::AsyncWrite> {
    writer: W,
}

impl<W: futures::io::AsyncWrite> FuturesWriter<W> {
    /// Wraps an instance of [`futures::io::AsyncWrite`].
    #[inline(always)]
    pub fn new(writer: W) -> Self {
        Self { writer }
    }

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

impl<W: futures::io::AsyncWrite + Unpin> AsyncWrite<std::io::Error> for FuturesWriter<W> {
    #[inline(always)]
    async fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> Result<(), std::io::Error> {
        self.writer.write_all(buf).await
    }

    #[inline]
    async fn flush<'a>(&'a mut self) -> Result<(), std::io::Error> {
        self.writer.flush().await
    }
}