1
2use std::io::{Result, ErrorKind};
4use bytes::{BytesMut, Buf, BufMut};
5
6use crate::zero_filled_bytes_mut;
7#[async_trait]
10pub trait ReadPreReqs {
11 async fn read(&mut self, byts: &mut BytesMut) -> Result<()>;
12}
13
14#[async_trait]
15pub trait Reader: ReadPreReqs {
16 async fn read_u8(&mut self) -> Result<u8> {
17 let mut byts = zero_filled_bytes_mut(1);
18 self.read(&mut byts).await?;
19 let res = byts.get_u8();
20 Ok(res)
21 }
22
23 async fn read_u16(&mut self) -> Result<u16> {
24 let mut byts = zero_filled_bytes_mut(2);
25 self.read(&mut byts).await?;
26 let res = byts.get_u16();
27 Ok(res)
28 }
29
30 async fn read_u32(&mut self) -> Result<u32> {
31 let mut byts = zero_filled_bytes_mut(4);
32 self.read(&mut byts).await?;
33 let res = byts.get_u32();
34 Ok(res)
35 }
36
37 async fn read_u64(&mut self) -> Result<u64> {
38 let mut byts = zero_filled_bytes_mut(8);
39 self.read(&mut byts).await?;
40 let res = byts.get_u64();
41 Ok(res)
42 }
43
44 async fn read_u128(&mut self) -> Result<u128> {
45 let mut byts = zero_filled_bytes_mut(16);
46 self.read(&mut byts).await?;
47 let res = byts.get_u128();
48 Ok(res)
49 }
50
51 async fn read_i8(&mut self) -> Result<i8> {
52 let mut byts = zero_filled_bytes_mut(1);
53 self.read(&mut byts).await?;
54 let res = byts.get_i8();
55 Ok(res)
56 }
57
58 async fn read_i16(&mut self) -> Result<i16> {
59 let mut byts = zero_filled_bytes_mut(2);
60 self.read(&mut byts).await?;
61 let res = byts.get_i16();
62 Ok(res)
63 }
64
65 async fn read_i32(&mut self) -> Result<i32> {
66 let mut byts = zero_filled_bytes_mut(4);
67 self.read(&mut byts).await?;
68 let res = byts.get_i32();
69 Ok(res)
70 }
71
72 async fn read_i64(&mut self) -> Result<i64> {
73 let mut byts = zero_filled_bytes_mut(8);
74 self.read(&mut byts).await?;
75 let res = byts.get_i64();
76 Ok(res)
77 }
78
79 async fn read_i128(&mut self) -> Result<i128> {
80 let mut byts = zero_filled_bytes_mut(16);
81 self.read(&mut byts).await?;
82 let res = byts.get_i128();
83 Ok(res)
84 }
85
86 async fn read_f32(&mut self) -> Result<f32> {
87 let mut byts = zero_filled_bytes_mut(4);
88 self.read(&mut byts).await?;
89 let res = byts.get_f32();
90 Ok(res)
91 }
92
93 async fn read_f64(&mut self) -> Result<f64> {
94 let mut byts = zero_filled_bytes_mut(8);
95 self.read(&mut byts).await?;
96 let res = byts.get_f64();
97 Ok(res)
98 }
99
100 async fn read_string(&mut self, len: usize) -> Result<String> {
101 let mut byts = zero_filled_bytes_mut(len);
102 self.read(&mut byts).await?;
103 let res = String::from_utf8(byts.to_vec());
104 if let Err(_) = res {
105 Err(std::io::Error::new(ErrorKind::InvalidData, "Could not read bytes as UTF-8 compatible string"))
106 } else if let Ok(data) = res {
107 Ok(data)
108 } else { unreachable!() }
109 }
110}
111
112#[async_trait]
115pub trait WritePreReqs {
116 async fn write(&mut self, byts: &mut BytesMut) -> Result<()>;
117}
118
119#[async_trait]
120pub trait Writer: WritePreReqs {
121 async fn write_u8(&mut self, data: u8) -> Result<()> {
122 let mut byts = BytesMut::new();
123 byts.put_u8(data);
124 self.write(&mut byts).await?;
125 Ok(())
126 }
127
128 async fn write_u16(&mut self, data: u16) -> Result<()> {
129 let mut byts = BytesMut::new();
130 byts.put_u16(data);
131 self.write(&mut byts).await?;
132 Ok(())
133 }
134
135 async fn write_u32(&mut self, data: u32) -> Result<()> {
136 let mut byts = BytesMut::new();
137 byts.put_u32(data);
138 self.write(&mut byts).await?;
139 Ok(())
140 }
141
142 async fn write_u64(&mut self, data: u64) -> Result<()> {
143 let mut byts = BytesMut::new();
144 byts.put_u64(data);
145 self.write(&mut byts).await?;
146 Ok(())
147 }
148
149 async fn write_u128(&mut self, data: u128) -> Result<()> {
150 let mut byts = BytesMut::new();
151 byts.put_u128(data);
152 self.write(&mut byts).await?;
153 Ok(())
154 }
155
156 async fn write_i8(&mut self, data: i8) -> Result<()> {
157 let mut byts = BytesMut::new();
158 byts.put_i8(data);
159 self.write(&mut byts).await?;
160 Ok(())
161 }
162
163 async fn write_i16(&mut self, data: i16) -> Result<()> {
164 let mut byts = BytesMut::new();
165 byts.put_i16(data);
166 self.write(&mut byts).await?;
167 Ok(())
168 }
169
170 async fn write_i32(&mut self, data: i32) -> Result<()> {
171 let mut byts = BytesMut::new();
172 byts.put_i32(data);
173 self.write(&mut byts).await?;
174 Ok(())
175 }
176
177 async fn write_i64(&mut self, data: i64) -> Result<()> {
178 let mut byts = BytesMut::new();
179 byts.put_i64(data);
180 self.write(&mut byts).await?;
181 Ok(())
182 }
183
184 async fn write_i128(&mut self, data: i128) -> Result<()> {
185 let mut byts = BytesMut::new();
186 byts.put_i128(data);
187 self.write(&mut byts).await?;
188 Ok(())
189 }
190
191 async fn write_f32(&mut self, data: f32) -> Result<()> {
192 let mut byts = BytesMut::new();
193 byts.put_f32(data);
194 self.write(&mut byts).await?;
195 Ok(())
196 }
197
198 async fn write_f64(&mut self, data: f64) -> Result<()> {
199 let mut byts = BytesMut::new();
200 byts.put_f64(data);
201 self.write(&mut byts).await?;
202 Ok(())
203 }
204
205 async fn write_string(&mut self, data: String) -> Result<()> {
206 let mut byts = BytesMut::new();
207 byts.put(data.as_bytes());
208 self.write(&mut byts).await?;
209 Ok(())
210 }
211}