endi/
io.rs

1use std::io::{Read, Result, Write};
2
3use crate::Endian;
4
5macro_rules! decl_read_method {
6    ($type:ty, $method:ident) => {
7        #[doc = concat!("Read a `", stringify!($type), "`.")]
8        fn $method(&mut self, endian: Endian) -> Result<$type>;
9    };
10}
11
12/// A trait for reading bytes.
13///
14/// This is implemented for all types that implement [`Read`].
15pub trait ReadBytes {
16    decl_read_method!(u8, read_u8);
17    decl_read_method!(u16, read_u16);
18    decl_read_method!(u32, read_u32);
19    decl_read_method!(u64, read_u64);
20    decl_read_method!(u128, read_u128);
21
22    decl_read_method!(i8, read_i8);
23    decl_read_method!(i16, read_i16);
24    decl_read_method!(i32, read_i32);
25    decl_read_method!(i64, read_i64);
26    decl_read_method!(i128, read_i128);
27
28    decl_read_method!(f32, read_f32);
29    decl_read_method!(f64, read_f64);
30}
31
32macro_rules! impl_read_method {
33    ($type:ty, $method:ident, $size:literal) => {
34        #[inline]
35        fn $method(&mut self, endian: Endian) -> Result<$type> {
36            let mut buf = [0; $size];
37            self.read_exact(&mut buf)?;
38            Ok(endian.$method(&buf))
39        }
40    };
41}
42
43impl<R: Read> ReadBytes for R {
44    impl_read_method!(u8, read_u8, 1);
45    impl_read_method!(u16, read_u16, 2);
46    impl_read_method!(u32, read_u32, 4);
47    impl_read_method!(u64, read_u64, 8);
48    impl_read_method!(u128, read_u128, 16);
49
50    impl_read_method!(i8, read_i8, 1);
51    impl_read_method!(i16, read_i16, 2);
52    impl_read_method!(i32, read_i32, 4);
53    impl_read_method!(i64, read_i64, 8);
54    impl_read_method!(i128, read_i128, 16);
55
56    impl_read_method!(f32, read_f32, 4);
57    impl_read_method!(f64, read_f64, 8);
58}
59
60macro_rules! decl_write_method {
61    ($type:ty, $method:ident) => {
62        #[doc = concat!("Write a `", stringify!($type), "`.")]
63        fn $method(&mut self, endian: Endian, n: $type) -> Result<()>;
64    };
65}
66
67/// A trait for writing bytes.
68///
69/// This is implemented for all types that implement [`Write`].
70pub trait WriteBytes {
71    decl_write_method!(u8, write_u8);
72    decl_write_method!(u16, write_u16);
73    decl_write_method!(u32, write_u32);
74    decl_write_method!(u64, write_u64);
75    decl_write_method!(u128, write_u128);
76
77    decl_write_method!(i8, write_i8);
78    decl_write_method!(i16, write_i16);
79    decl_write_method!(i32, write_i32);
80    decl_write_method!(i64, write_i64);
81    decl_write_method!(i128, write_i128);
82
83    decl_write_method!(f32, write_f32);
84    decl_write_method!(f64, write_f64);
85}
86
87macro_rules! impl_write_method {
88    ($type:ty, $method:ident, $size:literal) => {
89        #[inline]
90        fn $method(&mut self, endian: Endian, n: $type) -> Result<()> {
91            let mut buf = [0; $size];
92            endian.$method(&mut buf, n);
93            self.write_all(&buf)
94        }
95    };
96}
97
98impl<W: Write> WriteBytes for W {
99    impl_write_method!(u8, write_u8, 1);
100    impl_write_method!(u16, write_u16, 2);
101    impl_write_method!(u32, write_u32, 4);
102    impl_write_method!(u64, write_u64, 8);
103    impl_write_method!(u128, write_u128, 16);
104
105    impl_write_method!(i8, write_i8, 1);
106    impl_write_method!(i16, write_i16, 2);
107    impl_write_method!(i32, write_i32, 4);
108    impl_write_method!(i64, write_i64, 8);
109    impl_write_method!(i128, write_i128, 16);
110
111    impl_write_method!(f32, write_f32, 4);
112    impl_write_method!(f64, write_f64, 8);
113}