embedded_io_adapters/
std.rs

1//! Adapters to/from `std::io` traits.
2
3use embedded_io::Error as _;
4
5/// Adapter from `std::io` traits.
6#[derive(Clone)]
7pub struct FromStd<T: ?Sized> {
8    inner: T,
9}
10
11impl<T> FromStd<T> {
12    /// Create a new adapter.
13    pub fn new(inner: T) -> Self {
14        Self { inner }
15    }
16
17    /// Consume the adapter, returning the inner object.
18    pub fn into_inner(self) -> T {
19        self.inner
20    }
21}
22
23impl<T: ?Sized> FromStd<T> {
24    /// Borrow the inner object.
25    pub fn inner(&self) -> &T {
26        &self.inner
27    }
28
29    /// Mutably borrow the inner object.
30    pub fn inner_mut(&mut self) -> &mut T {
31        &mut self.inner
32    }
33}
34
35impl<T: ?Sized> embedded_io::ErrorType for FromStd<T> {
36    type Error = std::io::Error;
37}
38
39impl<T: std::io::Read + ?Sized> embedded_io::Read for FromStd<T> {
40    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
41        self.inner.read(buf)
42    }
43}
44
45impl<T: std::io::BufRead + ?Sized> embedded_io::BufRead for FromStd<T> {
46    fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
47        self.inner.fill_buf()
48    }
49
50    fn consume(&mut self, amt: usize) {
51        self.inner.consume(amt);
52    }
53}
54
55impl<T: std::io::Write + ?Sized> embedded_io::Write for FromStd<T> {
56    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
57        match self.inner.write(buf) {
58            Ok(0) if !buf.is_empty() => Err(std::io::ErrorKind::WriteZero.into()),
59            Ok(n) => Ok(n),
60            Err(e) => Err(e),
61        }
62    }
63    fn flush(&mut self) -> Result<(), Self::Error> {
64        self.inner.flush()
65    }
66}
67
68impl<T: std::io::Seek + ?Sized> embedded_io::Seek for FromStd<T> {
69    fn seek(&mut self, pos: embedded_io::SeekFrom) -> Result<u64, Self::Error> {
70        self.inner.seek(pos.into())
71    }
72}
73
74/// Adapter to `std::io` traits.
75#[derive(Clone)]
76pub struct ToStd<T: ?Sized> {
77    inner: T,
78}
79
80impl<T> ToStd<T> {
81    /// Create a new adapter.
82    pub fn new(inner: T) -> Self {
83        Self { inner }
84    }
85
86    /// Consume the adapter, returning the inner object.
87    pub fn into_inner(self) -> T {
88        self.inner
89    }
90}
91
92impl<T: ?Sized> ToStd<T> {
93    /// Borrow the inner object.
94    pub fn inner(&self) -> &T {
95        &self.inner
96    }
97
98    /// Mutably borrow the inner object.
99    pub fn inner_mut(&mut self) -> &mut T {
100        &mut self.inner
101    }
102}
103
104impl<T: embedded_io::Read + ?Sized> std::io::Read for ToStd<T> {
105    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
106        self.inner.read(buf).map_err(to_std_error)
107    }
108}
109
110impl<T: embedded_io::Write + ?Sized> std::io::Write for ToStd<T> {
111    fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
112        match self.inner.write(buf) {
113            Ok(n) => Ok(n),
114            Err(e) if e.kind() == embedded_io::ErrorKind::WriteZero => Ok(0),
115            Err(e) => Err(to_std_error(e)),
116        }
117    }
118    fn flush(&mut self) -> Result<(), std::io::Error> {
119        self.inner.flush().map_err(to_std_error)
120    }
121}
122
123impl<T: embedded_io::Seek + ?Sized> std::io::Seek for ToStd<T> {
124    fn seek(&mut self, pos: std::io::SeekFrom) -> Result<u64, std::io::Error> {
125        self.inner.seek(pos.into()).map_err(to_std_error)
126    }
127}
128
129/// Convert a embedded-io error to a [`std::io::Error`]
130pub fn to_std_error<T: embedded_io::Error>(err: T) -> std::io::Error {
131    std::io::Error::new(err.kind().into(), format!("{err:?}"))
132}
embedded_io_adapters/std.rs

embedded_io_adapters/
std.rs
