From a8299d75d1a7b2f89103b26a373dab4105a8133e Mon Sep 17 00:00:00 2001 From: MeexReay Date: Fri, 6 Jun 2025 19:59:32 +0300 Subject: [PATCH] fix warnings --- convert_async.py | 46 ++++++ src/data/reader.rs | 202 +++++++++++------------ src/data/reader.rs.prev | 347 ++++++++++++++++++++++++++++++++++++++++ src/data/writer.rs | 88 +++++----- 4 files changed, 538 insertions(+), 145 deletions(-) create mode 100644 convert_async.py create mode 100644 src/data/reader.rs.prev diff --git a/convert_async.py b/convert_async.py new file mode 100644 index 0000000..a87ac2d --- /dev/null +++ b/convert_async.py @@ -0,0 +1,46 @@ +import sys +import re + +if len(sys.argv) != 2: + print(f"Usage: {sys.argv[0]} ") + sys.exit(1) + +filename = sys.argv[1] + +with open(filename, "r", encoding="utf-8") as f: + content = f.read() + +pattern = re.compile( + r"""async\s+fn\s+ # async fn + (\w+)\s* # имя функции + \(([^)]*)\)\s* # аргументы + ->\s*([^{\n]+)\s* # возвращаемый тип + \{\s*\n # открывающая фигурная скобка + новая строка + (.*?) # тело функции (ленивый захват) + ^\} # закрывающая фигурная скобка на отдельной строке + """, + re.DOTALL | re.MULTILINE | re.VERBOSE, +) + +def replacer(match): + name = match.group(1) + args = match.group(2) + ret = match.group(3).strip() + body = match.group(4) + + # Добавляем 4 пробела в начале каждой строки тела + indented_body = "\n".join(" " + line if line.strip() else "" for line in body.splitlines()) + + return ( + f"fn {name}({args}) -> impl std::future::Future {{\n" + f" async {{\n" + f"{indented_body}\n" + f" }}\n" + f"}}" + ) + +new_content = pattern.sub(replacer, content) + +with open(filename, "w", encoding="utf-8") as f: + f.write(new_content) + diff --git a/src/data/reader.rs b/src/data/reader.rs index c2cc2e3..50eecb7 100644 --- a/src/data/reader.rs +++ b/src/data/reader.rs @@ -76,203 +76,203 @@ pub trait DataReader { } /// Read VarInt as u8 - async fn read_u8_varint(&mut self) -> Result { - TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + fn read_u8_varint(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarInt as u16 - async fn read_u16_varint(&mut self) -> Result { - TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + fn read_u16_varint(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarInt as u32 /// /// Returns error if the value is greater than i32::MAX - async fn read_u32_varint(&mut self) -> Result { - let val = self.read_varint().await?; + fn read_u32_varint(&mut self) -> impl Future> { + async {let val = self.read_varint().await?; if val < 0 { return Err(ProtocolError::VarIntError); } - TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError) + TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)} } /// Read VarInt as usize - async fn read_usize_varint(&mut self) -> Result { - Ok(TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)?) + fn read_usize_varint(&mut self) -> impl Future> { + async {Ok(TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)?)} } /// Read VarInt as i8 - async fn read_i8_varint(&mut self) -> Result { - TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + fn read_i8_varint(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarInt as i16 - async fn read_i16_varint(&mut self,) -> Result { - TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + fn read_i16_varint(&mut self,) -> impl Future> { + async {TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarInt as i32 /// /// *Use [read_varint](DataReader::read_varint) instead* - async fn read_i32_varint(&mut self) -> Result { - self.read_varint().await + fn read_i32_varint(&mut self) -> impl Future> { + async {self.read_varint().await} } /// Read VarInt as isize - async fn read_isize_varint(&mut self) -> Result { - Ok(TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)?) + fn read_isize_varint(&mut self) -> impl Future> { + async {Ok(TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)?)} } /// Read VarLong as u8 - async fn read_u8_varlong(&mut self) -> Result { - TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + fn read_u8_varlong(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as u16 - async fn read_u16_varlong(&mut self) -> Result { - TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + fn read_u16_varlong(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as u32 - async fn read_u32_varlong(&mut self) -> Result { - TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + fn read_u32_varlong(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as usize /// /// Returns error if the value is greater than i64::MAX - async fn read_usize_varlong(&mut self) -> Result { - let val = TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)?; + fn read_usize_varlong(&mut self) -> impl Future> { + async {let val = TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)?; if val as u64 > i64::MAX as u64 { return Err(ProtocolError::VarIntError); } - Ok(val) + Ok(val) } } /// Read VarLong as u64 /// /// Returns error if the value is greater than i64::MAX - async fn read_u64_varlong(&mut self) -> Result { - let val = self.read_varlong().await?; + fn read_u64_varlong(&mut self) -> impl Future> { + async {let val = self.read_varlong().await?; if val < 0 { return Err(ProtocolError::VarIntError); } - TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError) + TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as i8 - async fn read_i8_varlong(&mut self) -> Result { - TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + fn read_i8_varlong(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as i16 - async fn read_i16_varlong(&mut self) -> Result { - TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + fn read_i16_varlong(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as i32 - async fn read_i32_varlong(&mut self) -> Result { - TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + fn read_i32_varlong(&mut self) -> impl Future> { + async {TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)} } /// Read VarLong as isize - async fn read_isize_varlong(&mut self) -> Result { - Ok(TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)?) + fn read_isize_varlong(&mut self) -> impl Future> { + async {Ok(TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)?)} } /// Read VarLong as i64 /// /// *Use [read_varlong](DataReader::read_varlong) instead* - async fn read_i64_varlong(&mut self) -> Result { - self.read_varlong().await + fn read_i64_varlong(&mut self) -> impl Future> { + async {self.read_varlong().await} } /// Read VarInt as u8 with size in bytes (value, size) - async fn read_u8_varint_size(&mut self) -> Result<(u8, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_u8_varint_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarInt as u16 with size in bytes (value, size) - async fn read_u16_varint_size(&mut self) -> Result<(u16, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_u16_varint_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarInt as u32 with size in bytes (value, size) /// /// Returns error if the value is greater than i32::MAX - async fn read_u32_varint_size(&mut self) -> Result<(u32, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; + fn read_u32_varint_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; if val < 0 { return Err(ProtocolError::VarIntError); } - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarInt as usize with size in bytes (value, size) - async fn read_usize_varint_size(&mut self) -> Result<(usize, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_usize_varint_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarInt as i8 with size in bytes (value, size) - async fn read_i8_varint_size(&mut self) -> Result<(i8, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_i8_varint_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarInt as i16 with size in bytes (value, size) - async fn read_i16_varint_size(&mut self,) -> Result<(i16, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_i16_varint_size(&mut self,) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarInt as i32 with size in bytes (value, size) /// /// *Use [read_varint_size](DataReader::read_varint_size) instead* - async fn read_i32_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> { - self.read_varint_size().await + fn read_i32_varint_size(&mut self) -> impl Future> { + async {self.read_varint_size().await} } /// Read VarInt as isize with size in bytes (value, size) - async fn read_isize_varint_size(&mut self) -> Result<(isize, usize), ProtocolError> { - let (val, size) = self.read_varint_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_isize_varint_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as u8 with size in bytes (value, size) - async fn read_u8_varlong_size(&mut self) -> Result<(u8, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_u8_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as u16 with size in bytes (value, size) - async fn read_u16_varlong_size(&mut self) -> Result<(u16, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_u16_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as u32 with size in bytes (value, size) - async fn read_u32_varlong_size(&mut self) -> Result<(u32, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_u32_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as usize with size in bytes (value, size) /// /// Returns error if the value is greater than i64::MAX - async fn read_usize_varlong_size(&mut self) -> Result<(usize, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; + fn read_usize_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; let val = TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?; if val as u64 > i64::MAX as u64 { return Err(ProtocolError::VarIntError); } - Ok((val, size)) + Ok((val, size))} } /// Read VarLong as u64 with size in bytes (value, size) /// /// Returns error if the value is greater than i64::MAX - async fn read_u64_varlong_size(&mut self) -> Result<(u64, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; + fn read_u64_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; if val < 0 { return Err(ProtocolError::VarIntError); } - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as i8 with size in bytes (value, size) - async fn read_i8_varlong_size(&mut self) -> Result<(i8, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_i8_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as i16 with size in bytes (value, size) - async fn read_i16_varlong_size(&mut self) -> Result<(i16, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_i16_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as i32 with size in bytes (value, size) - async fn read_i32_varlong_size(&mut self) -> Result<(i32, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_i32_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as isize with size in bytes (value, size) - async fn read_isize_varlong_size(&mut self) -> Result<(isize, usize), ProtocolError> { - let (val, size) = self.read_varlong_size().await?; - Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + fn read_isize_varlong_size(&mut self) -> impl Future> { + async {let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))} } /// Read VarLong as i64 with size in bytes (value, size) /// /// *Use [read_varlong_size](DataReader::read_varlong_size) instead* - async fn read_i64_varlong_size(&mut self) -> Result<(i64, usize), ProtocolError> { - self.read_varlong_size().await + fn read_i64_varlong_size(&mut self) -> impl Future> { + async {self.read_varlong_size().await} } /// Read VarInt as i32 with size in bytes (value, size) - async fn read_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> { - let mut value: u32 = 0; + fn read_varint_size(&mut self) -> impl Future> { + async {let mut value: u32 = 0; let mut position: u32 = 0; let mut size = 0; @@ -289,11 +289,11 @@ pub trait DataReader { position += 7; } - Ok((value as i32, size)) + Ok((value as i32, size))} } /// Read VarLong as i64 with size in bytes (value, size) - async fn read_varlong_size(&mut self) -> Result<(i64, usize), ProtocolError> { - let mut value: u64 = 0; + fn read_varlong_size(&mut self) -> impl Future> { + async {let mut value: u64 = 0; let mut position: u32 = 0; let mut size = 0; @@ -310,16 +310,16 @@ pub trait DataReader { position += 7; } - Ok((value as i64, size)) + Ok((value as i64, size))} } /// Read VarInt as i32 - async fn read_varint(&mut self) -> Result { - self.read_varint_size().await.map(|o| o.0) + fn read_varint(&mut self) -> impl Future> { + async {self.read_varint_size().await.map(|o| o.0)} } /// Read VarLong as i64 - async fn read_varlong(&mut self) -> Result { - self.read_varlong_size().await.map(|o| o.0) + fn read_varlong(&mut self) -> impl Future> { + async {self.read_varlong_size().await.map(|o| o.0)} } } diff --git a/src/data/reader.rs.prev b/src/data/reader.rs.prev new file mode 100644 index 0000000..c2cc2e3 --- /dev/null +++ b/src/data/reader.rs.prev @@ -0,0 +1,347 @@ +use crate::ProtocolError; +use tokio::io::AsyncReadExt; +use uuid::Uuid; + +/// Packet data reader trait +pub trait DataReader { + /// Read bytes + fn read_bytes(&mut self, size: usize) -> impl Future, ProtocolError>>; + + /// Read byte + fn read_byte(&mut self) -> impl Future> { + async {Ok(self.read_bytes(1).await?[0])} + } + /// Read String + fn read_string(&mut self) -> impl Future> { + async { + let size = self.read_usize_varint().await?; + match String::from_utf8(self.read_bytes(size).await?) { + Ok(i) => Ok(i), + Err(_) => Err(ProtocolError::StringParseError), + } + } + } + /// Read Unsigned Short as u16 + fn read_unsigned_short(&mut self) -> impl Future> { + async {match self.read_bytes(2).await?.try_into() { + Ok(i) => Ok(u16::from_be_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + /// Read Boolean + fn read_boolean(&mut self) -> impl Future> { + async {Ok(self.read_byte().await? == 0x01)} + } + /// Read Short as i16 + fn read_short(&mut self) -> impl Future> { + async {match self.read_bytes(2).await?.try_into() { + Ok(i) => Ok(i16::from_be_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + /// Read Long as i64 + fn read_long(&mut self) -> impl Future> { + async {match self.read_bytes(8).await?.try_into() { + Ok(i) => Ok(i64::from_be_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + /// Read Float as f32 + fn read_float(&mut self) -> impl Future> { + async {match self.read_bytes(4).await?.try_into() { + Ok(i) => Ok(f32::from_be_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + /// Read Double as f64 + fn read_double(&mut self) -> impl Future> { + async {match self.read_bytes(8).await?.try_into() { + Ok(i) => Ok(f64::from_be_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + /// Read Int as i32 + fn read_int(&mut self) -> impl Future> { + async {match self.read_bytes(4).await?.try_into() { + Ok(i) => Ok(i32::from_be_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + /// Read UUID + fn read_uuid(&mut self) -> impl Future> { + async {match self.read_bytes(16).await?.try_into() { + Ok(i) => Ok(Uuid::from_bytes(i)), + Err(_) => Err(ProtocolError::ReadError), + }} + } + + /// Read VarInt as u8 + async fn read_u8_varint(&mut self) -> Result { + TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarInt as u16 + async fn read_u16_varint(&mut self) -> Result { + TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + } + + /// Read VarInt as u32 + /// + /// Returns error if the value is greater than i32::MAX + async fn read_u32_varint(&mut self) -> Result { + let val = self.read_varint().await?; + if val < 0 { return Err(ProtocolError::VarIntError); } + TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarInt as usize + async fn read_usize_varint(&mut self) -> Result { + Ok(TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)?) + } + /// Read VarInt as i8 + async fn read_i8_varint(&mut self) -> Result { + TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarInt as i16 + async fn read_i16_varint(&mut self,) -> Result { + TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarInt as i32 + /// + /// *Use [read_varint](DataReader::read_varint) instead* + async fn read_i32_varint(&mut self) -> Result { + self.read_varint().await + } + /// Read VarInt as isize + async fn read_isize_varint(&mut self) -> Result { + Ok(TryInto::::try_into(self.read_varint().await?).map_err(|_| ProtocolError::VarIntError)?) + } + + /// Read VarLong as u8 + async fn read_u8_varlong(&mut self) -> Result { + TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as u16 + async fn read_u16_varlong(&mut self) -> Result { + TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as u32 + async fn read_u32_varlong(&mut self) -> Result { + TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as usize + /// + /// Returns error if the value is greater than i64::MAX + async fn read_usize_varlong(&mut self) -> Result { + let val = TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)?; + if val as u64 > i64::MAX as u64 { return Err(ProtocolError::VarIntError); } + Ok(val) + } + /// Read VarLong as u64 + /// + /// Returns error if the value is greater than i64::MAX + async fn read_u64_varlong(&mut self) -> Result { + let val = self.read_varlong().await?; + if val < 0 { return Err(ProtocolError::VarIntError); } + TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as i8 + async fn read_i8_varlong(&mut self) -> Result { + TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as i16 + async fn read_i16_varlong(&mut self) -> Result { + TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as i32 + async fn read_i32_varlong(&mut self) -> Result { + TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError) + } + /// Read VarLong as isize + async fn read_isize_varlong(&mut self) -> Result { + Ok(TryInto::::try_into(self.read_varlong().await?).map_err(|_| ProtocolError::VarIntError)?) + } + /// Read VarLong as i64 + /// + /// *Use [read_varlong](DataReader::read_varlong) instead* + async fn read_i64_varlong(&mut self) -> Result { + self.read_varlong().await + } + + /// Read VarInt as u8 with size in bytes (value, size) + async fn read_u8_varint_size(&mut self) -> Result<(u8, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarInt as u16 with size in bytes (value, size) + async fn read_u16_varint_size(&mut self) -> Result<(u16, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarInt as u32 with size in bytes (value, size) + /// + /// Returns error if the value is greater than i32::MAX + async fn read_u32_varint_size(&mut self) -> Result<(u32, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + if val < 0 { return Err(ProtocolError::VarIntError); } + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarInt as usize with size in bytes (value, size) + async fn read_usize_varint_size(&mut self) -> Result<(usize, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarInt as i8 with size in bytes (value, size) + async fn read_i8_varint_size(&mut self) -> Result<(i8, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarInt as i16 with size in bytes (value, size) + async fn read_i16_varint_size(&mut self,) -> Result<(i16, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarInt as i32 with size in bytes (value, size) + /// + /// *Use [read_varint_size](DataReader::read_varint_size) instead* + async fn read_i32_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> { + self.read_varint_size().await + } + /// Read VarInt as isize with size in bytes (value, size) + async fn read_isize_varint_size(&mut self) -> Result<(isize, usize), ProtocolError> { + let (val, size) = self.read_varint_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + + /// Read VarLong as u8 with size in bytes (value, size) + async fn read_u8_varlong_size(&mut self) -> Result<(u8, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as u16 with size in bytes (value, size) + async fn read_u16_varlong_size(&mut self) -> Result<(u16, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as u32 with size in bytes (value, size) + async fn read_u32_varlong_size(&mut self) -> Result<(u32, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as usize with size in bytes (value, size) + /// + /// Returns error if the value is greater than i64::MAX + async fn read_usize_varlong_size(&mut self) -> Result<(usize, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + let val = TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?; + if val as u64 > i64::MAX as u64 { return Err(ProtocolError::VarIntError); } + Ok((val, size)) + } + /// Read VarLong as u64 with size in bytes (value, size) + /// + /// Returns error if the value is greater than i64::MAX + async fn read_u64_varlong_size(&mut self) -> Result<(u64, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + if val < 0 { return Err(ProtocolError::VarIntError); } + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as i8 with size in bytes (value, size) + async fn read_i8_varlong_size(&mut self) -> Result<(i8, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as i16 with size in bytes (value, size) + async fn read_i16_varlong_size(&mut self) -> Result<(i16, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as i32 with size in bytes (value, size) + async fn read_i32_varlong_size(&mut self) -> Result<(i32, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as isize with size in bytes (value, size) + async fn read_isize_varlong_size(&mut self) -> Result<(isize, usize), ProtocolError> { + let (val, size) = self.read_varlong_size().await?; + Ok((TryInto::::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size)) + } + /// Read VarLong as i64 with size in bytes (value, size) + /// + /// *Use [read_varlong_size](DataReader::read_varlong_size) instead* + async fn read_i64_varlong_size(&mut self) -> Result<(i64, usize), ProtocolError> { + self.read_varlong_size().await + } + + /// Read VarInt as i32 with size in bytes (value, size) + async fn read_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> { + let mut value: u32 = 0; + let mut position: u32 = 0; + let mut size = 0; + + loop { + let byte = self.read_byte().await?; + value |= TryInto::::try_into(byte & 0x7F).map_err(|_| ProtocolError::VarIntError)? << position; + + size += 1; + + if (byte & 0x80) == 0 { + break; + } + + position += 7; + } + + Ok((value as i32, size)) + } + /// Read VarLong as i64 with size in bytes (value, size) + async fn read_varlong_size(&mut self) -> Result<(i64, usize), ProtocolError> { + let mut value: u64 = 0; + let mut position: u32 = 0; + let mut size = 0; + + loop { + let byte = self.read_byte().await?; + value |= TryInto::::try_into(byte & 0x7F).map_err(|_| ProtocolError::VarIntError)? << position; + + size += 1; + + if (byte & 0x80) == 0 { + break; + } + + position += 7; + } + + Ok((value as i64, size)) + } + + /// Read VarInt as i32 + async fn read_varint(&mut self) -> Result { + self.read_varint_size().await.map(|o| o.0) + } + /// Read VarLong as i64 + async fn read_varlong(&mut self) -> Result { + self.read_varlong_size().await.map(|o| o.0) + } +} + +impl DataReader for R { + async fn read_bytes(&mut self, size: usize) -> Result, ProtocolError> { + let mut data = Vec::new(); + + while data.len() < size { + let mut buf = vec![0; size - data.len()]; + + let n = self.read(&mut buf).await + .map_err(|_| ProtocolError::ReadError)?; + + if n == 0 { + return Err(ProtocolError::ConnectionClosedError); + } + + buf.truncate(n); + + data.append(&mut buf); + } + + Ok(data) + } +} diff --git a/src/data/writer.rs b/src/data/writer.rs index b2ac819..3c96fad 100644 --- a/src/data/writer.rs +++ b/src/data/writer.rs @@ -53,98 +53,98 @@ pub trait DataWriter { } /// Write VarInt as u8 - async fn write_u8_varint(&mut self, val: u8) -> Result<(), ProtocolError> { - self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_u8_varint(&mut self, val: u8) -> impl Future> { + async move { self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarInt as u16 - async fn write_u16_varint(&mut self, val: u16) -> Result<(), ProtocolError> { - self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_u16_varint(&mut self, val: u16) -> impl Future> { + async move { self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarInt as usize /// /// Returns error if the value is greater than i32::MAX - async fn write_usize_varint(&mut self, val: usize) -> Result<(), ProtocolError> { - let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; + fn write_usize_varint(&mut self, val: usize) -> impl Future> { + async move { let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; if val < 0 { return Err(ProtocolError::VarIntError); } - self.write_varint(val).await + self.write_varint(val).await } } /// Write VarInt as u32 /// /// Returns error if the value is greater than i32::MAX - async fn write_u32_varint(&mut self, val: u32) -> Result<(), ProtocolError> { - let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; + fn write_u32_varint(&mut self, val: u32) -> impl Future> { + async move { let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; if val < 0 { return Err(ProtocolError::VarIntError); } - self.write_varint(val).await + self.write_varint(val).await } } /// Write VarInt as i8 - async fn write_i8_varint(&mut self, val: i8) -> Result<(), ProtocolError> { - self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_i8_varint(&mut self, val: i8) -> impl Future> { + async move { self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarInt as i16 - async fn write_i16_varint(&mut self, val: i16) -> Result<(), ProtocolError> { - self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_i16_varint(&mut self, val: i16) -> impl Future> { + async move { self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarInt as isize - async fn write_isize_varint(&mut self, val: isize) -> Result<(), ProtocolError> { - self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_isize_varint(&mut self, val: isize) -> impl Future> { + async move { self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarInt as i32 /// /// *Use [write_varint](DataWriter::write_varint) instead* - async fn write_i32_varint(&mut self, val: i32) -> Result<(), ProtocolError> { - self.write_varint(val).await + fn write_i32_varint(&mut self, val: i32) -> impl Future> { + async move { self.write_varint(val).await } } /// Write VarLong as u8 - async fn write_u8_varlong(&mut self, val: u8) -> Result<(), ProtocolError> { - self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_u8_varlong(&mut self, val: u8) -> impl Future> { + async move { self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarLong as u16 - async fn write_u16_varlong(&mut self, val: u16) -> Result<(), ProtocolError> { - self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_u16_varlong(&mut self, val: u16) -> impl Future> { + async move { self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarLong as u32 - async fn write_u32_varlong(&mut self, val: u32) -> Result<(), ProtocolError> { - self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_u32_varlong(&mut self, val: u32) -> impl Future> { + async move { self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarLong as u64 /// /// Returns error if the value is greater than i64::MAX - async fn write_u64_varlong(&mut self, val: u64) -> Result<(), ProtocolError> { - let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; + fn write_u64_varlong(&mut self, val: u64) -> impl Future> { + async move { let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; if val < 0 { return Err(ProtocolError::VarIntError); } - self.write_varlong(val).await + self.write_varlong(val).await } } /// Write VarLong as usize /// /// Returns error if the value is greater than i64::MAX - async fn write_usize_varlong(&mut self, val: u64) -> Result<(), ProtocolError> { - let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; + fn write_usize_varlong(&mut self, val: u64) -> impl Future> { + async move { let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?; if val < 0 { return Err(ProtocolError::VarIntError); } - self.write_varlong(val).await + self.write_varlong(val).await } } /// Write VarLong as i8 - async fn write_i8_varlong(&mut self, val: i8) -> Result<(), ProtocolError> { - self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_i8_varlong(&mut self, val: i8) -> impl Future> { + async move { self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarLong as i16 - async fn write_i16_varlong(&mut self, val: i16) -> Result<(), ProtocolError> { - self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_i16_varlong(&mut self, val: i16) -> impl Future> { + async move { self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarLong as i32 - async fn write_i32_varlong(&mut self, val: i32) -> Result<(), ProtocolError> { - self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await + fn write_i32_varlong(&mut self, val: i32) -> impl Future> { + async move { self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?).await } } /// Write VarLong as i64 /// /// *Use [write_varlong](DataWriter::write_varlong) instead* - async fn write_i64_varlong(&mut self, val: i64) -> Result<(), ProtocolError> { - self.write_varlong(val).await + fn write_i64_varlong(&mut self, val: i64) -> impl Future> { + async move { self.write_varlong(val).await } } /// Write VarInt as i32 - async fn write_varint(&mut self, val: i32) -> Result<(), ProtocolError> { - let mut value = val as u32; + fn write_varint(&mut self, val: i32) -> impl Future> { + async move { let mut value = val as u32; loop { if value & !0x7F == 0 { @@ -157,11 +157,11 @@ pub trait DataWriter { value >>= 7; } - Ok(()) + Ok(()) } } /// Write VarLong as i64 - async fn write_varlong(&mut self, val: i64) -> Result<(), ProtocolError> { - let mut value = val as u64; + fn write_varlong(&mut self, val: i64) -> impl Future> { + async move { let mut value = val as u64; loop { if value & !0x7F == 0 { @@ -174,7 +174,7 @@ pub trait DataWriter { value >>= 7; } - Ok(()) + Ok(()) } } }