1use std::io::{Read, Write};
2
3use crate::*;
4
5impl From<std::io::Error> for Error<std::io::Error> {
12 fn from(value: std::io::Error) -> Self {
13 Self::Sender(value)
14 }
15}
16
17impl<T: Read> Sender for T {
19 type Item = u8;
20 type Error = std::io::Error;
21
22 fn get(&mut self) -> Result<Self::Item, Error<Self::Error>> {
23 let mut buffer = [0; 1];
24 match self.read_exact(&mut buffer) {
25 Ok(_) => Ok(buffer[0]),
26 Err(err) => match err.kind() {
27 std::io::ErrorKind::UnexpectedEof => Err(Error::EOF),
28 _ => Err(err.into()),
29 },
30 }
31 }
32
33 fn fill_buffer(&mut self, buffer: &mut [Self::Item]) -> Result<(), Error<Self::Error>> {
34 match self.read_exact(buffer) {
35 Err(err) if err.kind() == std::io::ErrorKind::UnexpectedEof => Err(Error::EOF),
36 x => Ok(x?),
37 }
38 }
39
40 fn get_buffer<const N: usize>(&mut self) -> Result<[Self::Item; N], Error<Self::Error>> {
41 let mut buffer = [0; N];
42 self.fill_buffer(&mut buffer)?;
43 Ok(buffer)
44 }
45}
46
47impl<T: Write> Receiver for T {
49 type Item = u8;
50 type Error = std::io::Error;
51
52 fn accept(&mut self, item: Self::Item) -> Result<(), Self::Error> {
53 self.write_all(&[item])
54 }
55}
56
57impl<Item, T> Deserialize<Item> for Vec<T>
64where
65 T: Deserialize<Item>,
66 usize: Deserialize<Item>,
67{
68 fn deserialize<S: Sender<Item = Item> + ?Sized>(
70 sender: &mut S,
71 ) -> Result<Vec<T>, Error<S::Error>> {
72 let len = sender.auto()?;
73 let mut buffer = Vec::with_capacity(len);
74 for _ in 0..len {
75 buffer.push(sender.auto()?);
76 }
77 Ok(buffer)
78 }
79}
80
81impl<Item, T> Serialize<Item> for &[T]
82where
83 T: Serialize<Item> + Clone,
84 usize: Serialize<Item>,
85{
86 fn serialize<R: Receiver<Item = Item>>(self, receiver: &mut R) -> Result<(), R::Error> {
88 receiver.auto(self.len())?;
89 for item in self {
90 receiver.auto(item.clone())?;
91 }
92 Ok(())
93 }
94}
95
96impl<Item, T> Serialize<Item> for Vec<T>
97where
98 T: Serialize<Item>,
99 usize: Serialize<Item>,
100{
101 fn serialize<R: Receiver<Item = Item>>(self, receiver: &mut R) -> Result<(), R::Error> {
103 receiver.auto(self.len())?;
104 for item in self {
105 receiver.auto(item)?;
106 }
107 Ok(())
108 }
109}
110
111impl<const N: usize, Item, T: Deserialize<Item>> Deserialize<Item> for [T; N] {
118 fn deserialize<S: Sender<Item = Item> + ?Sized>(
120 sender: &mut S,
121 ) -> Result<[T; N], Error<S::Error>> {
122 let mut buffer = Vec::with_capacity(N);
123 for _ in 0..N {
124 buffer.push(sender.auto()?);
125 }
126 let Ok(buffer) = buffer.try_into() else { unreachable!() };
127 Ok(buffer)
128 }
129}
130
131impl<const N: usize, Item, T> Serialize<Item> for [T; N]
132where
133 T: Serialize<Item>,
134{
135 fn serialize<R: Receiver<Item = Item>>(self, receiver: &mut R) -> Result<(), R::Error> {
137 for item in self {
138 receiver.auto(item)?;
139 }
140 Ok(())
141 }
142}
143
144impl<Item, T> Deserialize<Item> for Option<T>
151where
152 T: Deserialize<Item>,
153 bool: Deserialize<Item>,
154{
155 fn deserialize<S: Sender<Item = Item> + ?Sized>(
157 sender: &mut S,
158 ) -> Result<Self, Error<S::Error>> {
159 let is_some: bool = sender.auto()?;
160 if is_some {
161 Ok(Some(sender.auto()?))
162 } else {
163 Ok(None)
164 }
165 }
166}
167
168impl<Item, T> Serialize<Item> for Option<T>
169where
170 T: Serialize<Item>,
171 bool: Serialize<Item>,
172{
173 fn serialize<R: Receiver<Item = Item>>(self, receiver: &mut R) -> Result<(), R::Error> {
175 match self {
176 Some(x) => receiver.auto((true, x)),
177 None => receiver.auto(false),
178 }
179 }
180}
181
182impl<Item, A, B> Deserialize<Item> for (A, B)
189where
190 A: Deserialize<Item>,
191 B: Deserialize<Item>,
192{
193 fn deserialize<S: Sender<Item = Item> + ?Sized>(
195 sender: &mut S,
196 ) -> Result<Self, Error<S::Error>> {
197 let a = sender.auto()?;
198 let b = sender.auto()?;
199 Ok((a, b))
200 }
201}
202
203impl<Item, A, B> Serialize<Item> for (A, B)
204where
205 A: Serialize<Item>,
206 B: Serialize<Item>,
207{
208 fn serialize<R: Receiver<Item = Item>>(self, receiver: &mut R) -> Result<(), R::Error> {
210 let (a, b) = self;
211 receiver.auto(a)?;
212 receiver.auto(b)?;
213 Ok(())
214 }
215}