paper_utils/stream/
reader.rs

1/*
2 * Copyright (c) Kia Shakiba
3 *
4 * This source code is licensed under the GNU AGPLv3 license found in the
5 * LICENSE file in the root directory of this source tree.
6 */
7
8use std::io::{Cursor, Read};
9
10use byteorder::{LittleEndian, ReadBytesExt};
11#[cfg(feature = "tokio")]
12use tokio::io::AsyncRead;
13
14use crate::stream::{Buffer, StreamError, read_buf, read_stack_buf};
15#[cfg(feature = "tokio")]
16use crate::stream::{read_buf_async, read_stack_buf_async};
17
18pub const TRUE_INDICATOR: u8 = 33;
19pub const FALSE_INDICATOR: u8 = 63;
20
21pub struct StreamReader<'a, R>
22where
23	R: Read,
24{
25	reader: &'a mut R,
26}
27
28#[cfg(feature = "tokio")]
29pub struct AsyncStreamReader<'a, R>
30where
31	R: AsyncRead,
32{
33	reader: &'a mut R,
34}
35
36impl<'a, R> StreamReader<'a, R>
37where
38	R: Read,
39{
40	pub fn new(reader: &'a mut R) -> Self {
41		StreamReader {
42			reader,
43		}
44	}
45
46	pub fn read_bool(&mut self) -> Result<bool, StreamError> {
47		let buf = read_stack_buf::<1>(self.reader)?;
48
49		match buf[0] {
50			TRUE_INDICATOR => Ok(true),
51			FALSE_INDICATOR => Ok(false),
52
53			_ => Err(StreamError::InvalidData),
54		}
55	}
56
57	pub fn read_u8(&mut self) -> Result<u8, StreamError> {
58		let buf = read_stack_buf::<1>(self.reader)?;
59		Ok(buf[0])
60	}
61
62	pub fn read_u16(&mut self) -> Result<u16, StreamError> {
63		let buf = read_stack_buf::<2>(self.reader)?;
64		let mut rdr = Cursor::new(buf);
65
66		rdr.read_u16::<LittleEndian>()
67			.map_err(|_| StreamError::InvalidData)
68	}
69
70	pub fn read_u32(&mut self) -> Result<u32, StreamError> {
71		let buf = read_stack_buf::<4>(self.reader)?;
72		let mut rdr = Cursor::new(buf);
73
74		rdr.read_u32::<LittleEndian>()
75			.map_err(|_| StreamError::InvalidData)
76	}
77
78	pub fn read_u64(&mut self) -> Result<u64, StreamError> {
79		let buf = read_stack_buf::<8>(self.reader)?;
80		let mut rdr = Cursor::new(buf);
81
82		rdr.read_u64::<LittleEndian>()
83			.map_err(|_| StreamError::InvalidData)
84	}
85
86	pub fn read_f32(&mut self) -> Result<f32, StreamError> {
87		let buf = read_stack_buf::<4>(self.reader)?;
88		let mut rdr = Cursor::new(buf);
89
90		rdr.read_f32::<LittleEndian>()
91			.map_err(|_| StreamError::InvalidData)
92	}
93
94	pub fn read_f64(&mut self) -> Result<f64, StreamError> {
95		let buf = read_stack_buf::<8>(self.reader)?;
96		let mut rdr = Cursor::new(buf);
97
98		rdr.read_f64::<LittleEndian>()
99			.map_err(|_| StreamError::InvalidData)
100	}
101
102	pub fn read_buf(&mut self) -> Result<Buffer, StreamError> {
103		let size = self.read_u32()? as usize;
104		read_buf(self.reader, size)
105	}
106
107	pub fn read_string(&mut self) -> Result<String, StreamError> {
108		let size = self.read_u32()? as usize;
109		let buf = read_buf(self.reader, size)?;
110
111		String::from_utf8(buf.to_vec()).map_err(|_| StreamError::InvalidData)
112	}
113}
114
115#[cfg(feature = "tokio")]
116impl<'a, R> AsyncStreamReader<'a, R>
117where
118	R: AsyncRead + Unpin,
119{
120	pub fn new(reader: &'a mut R) -> Self {
121		AsyncStreamReader {
122			reader,
123		}
124	}
125
126	pub async fn read_bool(&mut self) -> Result<bool, StreamError> {
127		let buf = read_stack_buf_async::<R, 1>(self.reader).await?;
128
129		match buf[0] {
130			TRUE_INDICATOR => Ok(true),
131			FALSE_INDICATOR => Ok(false),
132
133			_ => Err(StreamError::InvalidData),
134		}
135	}
136
137	pub async fn read_u8(&mut self) -> Result<u8, StreamError> {
138		let buf = read_stack_buf_async::<R, 1>(self.reader).await?;
139		Ok(buf[0])
140	}
141
142	pub async fn read_u16(&mut self) -> Result<u16, StreamError> {
143		let buf = read_stack_buf_async::<R, 2>(self.reader).await?;
144		let mut rdr = Cursor::new(buf);
145
146		rdr.read_u16::<LittleEndian>()
147			.map_err(|_| StreamError::InvalidData)
148	}
149
150	pub async fn read_u32(&mut self) -> Result<u32, StreamError> {
151		let buf = read_stack_buf_async::<R, 4>(self.reader).await?;
152		let mut rdr = Cursor::new(buf);
153
154		rdr.read_u32::<LittleEndian>()
155			.map_err(|_| StreamError::InvalidData)
156	}
157
158	pub async fn read_u64(&mut self) -> Result<u64, StreamError> {
159		let buf = read_stack_buf_async::<R, 8>(self.reader).await?;
160		let mut rdr = Cursor::new(buf);
161
162		rdr.read_u64::<LittleEndian>()
163			.map_err(|_| StreamError::InvalidData)
164	}
165
166	pub async fn read_f32(&mut self) -> Result<f32, StreamError> {
167		let buf = read_stack_buf_async::<R, 4>(self.reader).await?;
168		let mut rdr = Cursor::new(buf);
169
170		rdr.read_f32::<LittleEndian>()
171			.map_err(|_| StreamError::InvalidData)
172	}
173
174	pub async fn read_f64(&mut self) -> Result<f64, StreamError> {
175		let buf = read_stack_buf_async::<R, 8>(self.reader).await?;
176		let mut rdr = Cursor::new(buf);
177
178		rdr.read_f64::<LittleEndian>()
179			.map_err(|_| StreamError::InvalidData)
180	}
181
182	pub async fn read_buf(&mut self) -> Result<Buffer, StreamError> {
183		let size = self.read_u32().await? as usize;
184		read_buf_async(self.reader, size).await
185	}
186
187	pub async fn read_string(&mut self) -> Result<String, StreamError> {
188		let size = self.read_u32().await? as usize;
189		let buf = read_buf_async(self.reader, size).await?;
190
191		String::from_utf8(buf.to_vec()).map_err(|_| StreamError::InvalidData)
192	}
193}
paper_utils/stream/reader.rs

paper_utils/stream/
reader.rs
