1use crate::{TBuffer, TBytes};
2use ::core::{i128, i16, i32, i64, i8, isize, u128, u16, u32, u64, u8, usize};
3
4impl TBytes for u8 {
5 fn size(&self) -> usize {
6 1
7 }
8
9 fn to_bytes(&self) -> Vec<u8> {
10 self.to_le_bytes().to_vec()
11 }
12
13 fn from_bytes(buffer: &mut TBuffer) -> Option<Self> {
14 if buffer.len() < Self::default().size() {
15 return None;
16 }
17 let mut buffer = buffer.drain(0..Self::default().size());
18 let bytes = [buffer.next()?];
19 Some(u8::from_le_bytes(bytes))
20 }
21}
22
23impl TBytes for u16 {
24 fn size(&self) -> usize {
25 2
26 }
27
28 fn to_bytes(&self) -> Vec<u8> {
29 self.to_le_bytes().to_vec()
30 }
31
32 fn from_bytes(buffer: &mut TBuffer) -> Option<Self> {
33 if buffer.len() < Self::default().size() {
34 return None;
35 }
36 let mut buffer = buffer.drain(0..Self::default().size());
37 let bytes = [buffer.next()?, buffer.next()?];
38 Some(u16::from_le_bytes(bytes))
39 }
40}
41
42impl TBytes for u32 {
43 fn size(&self) -> usize {
44 4
45 }
46
47 fn to_bytes(&self) -> Vec<u8> {
48 self.to_le_bytes().to_vec()
49 }
50
51 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
52 where
53 Self: Sized,
54 {
55 if buffer.len() < Self::default().size() {
56 return None;
57 }
58 let mut buffer = buffer.drain(0..Self::default().size());
59 let bytes = [
60 buffer.next()?,
61 buffer.next()?,
62 buffer.next()?,
63 buffer.next()?,
64 ];
65 Some(u32::from_le_bytes(bytes))
66 }
67}
68
69impl TBytes for u64 {
70 fn size(&self) -> usize {
71 8
72 }
73
74 fn to_bytes(&self) -> Vec<u8> {
75 self.to_le_bytes().to_vec()
76 }
77
78 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
79 where
80 Self: Sized,
81 {
82 if buffer.len() < Self::default().size() {
83 return None;
84 }
85 let mut buffer = buffer.drain(0..Self::default().size());
86 let bytes = [
87 buffer.next()?,
88 buffer.next()?,
89 buffer.next()?,
90 buffer.next()?,
91 buffer.next()?,
92 buffer.next()?,
93 buffer.next()?,
94 buffer.next()?,
95 ];
96 Some(u64::from_le_bytes(bytes))
97 }
98}
99
100impl TBytes for u128 {
101 fn size(&self) -> usize {
102 16
103 }
104
105 fn to_bytes(&self) -> Vec<u8> {
106 self.to_le_bytes().to_vec()
107 }
108 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
109 where
110 Self: Sized,
111 {
112 if buffer.len() < Self::default().size() {
113 return None;
114 }
115 let mut buffer = buffer.drain(0..Self::default().size());
116 let bytes = [
117 buffer.next()?,
118 buffer.next()?,
119 buffer.next()?,
120 buffer.next()?,
121 buffer.next()?,
122 buffer.next()?,
123 buffer.next()?,
124 buffer.next()?,
125 buffer.next()?,
126 buffer.next()?,
127 buffer.next()?,
128 buffer.next()?,
129 buffer.next()?,
130 buffer.next()?,
131 buffer.next()?,
132 buffer.next()?,
133 ];
134 Some(u128::from_le_bytes(bytes))
135 }
136}
137
138impl TBytes for usize {
139 fn size(&self) -> usize {
140 8
141 }
142
143 fn to_bytes(&self) -> Vec<u8> {
144 self.to_le_bytes().to_vec()
145 }
146
147 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
148 where
149 Self: Sized,
150 {
151 if buffer.len() < Self::default().size() {
152 return None;
153 }
154 let mut buffer = buffer.drain(0..Self::default().size());
155 let bytes = [
156 buffer.next()?,
157 buffer.next()?,
158 buffer.next()?,
159 buffer.next()?,
160 buffer.next()?,
161 buffer.next()?,
162 buffer.next()?,
163 buffer.next()?,
164 ];
165 Some(usize::from_le_bytes(bytes))
166 }
167}
168
169impl TBytes for i8 {
170 fn size(&self) -> usize {
171 1
172 }
173
174 fn to_bytes(&self) -> Vec<u8> {
175 self.to_le_bytes().to_vec()
176 }
177
178 fn from_bytes(buffer: &mut TBuffer) -> Option<Self> {
179 if buffer.len() < Self::default().size() {
180 return None;
181 }
182 let mut buffer = buffer.drain(0..Self::default().size());
183 let bytes = [buffer.next()?];
184 Some(i8::from_le_bytes(bytes))
185 }
186}
187
188impl TBytes for i16 {
189 fn size(&self) -> usize {
190 2
191 }
192
193 fn to_bytes(&self) -> Vec<u8> {
194 self.to_le_bytes().to_vec()
195 }
196
197 fn from_bytes(buffer: &mut TBuffer) -> Option<Self> {
198 if buffer.len() < Self::default().size() {
199 return None;
200 }
201 let mut buffer = buffer.drain(0..Self::default().size());
202 let bytes = [buffer.next()?, buffer.next()?];
203 Some(i16::from_le_bytes(bytes))
204 }
205}
206
207impl TBytes for i32 {
208 fn size(&self) -> usize {
209 4
210 }
211
212 fn to_bytes(&self) -> Vec<u8> {
213 self.to_le_bytes().to_vec()
214 }
215
216 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
217 where
218 Self: Sized,
219 {
220 if buffer.len() < Self::default().size() {
221 return None;
222 }
223 let mut buffer = buffer.drain(0..Self::default().size());
224 let bytes = [
225 buffer.next()?,
226 buffer.next()?,
227 buffer.next()?,
228 buffer.next()?,
229 ];
230 Some(i32::from_le_bytes(bytes))
231 }
232}
233
234impl TBytes for i64 {
235 fn size(&self) -> usize {
236 8
237 }
238
239 fn to_bytes(&self) -> Vec<u8> {
240 self.to_le_bytes().to_vec()
241 }
242
243 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
244 where
245 Self: Sized,
246 {
247 if buffer.len() < Self::default().size() {
248 return None;
249 }
250 let mut buffer = buffer.drain(0..Self::default().size());
251 let bytes = [
252 buffer.next()?,
253 buffer.next()?,
254 buffer.next()?,
255 buffer.next()?,
256 buffer.next()?,
257 buffer.next()?,
258 buffer.next()?,
259 buffer.next()?,
260 ];
261 Some(i64::from_le_bytes(bytes))
262 }
263}
264
265impl TBytes for i128 {
266 fn size(&self) -> usize {
267 16
268 }
269
270 fn to_bytes(&self) -> Vec<u8> {
271 self.to_le_bytes().to_vec()
272 }
273 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
274 where
275 Self: Sized,
276 {
277 if buffer.len() < Self::default().size() {
278 return None;
279 }
280 let mut buffer = buffer.drain(0..Self::default().size());
281 let bytes = [
282 buffer.next()?,
283 buffer.next()?,
284 buffer.next()?,
285 buffer.next()?,
286 buffer.next()?,
287 buffer.next()?,
288 buffer.next()?,
289 buffer.next()?,
290 buffer.next()?,
291 buffer.next()?,
292 buffer.next()?,
293 buffer.next()?,
294 buffer.next()?,
295 buffer.next()?,
296 buffer.next()?,
297 buffer.next()?,
298 ];
299 Some(i128::from_le_bytes(bytes))
300 }
301}
302
303impl TBytes for isize {
304 fn size(&self) -> usize {
305 8
306 }
307
308 fn to_bytes(&self) -> Vec<u8> {
309 self.to_le_bytes().to_vec()
310 }
311
312 fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
313 where
314 Self: Sized,
315 {
316 if buffer.len() < Self::default().size() {
317 return None;
318 }
319 let mut buffer = buffer.drain(0..Self::default().size());
320 let bytes = [
321 buffer.next()?,
322 buffer.next()?,
323 buffer.next()?,
324 buffer.next()?,
325 buffer.next()?,
326 buffer.next()?,
327 buffer.next()?,
328 buffer.next()?,
329 ];
330 Some(isize::from_le_bytes(bytes))
331 }
332}
333
334#[cfg(test)]
335mod test {
336 use crate::TBytes;
337
338 #[test]
339 fn u8() {
340 let a = 42u8;
341
342 let mut b = a.to_bytes();
343 let other = u8::from_bytes(&mut b).unwrap();
344
345 assert_eq!(a, other)
346 }
347
348 #[test]
349 fn u16() {
350 let a = 42u16;
351
352 let mut b = a.to_bytes();
353 let other = u16::from_bytes(&mut b).unwrap();
354
355 assert_eq!(a, other)
356 }
357
358 #[test]
359 fn u32() {
360 let a = 42u32;
361
362 let mut b = a.to_bytes();
363 let other = u32::from_bytes(&mut b).unwrap();
364
365 assert_eq!(a, other)
366 }
367
368 #[test]
369 fn u64() {
370 let a = 42u64;
371
372 let mut b = a.to_bytes();
373 let other = u64::from_bytes(&mut b).unwrap();
374
375 assert_eq!(a, other)
376 }
377
378 #[test]
379 fn u128() {
380 let a = 42u128;
381
382 let mut b = a.to_bytes();
383 let other = u128::from_bytes(&mut b).unwrap();
384
385 assert_eq!(a, other)
386 }
387
388 #[test]
389 fn usize() {
390 let a = 42usize;
391
392 let mut b = a.to_bytes();
393 let other = usize::from_bytes(&mut b).unwrap();
394
395 assert_eq!(a, other)
396 }
397
398 #[test]
399 fn i8() {
400 let a = 42i8;
401
402 let mut b = a.to_bytes();
403 let other = i8::from_bytes(&mut b).unwrap();
404
405 assert_eq!(a, other)
406 }
407
408 #[test]
409 fn i16() {
410 let a = 42i16;
411
412 let mut b = a.to_bytes();
413 let other = i16::from_bytes(&mut b).unwrap();
414
415 assert_eq!(a, other)
416 }
417
418 #[test]
419 fn i32() {
420 let a = 42i32;
421
422 let mut b = a.to_bytes();
423 let other = i32::from_bytes(&mut b).unwrap();
424
425 assert_eq!(a, other)
426 }
427
428 #[test]
429 fn i64() {
430 let a = 42i64;
431
432 let mut b = a.to_bytes();
433 let other = i64::from_bytes(&mut b).unwrap();
434
435 assert_eq!(a, other)
436 }
437
438 #[test]
439 fn i128() {
440 let a = 42i128;
441
442 let mut b = a.to_bytes();
443 let other = i128::from_bytes(&mut b).unwrap();
444
445 assert_eq!(a, other)
446 }
447
448 #[test]
449 fn isize() {
450 let a = 42isize;
451
452 let mut b = a.to_bytes();
453 let other = isize::from_bytes(&mut b).unwrap();
454
455 assert_eq!(a, other)
456 }
457
458 #[test]
459 fn incomplete_u16() {
460 let mut buffer = Vec::new();
461 buffer.push(10);
462 let clone_buffer = buffer.clone();
463
464 let other_buffer = u16::from_bytes(&mut buffer);
465 if let Some(other_buffer) = other_buffer {
466 panic!("This should be possible! Other buffer: {other_buffer:?}");
467 }
468
469 assert_eq!(buffer, clone_buffer);
470 buffer.push(1);
471
472 let value = u16::from_bytes(&mut buffer).unwrap();
473 assert_eq!(value, 266)
474 }
475}