trellis_net/
rw.rs

1
2// ===== Imports =====
3use std::io::{Result, ErrorKind};
4use bytes::{BytesMut, Buf, BufMut};
5
6use crate::zero_filled_bytes_mut;
7// ===================
8
9#[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// =============================================================
113
114#[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}