plain_binary_stream/
binary_stream.rs

1use std::{collections::VecDeque, io::{self, Error}};
2
3use crate::util::{PacketType, Serializable};
4
5pub enum BinaryStreamMode {
6    Read,
7    Write
8}
9
10pub struct BinaryStream {
11    pub mode: BinaryStreamMode,
12    buffer: VecDeque<u8>
13}
14
15pub fn collect_array<T, I, const N: usize>(itr: I) -> [T; N]
16    where
17        T: Default + Copy,
18        I: IntoIterator<Item = T>,
19{
20    let mut res = [T::default(); N];
21    for (it, elem) in res.iter_mut().zip(itr) {
22        *it = elem
23    }
24
25    res
26}
27
28impl BinaryStream {
29    pub fn new() -> BinaryStream {
30        BinaryStream {
31            mode: BinaryStreamMode::Write,
32            buffer: VecDeque::new()
33        }
34    }
35
36    pub fn with_capacity(expected_size: usize) -> BinaryStream {
37        BinaryStream {
38            mode: BinaryStreamMode::Write,
39            buffer: VecDeque::with_capacity(expected_size)
40        }
41    }
42
43    pub fn from_buffer(buffer: VecDeque<u8>) -> BinaryStream {
44        BinaryStream {
45            mode: BinaryStreamMode::Read,
46            buffer
47        }
48    }
49
50    pub fn from_bytes(bytes: &[u8]) -> BinaryStream {
51        BinaryStream {
52            mode: BinaryStreamMode::Read,
53            buffer: bytes.to_vec().into()
54        }
55    }
56
57    pub fn size(&self) -> usize {
58        self.buffer.len()
59    }
60
61    pub fn get_buffer(self) -> VecDeque<u8> {
62        self.buffer
63    }
64
65    pub fn get_buffer_vec(mut self) -> Vec<u8> {
66        self.buffer.make_contiguous().to_vec()
67    }
68
69    pub fn get_buffer_clone(&self) -> VecDeque<u8> {
70        self.buffer.clone()
71    }
72
73    pub fn get_buffer_vec_clone(&self) -> Vec<u8> {
74        self.buffer.clone().make_contiguous().to_vec()
75    }
76
77    // Writing
78
79    pub fn write_bool(&mut self, val: bool) -> io::Result<()> {
80        self.write_buffer_single(val as u8)
81    }
82
83    pub fn write_u16(&mut self, val: u16) -> io::Result<()> {
84        self.write_buffer(&val.to_le_bytes().to_vec())
85    }
86
87    pub fn write_u32(&mut self, val: u32) -> io::Result<()> {
88        self.write_buffer(&val.to_le_bytes().to_vec())
89    }
90
91    pub fn write_u64(&mut self, val: u64) -> io::Result<()> {
92        self.write_buffer(&val.to_le_bytes().to_vec())
93    }
94
95    pub fn write_u128(&mut self, val: u128) -> io::Result<()> {
96        self.write_buffer(&val.to_le_bytes().to_vec())
97    }
98
99    pub fn write_i64(&mut self, val: i64) -> io::Result<()> {
100        self.write_buffer(&val.to_le_bytes().to_vec())
101    }
102
103    pub fn write_f32(&mut self, val: f32) -> io::Result<()> {
104        self.write_buffer(&val.to_le_bytes().to_vec())
105    }
106
107    pub fn write_string(&mut self, val: &String) -> io::Result<()> {
108        let string_bytes = val.as_bytes();
109        self.write_u32(string_bytes.len() as u32)?;
110        self.write_buffer(&val.as_bytes().to_vec())
111    }
112
113    pub fn write_byte_vec(&mut self, val: &Vec<u8>) -> io::Result<()> {
114        self.write_u32(val.len() as u32)?;
115        self.write_buffer(val)?;
116        Ok(())
117    }
118
119    pub fn write_vec<T: Serializable>(&mut self, val: &Vec<T>) -> io::Result<()> {
120        self.write_u32(val.len() as u32)?;
121        val.iter().for_each(|x| x.to_stream(self));
122        Ok(())
123    }
124
125    pub fn write_packet_type<T: PacketType>(&mut self, val: T) -> io::Result<()> {
126        self.write_buffer_single(val.to_byte())
127    }
128
129    // Really needed?
130    pub fn write_buffer_size(&mut self) -> io::Result<()> {
131        self.write_u32(self.buffer.len() as u32)
132    }
133
134    // Reading
135
136    pub fn read_bool(&mut self) -> io::Result<bool> {
137        self.read_buffer_single().map(|byte| byte == 1)
138    }
139
140    pub fn read_u16(&mut self) -> io::Result<u16> {
141        let bytes = collect_array(self.read_buffer(2)?);
142        Ok(u16::from_le_bytes(bytes))
143    }
144
145    pub fn read_u32(&mut self) -> io::Result<u32> {
146        let bytes = collect_array(self.read_buffer(4)?);
147        Ok(u32::from_le_bytes(bytes))
148    }
149
150    pub fn read_u64(&mut self) -> io::Result<u64> {
151        let bytes = collect_array(self.read_buffer(8)?);
152        Ok(u64::from_le_bytes(bytes))
153    }
154
155    pub fn read_u128(&mut self) -> io::Result<u128> {
156        let bytes = collect_array(self.read_buffer(16)?);
157        Ok(u128::from_le_bytes(bytes))
158    }
159
160    pub fn read_i64(&mut self) -> io::Result<i64> {
161        let bytes = collect_array(self.read_buffer(8)?);
162        Ok(i64::from_le_bytes(bytes))
163    }
164
165    pub fn read_f32(&mut self) -> io::Result<f32> {
166        let bytes = collect_array(self.read_buffer(4)?);
167        Ok(f32::from_le_bytes(bytes))
168    }
169
170    pub fn read_string(&mut self) -> io::Result<String> {
171        let string_size = self.read_u32()? as usize;
172        Ok(String::from_utf8(self.read_buffer(string_size)?).unwrap())
173    }
174
175    pub fn read_byte_vec(&mut self) -> io::Result<Vec<u8>> {
176        let vec_size = self.read_u32()? as usize;
177        self.read_buffer(vec_size)
178    }
179
180    pub fn read_vec<T: Serializable>(&mut self) -> io::Result<Vec<T>> {
181        let vec_size = self.read_u32()?;
182        let mut vec = Vec::with_capacity(vec_size as usize);
183        for _ in 0..vec_size {
184            let t = T::from_stream(self);
185            vec.push(t);
186        }
187
188        Ok(vec)
189    }
190
191    pub fn read_packet_type<T: PacketType>(&mut self) -> io::Result<T> {
192        Ok(T::from_byte(self.read_buffer_single()?).unwrap())
193    }
194
195    pub fn read_buffer_size(&mut self) -> io::Result<u32> {
196        self.read_u32()
197    }
198    
199    // Abstract writing/reading
200
201    pub fn write_buffer_single(&mut self, byte: u8) -> io::Result<()> {
202        match self.mode {
203            BinaryStreamMode::Read => Err(Error::new(io::ErrorKind::PermissionDenied, "Stream is in read-only mode")),
204            BinaryStreamMode::Write => {
205                self.buffer.push_back(byte);
206                Ok(())
207            }
208        }
209    }
210
211    pub fn write_buffer(&mut self, bytes: &Vec<u8>) -> io::Result<()> {
212        match self.mode {
213            BinaryStreamMode::Read => Err(Error::new(io::ErrorKind::PermissionDenied, "Stream is in read-only mode")),
214            BinaryStreamMode::Write => {
215                self.buffer.extend(bytes);
216                Ok(())
217            }
218        }
219    }
220
221    pub fn write_buffer_slice(&mut self, bytes: &[u8]) -> io::Result<()> {
222        match self.mode {
223            BinaryStreamMode::Read => Err(Error::new(io::ErrorKind::PermissionDenied, "Stream is in read-only mode")),
224            BinaryStreamMode::Write => {
225                self.buffer.extend(bytes);
226                Ok(())
227            }
228        }
229    }
230
231    pub fn read_buffer_single(&mut self) -> io::Result<u8> {
232        match self.mode {
233            BinaryStreamMode::Write => Err(Error::new(io::ErrorKind::PermissionDenied, "Stream is in writing mode")),
234            BinaryStreamMode::Read => {
235                Ok(self.buffer.pop_front().unwrap())
236            }
237        }
238    }
239
240    pub fn read_buffer(&mut self, count: usize) -> io::Result<Vec<u8>> {
241        match self.mode {
242            BinaryStreamMode::Write => Err(Error::new(io::ErrorKind::PermissionDenied, "Stream is in writing mode")),
243            BinaryStreamMode::Read => {
244                let mut bytes = vec![];
245                for _ in 0..count {
246                    bytes.push(self.buffer.pop_front().unwrap());
247                }
248
249                Ok(bytes)
250            }
251        }
252    }
253
254    // TODO: Read buffer slice
255}
plain_binary_stream/binary_stream.rs

plain_binary_stream/
binary_stream.rs
