devela/data/codec/encode/
impls.rs

Help
1// devela::data::codec::encode::impls
2//
3//! General implementations of [`Decodable`] and [`Encodable`].
4//
5
6use crate::{
7    sf, CStr, Char, Decodable, Encodable, Fmt, FmtArguments, FmtError, FmtResult, FmtWrite,
8    IoError, IoErrorKind, IoRead, IoResult, IoWrite, NoData, Slice,
9};
10crate::_use! {basic::from_utf8}
11
12#[cfg(feature = "alloc")]
13crate::items! {
14    use crate::{iif, Cow, CString, Box, String, ToOwned, Vec};
15
16    impl<W: IoWrite> Encodable<W> for Vec<u8> {
17        fn encode(&self, writer: &mut W) -> IoResult<usize> {
18            writer.write(self.as_slice()) } }
19    impl<R: IoRead> Decodable<R> for Vec<u8> {
20        type Output = Vec<u8>;
21        fn decode(reader: &mut R) -> IoResult<Self::Output> {
22            let mut buf = Vec::new();
23            reader.read_to_end(&mut buf)?;
24            Ok(buf) } }
25
26    impl<W: IoWrite, T: Encodable<W>> Encodable<W> for Box<T> {
27        fn encode(&self, writer: &mut W) -> IoResult<usize> {
28            self.as_ref().encode(writer) } }
29    impl<R: IoRead, T: Decodable<R>> Decodable<R> for Box<T> {
30        type Output = Box<T::Output>;
31        fn decode(reader: &mut R) -> IoResult<Self::Output> {
32            Ok(Box::new(T::decode(reader)?)) } }
33
34    impl<W: IoWrite> Encodable<W> for String {
35        fn encode(&self, writer: &mut W) -> IoResult<usize> {
36            writer.write(self.as_bytes()) } }
37    impl<R: IoRead> Decodable<R> for String {
38        type Output = String;
39        fn decode(reader: &mut R) -> IoResult<Self::Output> {
40            let mut buf = Vec::new();
41            reader.read_to_end(&mut buf)?;
42            from_utf8(&buf).map(|s| s.to_owned())
43                .map_err(|_| IoError::new(IoErrorKind::InvalidData, "Invalid UTF-8"))
44        }
45    }
46    impl<W: IoWrite> Encodable<W> for CString {
47        fn encode(&self, writer: &mut W) -> IoResult<usize> {
48            writer.write(self.as_bytes()) } }
49    impl<R: IoRead> Decodable<R> for CString {
50        type Output = CString;
51        fn decode(reader: &mut R) -> IoResult<Self::Output> {
52            let mut buf = Vec::new();
53            let mut byte = [0u8; 1];
54            loop {
55                reader.read_exact(&mut byte)?;
56                iif![byte[0] == 0; break];
57                buf.push(byte[0]);
58            }
59            CString::new(buf).map_err(|_|
60                IoError::new(IoErrorKind::InvalidData, "Invalid C string")) } }
61
62    // only Encodable (for now?)
63    impl<W: IoWrite, T: Clone + Encodable<W>> Encodable<W> for Cow<'_, T> {
64        fn encode(&self, writer: &mut W) -> IoResult<usize> {
65            self.as_ref().encode(writer) } }
66}
67
68/* fmt */
69
70#[rustfmt::skip]
71impl<W: IoWrite> Encodable<W> for FmtArguments<'_> {
72    fn encode(&self, writer: &mut W) -> IoResult<usize> {
73        // Allows to use `Fmt::write` to format `FmtArguments` directly into `IoWrite`.
74        struct InlineFmtAdapter<'a, W: IoWrite> {
75            writer: &'a mut W,
76            error: Option<IoError>,
77            total: usize,
78        }
79        impl<W: IoWrite> FmtWrite for InlineFmtAdapter<'_, W> {
80            fn write_str(&mut self, s: &str) -> FmtResult<()> {
81                match self.writer.write(s.as_bytes()) {
82                    Ok(n) => { self.total += n; Ok(()) }
83                    Err(e) => { self.error = Some(e); Err(FmtError) }
84                }
85            }
86        }
87        let mut adapter = InlineFmtAdapter { writer, error: None, total: 0 };
88        if Fmt::write(&mut adapter, *self).is_ok() { Ok(adapter.total) }
89        else { Err(adapter.error
90            .unwrap_or_else(|| IoError::new(IoErrorKind::Other, "Formatting failed"))) }
91    }
92}
93
94/* primitives: char, byte, bool */
95
96impl<W: IoWrite> Encodable<W> for char {
97    fn encode(&self, w: &mut W) -> IoResult<usize> {
98        let mut buf = [0; 4];
99        let s = self.encode_utf8(&mut buf);
100        w.write(s.as_bytes())
101    }
102}
103impl<R: IoRead> Decodable<R> for char {
104    type Output = char;
105    fn decode(reader: &mut R) -> IoResult<Self::Output> {
106        let mut buf = [0u8; 4]; // UTF-8 can be up to 4 bytes
107        reader.read_exact(&mut buf[..1])?;
108        let len = Char::utf8_len(buf[0]) as usize;
109        reader.read_exact(&mut buf[1..len])?;
110        let utf8_str = from_utf8(&buf[..len])
111            .map_err(|_| IoError::new(IoErrorKind::InvalidData, "Invalid UTF-8 sequence"))?;
112        utf8_str
113            .chars()
114            .next()
115            .ok_or_else(|| IoError::new(IoErrorKind::UnexpectedEof, "Empty UTF-8 sequence"))
116    }
117}
118
119impl<W: IoWrite> Encodable<W> for u8 {
120    fn encode(&self, writer: &mut W) -> IoResult<usize> {
121        writer.write(Slice::from_ref(self))
122    }
123}
124impl<R: IoRead> Decodable<R> for u8 {
125    type Output = u8;
126    fn decode(reader: &mut R) -> IoResult<u8> {
127        let mut buf = [0u8; size_of::<u8>()];
128        reader.read_exact(&mut buf)?;
129        Ok(buf[0])
130    }
131}
132
133impl<W: IoWrite> Encodable<W> for i8 {
134    fn encode(&self, writer: &mut W) -> IoResult<usize> {
135        (*self as u8).encode(writer)
136    }
137}
138impl<R: IoRead> Decodable<R> for i8 {
139    type Output = i8;
140    fn decode(reader: &mut R) -> IoResult<i8> {
141        let mut buf = [0u8; size_of::<i8>()];
142        reader.read_exact(&mut buf)?;
143        Ok(buf[0] as i8)
144    }
145}
146
147impl<W: IoWrite> Encodable<W> for bool {
148    fn encode(&self, writer: &mut W) -> IoResult<usize> {
149        u8::from(*self).encode(writer)
150    }
151}
152impl<R: IoRead> Decodable<R> for bool {
153    type Output = bool;
154    fn decode(reader: &mut R) -> IoResult<Self::Output> {
155        let mut buf = [0u8; 1];
156        reader.read_exact(&mut buf)?;
157        match buf[0] {
158            0 => Ok(false),
159            1 => Ok(true),
160            _ => Err(IoError::new(IoErrorKind::InvalidData, "Invalid boolean value")),
161        }
162    }
163}
164
165// only Encodable
166/// Allows encoding of `&T` directly, forwarding calls to `T::encode()`.
167impl<T: Encodable<W> + ?Sized, W: IoWrite> Encodable<W> for &T {
168    fn encode(&self, writer: &mut W) -> IoResult<usize> {
169        T::encode(self, writer)
170    }
171}
172// only Decodable
173// impl<R: IoRead, T: Decodable<R>> Decodable<IoTake<R>> for T {
174//     type Output = T::Output;
175//     fn decode(reader: &mut IoTake<R>) -> IoResult<Self::Output> {
176//         T::decode(reader)
177//     }
178// }
179
180/* slices, arrays */
181
182sf! {
183    impl<W: IoWrite, const SIZE: usize> Encodable<W> for [u8; SIZE] {
184        fn encode(&self, writer: &mut W) -> IoResult<usize> {
185            writer.write(self)
186        }
187    }
188    impl<R: IoRead, const SIZE: usize> Decodable<R> for [u8; SIZE] {
189        type Output = [u8; SIZE];
190        fn decode(reader: &mut R) -> IoResult<Self::Output> {
191            let mut buf = [0u8; SIZE];
192            reader.read_exact(&mut buf)?;
193            Ok(buf)
194        }
195    }
196
197    impl<W: IoWrite> Encodable<W> for str {
198        fn encode(&self, writer: &mut W) -> IoResult<usize> {
199            writer.write(self.as_bytes())
200        }
201    }
202    impl<'a> Decodable<&'a mut &[u8]> for &'a str {
203        type Output = Self;
204        fn decode(reader: &mut &'a mut &[u8]) -> IoResult<Self::Output> {
205            // In this specialized case, we assume the reader is already limited
206            // to exactly the bytes for the string.
207            let s = from_utf8(reader)
208                .map_err(|_| IoError::new(IoErrorKind::InvalidData, "Invalid UTF-8"))?;
209            // Consume the entire slice.
210            **reader = &[];
211            Ok(s)
212        }
213    }
214
215    // only Encodable
216    impl<W: IoWrite> Encodable<W> for [u8] {
217        fn encode(&self, writer: &mut W) -> IoResult<usize> {
218            writer.write(self)
219        }
220    }
221    // only Encodable
222    impl<W: IoWrite> Encodable<W> for CStr {
223        fn encode(&self, writer: &mut W) -> IoResult<usize> {
224            writer.write(self.to_bytes_with_nul())
225        }
226    }
227}
228
229/* tuples */
230
231// https://users.rust-lang.org/t/macro-to-impl-trait-for-tuple/79165/3
232macro_rules! impl_encodable_for_tuple {
233    ($($T:tt)*) => { $crate::paste! {
234        impl<WRITER, A, $($T,)*> Encodable<WRITER> for (A,$($T,)*)
235        where
236            WRITER: IoWrite,
237            A: Encodable<WRITER>,
238            $($T: Encodable<WRITER>,)*
239        {
240            fn encode(&self, writer: &mut WRITER) -> IoResult<usize> {
241                let (a, $([<$T:lower>],)*) = self;
242                let mut total = 0;
243                total += a.encode(writer)?;
244                $(
245                    total += [<$T:lower>].encode(writer)?;
246                )*
247                Ok(total)
248            }
249
250        }
251    }};
252}
253impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T U V W X Y Z);
254impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T U V W X Y);
255impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T U V W X);
256impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T U V W);
257impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T U V);
258impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T U);
259impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S T);
260impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R S);
261impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q R);
262impl_encodable_for_tuple!(B C D E F G H I J K L M N O P Q);
263impl_encodable_for_tuple!(B C D E F G H I J K L M N O P);
264impl_encodable_for_tuple!(B C D E F G H I J K L M N O);
265impl_encodable_for_tuple!(B C D E F G H I J K L M N);
266impl_encodable_for_tuple!(B C D E F G H I J K L M);
267impl_encodable_for_tuple!(B C D E F G H I J K L);
268impl_encodable_for_tuple!(B C D E F G H I J K);
269impl_encodable_for_tuple!(B C D E F G H I J);
270impl_encodable_for_tuple!(B C D E F G H I);
271impl_encodable_for_tuple!(B C D E F G H);
272impl_encodable_for_tuple!(B C D E F G);
273impl_encodable_for_tuple!(B C D E F);
274impl_encodable_for_tuple!(B C D E);
275impl_encodable_for_tuple!(B C D);
276impl_encodable_for_tuple!(B C);
277impl_encodable_for_tuple!(B);
278impl_encodable_for_tuple!();
279
280/* option, unit */
281
282sf! {
283    impl<T: Encodable<W>, W: IoWrite> Encodable<W> for Option<T> {
284        fn encode(&self, writer: &mut W) -> IoResult<usize> {
285            match self { Some(value) => value.encode(writer), None => Ok(0) }
286        }
287    }
288    impl<W: IoWrite> Encodable<W> for NoData {
289        fn encode(&self, _writer: &mut W) -> IoResult<usize> { Ok(0) }
290    }
291}
292
293#[cfg(test)]
294mod tests {
295    use super::*;
296
297    #[test]
298    fn option() {
299        let mut writer = &mut [0u8; 32] as &mut [u8];
300        None::<Option<u8>>.encode(&mut writer).unwrap();
301        Some(42u8).encode(&mut writer).unwrap();
302    }
303}
devela/data/codec/encode/impls.rs

devela/data/codec/encode/
impls.rs
