A better Rust ATProto crate
1use embedded_io::{self, ErrorType, ReadExactError, WriteFmtError};
2
3use crate::io::{ErrorKind, Read, Seek, SeekFrom, Write};
4
5#[derive(Clone)]
6pub struct FromEmbed<T: ?Sized> {
7 inner: T,
8}
9
10impl<T> FromEmbed<T> {
11 /// Create a new adapter.
12 pub fn new(inner: T) -> Self {
13 Self { inner }
14 }
15
16 /// Consume the adapter, returning the inner object.
17 pub fn into_inner(self) -> T {
18 self.inner
19 }
20}
21
22impl<T: ?Sized> FromEmbed<T> {
23 /// Borrow the inner object.
24 pub fn inner(&self) -> &T {
25 &self.inner
26 }
27
28 /// Mutably borrow the inner object.
29 pub fn inner_mut(&mut self) -> &mut T {
30 &mut self.inner
31 }
32}
33
34impl embedded_io::Error for crate::io::Error {
35 fn kind(&self) -> embedded_io::ErrorKind {
36 self.kind().into()
37 }
38}
39
40impl<T: ?Sized> ErrorType for FromEmbed<T> {
41 type Error = crate::io::Error;
42}
43
44impl<T: Read + ?Sized> embedded_io::Read for FromEmbed<T> {
45 fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
46 Read::read(self.inner_mut(), buf)
47 }
48
49 fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), ReadExactError<Self::Error>> {
50 match Read::read_exact(self.inner_mut(), buf) {
51 Ok(()) => Ok(()),
52 Err(err) => {
53 if err.kind() == ErrorKind::UnexpectedEof {
54 Err(ReadExactError::UnexpectedEof)
55 } else {
56 Err(ReadExactError::Other(err))
57 }
58 }
59 }
60 }
61}
62
63impl<T: Write + ?Sized> embedded_io::Write for FromEmbed<T> {
64 fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
65 Write::write(self.inner_mut(), buf)
66 }
67
68 fn flush(&mut self) -> Result<(), Self::Error> {
69 Write::flush(self.inner_mut())
70 }
71
72 fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
73 Write::write_all(self.inner_mut(), buf)
74 }
75
76 fn write_fmt(
77 &mut self,
78 fmt: core::fmt::Arguments<'_>,
79 ) -> Result<(), embedded_io::WriteFmtError<Self::Error>> {
80 Write::write_fmt(self.inner_mut(), fmt).map_err(|e| WriteFmtError::Other(e))
81 }
82}
83
84impl From<embedded_io::SeekFrom> for SeekFrom {
85 fn from(from: embedded_io::SeekFrom) -> Self {
86 match from {
87 embedded_io::SeekFrom::Start(offset) => SeekFrom::Start(offset),
88 embedded_io::SeekFrom::End(offset) => SeekFrom::End(offset),
89 embedded_io::SeekFrom::Current(offset) => SeekFrom::Current(offset),
90 }
91 }
92}
93
94impl<T: Seek + ?Sized> embedded_io::Seek for FromEmbed<T> {
95 fn seek(&mut self, pos: embedded_io::SeekFrom) -> Result<u64, Self::Error> {
96 Seek::seek(self.inner_mut(), pos.into())
97 }
98
99 fn rewind(&mut self) -> Result<(), Self::Error> {
100 self.seek(embedded_io::SeekFrom::Start(0))?;
101 Ok(())
102 }
103
104 fn stream_position(&mut self) -> Result<u64, Self::Error> {
105 Seek::stream_position(self.inner_mut())
106 }
107}