MeexReay/rust_mc_proto
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

varint alias functions

Browse source
This commit is contained in:
MeexReay 2025-05-01 14:36:30 +03:00
parent 4b7af49ad0
commit a91d262271
5 changed files with 346 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

206
src/data/reader.rs
View file

@ -1,5 +1,5 @@
use crate::ProtocolError;
use std::io::Read;
use std::{io::Read, usize};
use uuid::Uuid;
/// Packet data reader trait
@ -13,7 +13,7 @@ pub trait DataReader {
}
/// Read String
fn read_string(&mut self) -> Result<String, ProtocolError> {
let size = self.read_varint()? as usize;
let size = self.read_usize_varint()?;
match String::from_utf8(self.read_bytes(size)?) {
Ok(i) => Ok(i),
Err(_) => Err(ProtocolError::StringParseError),
@ -70,7 +70,201 @@ pub trait DataReader {
.map(|o| Uuid::from_bytes(o))
}
/// Read VarInt as i32 with size in bytes (varint, size)
/// Read VarInt as u8
fn read_u8_varint(&mut self) -> Result<u8, ProtocolError> {
TryInto::<u8>::try_into(self.read_varint()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as u16
fn read_u16_varint(&mut self) -> Result<u16, ProtocolError> {
TryInto::<u16>::try_into(self.read_varint()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as u32
///
/// Returns error if the value is greater than i32::MAX
fn read_u32_varint(&mut self) -> Result<u32, ProtocolError> {
let val = self.read_varint()?;
if val < 0 { return Err(ProtocolError::VarIntError); }
TryInto::<u32>::try_into(val).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as usize
fn read_usize_varint(&mut self) -> Result<usize, ProtocolError> {
Ok(TryInto::<usize>::try_into(self.read_varint()?).map_err(|_| ProtocolError::VarIntError)?)
}
/// Read VarInt as i8
fn read_i8_varint(&mut self) -> Result<i8, ProtocolError> {
TryInto::<i8>::try_into(self.read_varint()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as i16
fn read_i16_varint(&mut self,) -> Result<i16, ProtocolError> {
TryInto::<i16>::try_into(self.read_varint()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarInt as i32
///
/// *Use [read_varint](DataReader::read_varint) instead*
fn read_i32_varint(&mut self) -> Result<i32, ProtocolError> {
self.read_varint()
}
/// Read VarInt as isize
fn read_isize_varint(&mut self) -> Result<isize, ProtocolError> {
Ok(TryInto::<isize>::try_into(self.read_varint()?).map_err(|_| ProtocolError::VarIntError)?)
}
/// Read VarLong as u8
fn read_u8_varlong(&mut self) -> Result<u8, ProtocolError> {
TryInto::<u8>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as u16
fn read_u16_varlong(&mut self) -> Result<u16, ProtocolError> {
TryInto::<u16>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as u32
fn read_u32_varlong(&mut self) -> Result<u32, ProtocolError> {
TryInto::<u32>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as usize
///
/// Returns error if the value is greater than i64::MAX
fn read_usize_varlong(&mut self) -> Result<usize, ProtocolError> {
let val = TryInto::<usize>::try_into(self.read_varlong()?).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
fn read_u64_varlong(&mut self) -> Result<u64, ProtocolError> {
let val = self.read_varlong()?;
if val < 0 { return Err(ProtocolError::VarIntError); }
TryInto::<u64>::try_into(val).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as i8
fn read_i8_varlong(&mut self) -> Result<i8, ProtocolError> {
TryInto::<i8>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as i16
fn read_i16_varlong(&mut self) -> Result<i16, ProtocolError> {
TryInto::<i16>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as i32
fn read_i32_varlong(&mut self) -> Result<i32, ProtocolError> {
TryInto::<i32>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)
}
/// Read VarLong as isize
fn read_isize_varlong(&mut self) -> Result<isize, ProtocolError> {
Ok(TryInto::<isize>::try_into(self.read_varlong()?).map_err(|_| ProtocolError::VarIntError)?)
}
/// Read VarLong as i64
///
/// *Use [read_varlong](DataReader::read_varlong) instead*
fn read_i64_varlong(&mut self) -> Result<i64, ProtocolError> {
self.read_varlong()
}
/// Read VarInt as u8 with size in bytes (value, size)
fn read_u8_varint_size(&mut self) -> Result<(u8, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
Ok((TryInto::<u8>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarInt as u16 with size in bytes (value, size)
fn read_u16_varint_size(&mut self) -> Result<(u16, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
Ok((TryInto::<u16>::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
fn read_u32_varint_size(&mut self) -> Result<(u32, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
if val < 0 { return Err(ProtocolError::VarIntError); }
Ok((TryInto::<u32>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarInt as usize with size in bytes (value, size)
fn read_usize_varint_size(&mut self) -> Result<(usize, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
Ok((TryInto::<usize>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarInt as i8 with size in bytes (value, size)
fn read_i8_varint_size(&mut self) -> Result<(i8, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
Ok((TryInto::<i8>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarInt as i16 with size in bytes (value, size)
fn read_i16_varint_size(&mut self,) -> Result<(i16, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
Ok((TryInto::<i16>::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*
fn read_i32_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> {
self.read_varint_size()
}
/// Read VarInt as isize with size in bytes (value, size)
fn read_isize_varint_size(&mut self) -> Result<(isize, usize), ProtocolError> {
let (val, size) = self.read_varint_size()?;
Ok((TryInto::<isize>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as u8 with size in bytes (value, size)
fn read_u8_varlong_size(&mut self) -> Result<(u8, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<u8>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as u16 with size in bytes (value, size)
fn read_u16_varlong_size(&mut self) -> Result<(u16, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<u16>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as u32 with size in bytes (value, size)
fn read_u32_varlong_size(&mut self) -> Result<(u32, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<u32>::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
fn read_usize_varlong_size(&mut self) -> Result<(usize, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
let val = TryInto::<usize>::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
fn read_u64_varlong_size(&mut self) -> Result<(u64, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
if val < 0 { return Err(ProtocolError::VarIntError); }
Ok((TryInto::<u64>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as i8 with size in bytes (value, size)
fn read_i8_varlong_size(&mut self) -> Result<(i8, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<i8>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as i16 with size in bytes (value, size)
fn read_i16_varlong_size(&mut self) -> Result<(i16, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<i16>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as i32 with size in bytes (value, size)
fn read_i32_varlong_size(&mut self) -> Result<(i32, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<i32>::try_into(val).map_err(|_| ProtocolError::VarIntError)?, size))
}
/// Read VarLong as isize with size in bytes (value, size)
fn read_isize_varlong_size(&mut self) -> Result<(isize, usize), ProtocolError> {
let (val, size) = self.read_varlong_size()?;
Ok((TryInto::<isize>::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*
fn read_i64_varlong_size(&mut self) -> Result<(i64, usize), ProtocolError> {
self.read_varlong_size()
}
/// Read VarInt as i32 with size in bytes (value, size)
fn read_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> {
let mut value: u32 = 0;
let mut position: u32 = 0;
@ -78,7 +272,7 @@ pub trait DataReader {
loop {
let byte = self.read_byte()?;
value |= ((byte & 0x7F) as u32) << position;
value |= TryInto::<u32>::try_into(byte & 0x7F).map_err(|_| ProtocolError::VarIntError)? << position;
size += 1;
@ -91,7 +285,7 @@ pub trait DataReader {
Ok((value as i32, size))
}
/// Read VarLong as i64 with size in bytes (varint, size)
/// Read VarLong as i64 with size in bytes (value, size)
fn read_varlong_size(&mut self) -> Result<(i64, usize), ProtocolError> {
let mut value: u64 = 0;
let mut position: u32 = 0;
@ -99,7 +293,7 @@ pub trait DataReader {
loop {
let byte = self.read_byte()?;
value |= ((byte & 0x7F) as u64) << position;
value |= TryInto::<u64>::try_into(byte & 0x7F).map_err(|_| ProtocolError::VarIntError)? << position;
size += 1;

103
src/data/writer.rs
View file

@ -13,9 +13,8 @@ pub trait DataWriter {
}
/// Write String
fn write_string(&mut self, val: &str) -> Result<(), ProtocolError> {
let bytes = val.as_bytes();
self.write_varint(bytes.len() as i32)?;
self.write_bytes(bytes)
self.write_usize_varint(val.len())?;
self.write_bytes(val.as_bytes())
}
/// Write UUID
fn write_uuid(&mut self, val: &Uuid) -> Result<(), ProtocolError> {
@ -54,17 +53,107 @@ pub trait DataWriter {
self.write_bytes(&val.to_be_bytes())
}
/// Write VarInt as u8
fn write_u8_varint(&mut self, val: u8) -> Result<(), ProtocolError> {
self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarInt as u16
fn write_u16_varint(&mut self, val: u16) -> Result<(), ProtocolError> {
self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarInt as usize
///
/// Returns error if the value is greater than i32::MAX
fn write_usize_varint(&mut self, val: usize) -> Result<(), ProtocolError> {
let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?;
if val < 0 { return Err(ProtocolError::VarIntError); }
self.write_varint(val)
}
/// Write VarInt as u32
///
/// Returns error if the value is greater than i32::MAX
fn write_u32_varint(&mut self, val: u32) -> Result<(), ProtocolError> {
let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?;
if val < 0 { return Err(ProtocolError::VarIntError); }
self.write_varint(val)
}
/// Write VarInt as i8
fn write_i8_varint(&mut self, val: i8) -> Result<(), ProtocolError> {
self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarInt as i16
fn write_i16_varint(&mut self, val: i16) -> Result<(), ProtocolError> {
self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarInt as isize
fn write_isize_varint(&mut self, val: isize) -> Result<(), ProtocolError> {
self.write_varint(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarInt as i32
///
/// *Use [write_varint](DataWriter::write_varint) instead*
fn write_i32_varint(&mut self, val: i32) -> Result<(), ProtocolError> {
self.write_varint(val)
}
/// Write VarLong as u8
fn write_u8_varlong(&mut self, val: u8) -> Result<(), ProtocolError> {
self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarLong as u16
fn write_u16_varlong(&mut self, val: u16) -> Result<(), ProtocolError> {
self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarLong as u32
fn write_u32_varlong(&mut self, val: u32) -> Result<(), ProtocolError> {
self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarLong as u64
///
/// Returns error if the value is greater than i64::MAX
fn write_u64_varlong(&mut self, val: u64) -> Result<(), ProtocolError> {
let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?;
if val < 0 { return Err(ProtocolError::VarIntError); }
self.write_varlong(val)
}
/// Write VarLong as usize
///
/// Returns error if the value is greater than i64::MAX
fn write_usize_varlong(&mut self, val: u64) -> Result<(), ProtocolError> {
let val = val.try_into().map_err(|_| ProtocolError::VarIntError)?;
if val < 0 { return Err(ProtocolError::VarIntError); }
self.write_varlong(val)
}
/// Write VarLong as i8
fn write_i8_varlong(&mut self, val: i8) -> Result<(), ProtocolError> {
self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarLong as i16
fn write_i16_varlong(&mut self, val: i16) -> Result<(), ProtocolError> {
self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarLong as i32
fn write_i32_varlong(&mut self, val: i32) -> Result<(), ProtocolError> {
self.write_varlong(val.try_into().map_err(|_| ProtocolError::VarIntError)?)
}
/// Write VarLong as i64
///
/// *Use [write_varlong](DataWriter::write_varlong) instead*
fn write_i64_varlong(&mut self, val: i64) -> Result<(), ProtocolError> {
self.write_varlong(val)
}
/// Write VarInt as i32
fn write_varint(&mut self, val: i32) -> Result<(), ProtocolError> {
let mut value = val as u32;
loop {
if value & !0x7F == 0 {
self.write_byte(value as u8)?;
self.write_byte(TryInto::<u8>::try_into(value).map_err(|_| ProtocolError::VarIntError)?)?;
break;
}
self.write_byte(((value & 0x7F) | 0x80) as u8)?;
self.write_byte(TryInto::<u8>::try_into((value & 0x7F) | 0x80).map_err(|_| ProtocolError::VarIntError)?)?;
value >>= 7;
}
@ -77,11 +166,11 @@ pub trait DataWriter {
loop {
if value & !0x7F == 0 {
self.write_byte(value as u8)?;
self.write_byte(TryInto::<u8>::try_into(value).map_err(|_| ProtocolError::VarIntError)?)?;
break;
}
self.write_byte(((value & 0x7F) | 0x80) as u8)?;
self.write_byte(TryInto::<u8>::try_into((value & 0x7F) | 0x80).map_err(|_| ProtocolError::VarIntError)?)?;
value >>= 7;
}