1use std::io::{self, Cursor, Write};
2use uuid::Uuid;
3
4use std::collections::HashMap;
5use std::hash::Hash;
6use std::sync::Arc;
7
8use crate::{Buffer, VarInt, read_str, write_str};
9
10use byteorder::{BE, ReadBytesExt, WriteBytesExt};
11
12impl Buffer for i32 {
13 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
14 buffer.read_i32::<BE>().ok()
15 }
16
17 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
18 buffer.write_i32::<BE>(*self)
19 }
20}
21
22impl Buffer for u32 {
23 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
24 Some(i32::read_buf(buffer)? as u32)
25 }
26
27 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
28 i32::write_buf(&(*self as i32), buffer)
29 }
30}
31
32impl Buffer for u16 {
33 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
34 i16::read_buf(buffer).map(|i| i as u16)
35 }
36
37 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
38 i16::write_buf(&(*self as i16), buffer)
39 }
40}
41
42impl Buffer for i16 {
43 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
44 buffer.read_i16::<BE>().ok()
45 }
46
47 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
48 buffer.write_i16::<BE>(*self)
49 }
50}
51
52impl Buffer for i64 {
53 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
54 buffer.read_i64::<BE>().ok()
55 }
56
57 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
58 buffer.write_i64::<BE>(*self)
59 }
60}
61
62impl Buffer for u64 {
63 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
64 i64::read_buf(buffer).map(|i| i as u64)
65 }
66
67 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
68 buffer.write_u64::<BE>(*self)
69 }
70}
71
72impl Buffer for bool {
73 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
74 let byte = u8::read_buf(buffer)?;
75
76 if byte > 1 {
77 return None;
78 }
79
80 Some(byte != 0)
81 }
82
83 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
84 let byte = u8::from(*self);
85 byte.write_buf(buffer)
86 }
87}
88
89impl Buffer for u8 {
90 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
91 buffer.read_u8().ok()
92 }
93
94 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
95 buffer.write_u8(*self)
96 }
97}
98
99impl Buffer for i8 {
100 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
101 u8::read_buf(buffer).map(|i| i as i8)
102 }
103
104 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
105 (*self as u8).write_buf(buffer)
106 }
107}
108
109impl Buffer for f32 {
110 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
111 buffer.read_f32::<BE>().ok()
112 }
113
114 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
115 buffer.write_f32::<BE>(*self)
116 }
117}
118
119impl Buffer for f64 {
120 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
121 buffer.read_f64::<BE>().ok()
122 }
123
124 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
125 buffer.write_f64::<BE>(*self)
126 }
127}
128
129impl<K: Buffer + Eq + Hash, V: Buffer> Buffer for HashMap<K, V> {
130 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
131 let length = i32::read_varint(buffer)? as usize;
132 let mut contents = HashMap::with_capacity(usize::min(length, 65536));
133
134 for _ in 0..length {
135 contents.insert(K::read_buf(buffer)?, V::read_buf(buffer)?);
136 }
137
138 Some(contents)
139 }
140
141 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
142 (self.len() as i32).write_varint(buffer)?;
143
144 for (key, value) in self {
145 key.write_buf(buffer)?;
146 value.write_buf(buffer)?;
147 }
148
149 Ok(())
150 }
151}
152
153impl<T: Buffer> Buffer for Vec<T> {
154 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
155 let length = i32::read_varint(buffer)? as usize;
156 let mut contents = Vec::with_capacity(usize::min(length, 65536));
157
158 for _ in 0..length {
159 contents.push(T::read_buf(buffer)?);
160 }
161
162 Some(contents)
163 }
164
165 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
166 (self.len() as i32).write_varint(buffer)?;
167
168 for item in self.iter() {
169 T::write_buf(item, buffer)?;
170 }
171
172 Ok(())
173 }
174}
175
176impl<T: Buffer> Buffer for Box<[T]> {
177 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
178 let length = i32::read_varint(buffer)? as usize;
179 let mut contents = Vec::with_capacity(usize::min(length, 65536));
180
181 for _ in 0..length {
182 contents.push(T::read_buf(buffer)?);
183 }
184
185 Some(contents.into_boxed_slice())
186 }
187
188 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
189 (self.len() as i32).write_varint(buffer)?;
190
191 for item in self.iter() {
192 T::write_buf(item, buffer)?;
193 }
194
195 Ok(())
196 }
197}
198
199impl Buffer for String {
200 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
201 read_str(buffer).map(Into::into)
202 }
203
204 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
205 write_str(buffer, self)
206 }
207}
208
209impl Buffer for Box<str> {
210 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
211 read_str(buffer).map(Into::into)
212 }
213
214 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
215 write_str(buffer, self)
216 }
217}
218
219impl<T: Buffer> Buffer for Option<T> {
220 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
221 if bool::read_buf(buffer)? { Some(T::read_buf(buffer)) } else { None }
222 }
223
224 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
225 if let Some(s) = self {
226 true.write_buf(buffer)?;
227 s.write_buf(buffer)
228 } else {
229 false.write_buf(buffer)
230 }
231 }
232}
233
234impl<T: Buffer, const N: usize> Buffer for [T; N] {
235 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
236 let mut contents = Vec::with_capacity(N);
237
238 for _ in 0..N {
239 contents.push(T::read_buf(buffer)?);
240 }
241
242 contents.try_into().ok()
243 }
244
245 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
246 for item in self {
247 item.write_buf(buffer)?;
248 }
249
250 Ok(())
251 }
252}
253
254impl<T: Buffer> Buffer for Box<T> {
255 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
256 T::read_buf(buffer).map(Box::new)
257 }
258
259 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
260 T::write_buf(&**self, buffer)
261 }
262}
263
264impl<A: Buffer, B: Buffer> Buffer for (A, B) {
265 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
266 Some((A::read_buf(buffer)?, B::read_buf(buffer)?))
267 }
268
269 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
270 self.0.write_buf(buffer)?;
271 self.1.write_buf(buffer)
272 }
273}
274
275impl<T: Buffer> Buffer for Arc<T> {
276 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
277 Some(Arc::new(T::read_buf(buffer)?))
278 }
279
280 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
281 T::write_buf(&**self, buffer)
282 }
283}
284
285impl Buffer for Uuid {
286 fn read_buf(buffer: &mut Cursor<&[u8]>) -> Option<Self> {
287 let array = [u32::read_buf(buffer)?, u32::read_buf(buffer)?, u32::read_buf(buffer)?, u32::read_buf(buffer)?];
288
289 let most = ((array[0] as u64) << 32) | ((array[1] as u64) & 0xffffffff);
290 let least = ((array[2] as u64) << 32) | ((array[3] as u64) & 0xffffffff);
291
292 Some(Uuid::from_u128(((most as u128) << 64) | least as u128))
293 }
294
295 fn write_buf(&self, buffer: &mut impl Write) -> io::Result<()> {
296 let most = (self.as_u128() >> 64) as u64;
297 let least = (self.as_u128() & 0xffffffffffffffff) as u64;
298
299 let [a, b, c, d] = [(most >> 32) as u32, most as u32, (least >> 32) as u32, least as u32];
300
301 a.write_buf(buffer)?;
302 b.write_buf(buffer)?;
303 c.write_buf(buffer)?;
304 d.write_buf(buffer)?;
305 Ok(())
306 }
307}