From 08958c2278b15ebeac8a964f392ebb792e479b61 Mon Sep 17 00:00:00 2001 From: mat <27899617+mat-1@users.noreply.github.com> Date: Wed, 27 Nov 2024 19:31:40 -0600 Subject: Refactor azalea-protocol (#190) * start updating to 1.21.4 * fix block codegen and stop using block data from burger * rename packet related modules and structs to be simpler * ItemSlot -> ItemStack for more consistency with mojmap * .get() -> .into_packet() * simplify declare_state_packets by removing packet ids * rename read_from and write_into to azalea_read and azalea_write * rename McBufReadable and McBufWritable to AzaleaRead and AzaleaWrite * McBuf -> AzBuf * remove most uses of into_variant * update codegen and use resourcelocation names for packets * implement #[limit(i)] attribute for AzBuf derive macro * fixes for 1.21.4 * fix examples * update some physics code and fix ChatType * remove unused imports in codegen * re-add some things to migrate.py and update +mc version numbers automatically * downgrade to 1.21.3 lol --- azalea-buf/src/lib.rs | 97 +++++++++--------- azalea-buf/src/read.rs | 195 ++++++++++++++++++----------------- azalea-buf/src/serializable_uuid.rs | 30 +++--- azalea-buf/src/write.rs | 196 ++++++++++++++++++------------------ 4 files changed, 267 insertions(+), 251 deletions(-) (limited to 'azalea-buf/src') diff --git a/azalea-buf/src/lib.rs b/azalea-buf/src/lib.rs index e1d1281f..ef3bd3a8 100755 --- a/azalea-buf/src/lib.rs +++ b/azalea-buf/src/lib.rs @@ -10,9 +10,9 @@ mod write; pub use azalea_buf_macros::*; pub use definitions::*; -pub use read::{BufReadError, McBufReadable, McBufVarReadable}; +pub use read::{AzaleaRead, AzaleaReadLimited, AzaleaReadVar, BufReadError}; pub use serializable_uuid::*; -pub use write::{McBufVarWritable, McBufWritable}; +pub use write::{AzaleaWrite, AzaleaWriteVar}; // const DEFAULT_NBT_QUOTA: u32 = 2097152; const MAX_STRING_LENGTH: u16 = 32767; @@ -27,110 +27,113 @@ mod tests { #[test] fn test_write_varint() { let mut buf = Vec::new(); - 0.var_write_into(&mut buf).unwrap(); + 0.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![0]); let mut buf = Vec::new(); - 1.var_write_into(&mut buf).unwrap(); + 1.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![1]); let mut buf = Vec::new(); - 2.var_write_into(&mut buf).unwrap(); + 2.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![2]); let mut buf = Vec::new(); - 127.var_write_into(&mut buf).unwrap(); + 127.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![127]); let mut buf = Vec::new(); - 128.var_write_into(&mut buf).unwrap(); + 128.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![128, 1]); let mut buf = Vec::new(); - 255.var_write_into(&mut buf).unwrap(); + 255.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![255, 1]); let mut buf = Vec::new(); - 25565.var_write_into(&mut buf).unwrap(); + 25565.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![221, 199, 1]); let mut buf = Vec::new(); - 2097151.var_write_into(&mut buf).unwrap(); + 2097151.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![255, 255, 127]); let mut buf = Vec::new(); - 2147483647.var_write_into(&mut buf).unwrap(); + 2147483647.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![255, 255, 255, 255, 7]); let mut buf = Vec::new(); - (-1).var_write_into(&mut buf).unwrap(); + (-1).azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![255, 255, 255, 255, 15]); let mut buf = Vec::new(); - (-2147483648).var_write_into(&mut buf).unwrap(); + (-2147483648).azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![128, 128, 128, 128, 8]); } #[test] fn test_read_varint() { // let buf = &mut &vec![0][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 0); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 0); let buf = vec![0]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 0); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 0); // let buf = &mut &vec![1][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 1); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 1); let buf = vec![1]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 1); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 1); // let buf = &mut &vec![2][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 2); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 2); let buf = vec![2]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 2); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 2); // let buf = &mut &vec![127][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 127); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 127); let buf = vec![127]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 127); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 127); // let buf = &mut &vec![128, 1][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 128); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 128); let buf = vec![128, 1]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 128); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 128); // let buf = &mut &vec![255, 1][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 255); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 255); let buf = vec![255, 1]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 255); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 255); // let buf = &mut &vec![221, 199, 1][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 25565); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 25565); let buf = vec![221, 199, 1]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 25565); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 25565); // let buf = &mut &vec![255, 255, 127][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 2097151); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 2097151); let buf = vec![255, 255, 127]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 2097151); + assert_eq!( + i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), + 2097151 + ); // let buf = &mut &vec![255, 255, 255, 255, 7][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), 2147483647); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), 2147483647); let buf = vec![255, 255, 255, 255, 7]; assert_eq!( - i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), + i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 2147483647 ); // let buf = &mut &vec![255, 255, 255, 255, 15][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), -1); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), -1); let buf = vec![255, 255, 255, 255, 15]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), -1); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), -1); // let buf = &mut &vec![128, 128, 128, 128, 8][..]; - // assert_eq!(i32::var_read_from(buf).unwrap(), -2147483648); + // assert_eq!(i32::azalea_read_var(buf).unwrap(), -2147483648); let buf = vec![128, 128, 128, 128, 8]; assert_eq!( - i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), + i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), -2147483648 ); } @@ -138,21 +141,21 @@ mod tests { #[test] fn test_read_varint_longer() { let buf = vec![138, 56, 0, 135, 56, 123]; - assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 7178); + assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 7178); } #[test] fn test_write_varlong() { let mut buf = Vec::new(); - 0u64.var_write_into(&mut buf).unwrap(); + 0u64.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![0]); let mut buf = Vec::new(); - 1u64.var_write_into(&mut buf).unwrap(); + 1u64.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![1]); let mut buf = Vec::new(); - 9223372036854775807u64.var_write_into(&mut buf).unwrap(); + 9223372036854775807u64.azalea_write_var(&mut buf).unwrap(); assert_eq!(buf, vec![255, 255, 255, 255, 255, 255, 255, 255, 127]); } @@ -161,20 +164,20 @@ mod tests { let original_vec = vec!["a".to_string(), "bc".to_string(), "def".to_string()]; let mut buf = Vec::new(); - original_vec.write_into(&mut buf).unwrap(); + original_vec.azalea_write(&mut buf).unwrap(); dbg!(&buf); - let result = Vec::::read_from(&mut Cursor::new(&buf)).unwrap(); + let result = Vec::::azalea_read(&mut Cursor::new(&buf)).unwrap(); assert_eq!(result, original_vec); } #[test] fn test_int_id_list() { let mut buf = Vec::new(); - vec![1, 2, 3].var_write_into(&mut buf).unwrap(); + vec![1, 2, 3].azalea_write_var(&mut buf).unwrap(); - let result = Vec::::var_read_from(&mut Cursor::new(&buf)).unwrap(); + let result = Vec::::azalea_read_var(&mut Cursor::new(&buf)).unwrap(); assert_eq!(result, vec![1, 2, 3]); } @@ -186,9 +189,9 @@ mod tests { ("def".to_string(), 456), ]); let mut buf = Vec::new(); - original_map.var_write_into(&mut buf).unwrap(); + original_map.azalea_write_var(&mut buf).unwrap(); - let result = HashMap::::var_read_from(&mut Cursor::new(&buf)).unwrap(); + let result = HashMap::::azalea_read_var(&mut Cursor::new(&buf)).unwrap(); assert_eq!(result, original_map); } @@ -196,8 +199,8 @@ mod tests { #[test] fn test_long() { let mut buf: Vec = Vec::new(); - 123456u64.write_into(&mut buf).unwrap(); + 123456u64.azalea_write(&mut buf).unwrap(); - assert_eq!(u64::read_from(&mut Cursor::new(&buf)).unwrap(), 123456); + assert_eq!(u64::azalea_read(&mut Cursor::new(&buf)).unwrap(), 123456); } } diff --git a/azalea-buf/src/read.rs b/azalea-buf/src/read.rs index 8e406acb..4353539a 100755 --- a/azalea-buf/src/read.rs +++ b/azalea-buf/src/read.rs @@ -81,7 +81,7 @@ fn read_bytes<'a>(buf: &'a mut Cursor<&[u8]>, length: usize) -> Result<&'a [u8], } fn read_utf_with_len(buf: &mut Cursor<&[u8]>, max_length: u32) -> Result { - let length = u32::var_read_from(buf)?; + let length = u32::azalea_read_var(buf)?; // i don't know why it's multiplied by 4 but it's like that in mojang's code so if length > max_length * 4 { return Err(BufReadError::StringLengthTooLong { @@ -105,30 +105,40 @@ fn read_utf_with_len(buf: &mut Cursor<&[u8]>, max_length: u32) -> Result) -> Result; + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result; } -pub trait McBufVarReadable +pub trait AzaleaReadVar where Self: Sized, { - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result; + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result; } -impl McBufReadable for i32 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +// note that there's no Write equivalent for this trait since we don't really +// care if we're writing over the limit (and maybe we already know that the +// server implementation accepts it) +pub trait AzaleaReadLimited +where + Self: Sized, +{ + fn azalea_read_limited(buf: &mut Cursor<&[u8]>, limit: usize) -> Result; +} + +impl AzaleaRead for i32 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_i32::()?) } } -impl McBufVarReadable for i32 { +impl AzaleaReadVar for i32 { // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L67 /// Read a single varint from the reader and return the value - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { let mut buffer = [0]; let mut ans = 0; for i in 0..5 { @@ -142,9 +152,9 @@ impl McBufVarReadable for i32 { } } -impl McBufVarReadable for i64 { +impl AzaleaReadVar for i64 { // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L54 - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { let mut buffer = [0]; let mut ans = 0; for i in 0..10 { @@ -158,14 +168,14 @@ impl McBufVarReadable for i64 { Ok(ans) } } -impl McBufVarReadable for u64 { - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { - i64::var_read_from(buf).map(|i| i as u64) +impl AzaleaReadVar for u64 { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { + i64::azalea_read_var(buf).map(|i| i as u64) } } -impl McBufReadable for UnsizedByteArray { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for UnsizedByteArray { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { // read to end of the buffer let data = buf.get_ref()[buf.position() as usize..].to_vec(); buf.set_position((buf.position()) + data.len() as u64); @@ -173,111 +183,114 @@ impl McBufReadable for UnsizedByteArray { } } -impl McBufReadable for Vec { - default fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - let length = u32::var_read_from(buf)? as usize; +impl AzaleaRead for Vec { + default fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let length = u32::azalea_read_var(buf)? as usize; // we limit the capacity to not get exploited into allocating a bunch let mut contents = Vec::with_capacity(usize::min(length, 65536)); for _ in 0..length { - contents.push(T::read_from(buf)?); + contents.push(T::azalea_read(buf)?); } Ok(contents) } } -impl McBufReadable for HashMap { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - let length = i32::var_read_from(buf)? as usize; +impl AzaleaRead for HashMap { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let length = i32::azalea_read_var(buf)? as usize; let mut contents = HashMap::with_capacity(usize::min(length, 65536)); for _ in 0..length { - contents.insert(K::read_from(buf)?, V::read_from(buf)?); + contents.insert(K::azalea_read(buf)?, V::azalea_read(buf)?); } Ok(contents) } } -impl McBufVarReadable - for HashMap -{ - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { - let length = i32::var_read_from(buf)? as usize; +impl AzaleaReadVar for HashMap { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { + let length = i32::azalea_read_var(buf)? as usize; let mut contents = HashMap::with_capacity(usize::min(length, 65536)); for _ in 0..length { - contents.insert(K::read_from(buf)?, V::var_read_from(buf)?); + contents.insert(K::azalea_read(buf)?, V::azalea_read_var(buf)?); } Ok(contents) } } -impl McBufReadable for Vec { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - let length = i32::var_read_from(buf)? as usize; +impl AzaleaRead for Vec { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let length = i32::azalea_read_var(buf)? as usize; read_bytes(buf, length).map(|b| b.to_vec()) } } -impl McBufReadable for String { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for String { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { read_utf_with_len(buf, MAX_STRING_LENGTH.into()) } } +impl AzaleaReadLimited for String { + fn azalea_read_limited(buf: &mut Cursor<&[u8]>, limit: usize) -> Result { + read_utf_with_len(buf, limit as u32) + } +} -impl McBufReadable for u32 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - Ok(i32::read_from(buf)? as u32) +impl AzaleaRead for u32 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + Ok(i32::azalea_read(buf)? as u32) } } -impl McBufVarReadable for u32 { - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { - Ok(i32::var_read_from(buf)? as u32) +impl AzaleaReadVar for u32 { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { + Ok(i32::azalea_read_var(buf)? as u32) } } -impl McBufReadable for u16 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - i16::read_from(buf).map(|i| i as u16) +impl AzaleaRead for u16 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + i16::azalea_read(buf).map(|i| i as u16) } } -impl McBufReadable for i16 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for i16 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_i16::()?) } } -impl McBufVarReadable for u16 { - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { - Ok(i32::var_read_from(buf)? as u16) +impl AzaleaReadVar for u16 { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { + Ok(i32::azalea_read_var(buf)? as u16) } } -impl McBufVarReadable for Vec { - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { - let length = i32::var_read_from(buf)? as usize; +impl AzaleaReadVar for Vec { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { + let length = i32::azalea_read_var(buf)? as usize; let mut contents = Vec::with_capacity(usize::min(length, 65536)); for _ in 0..length { - contents.push(T::var_read_from(buf)?); + contents.push(T::azalea_read_var(buf)?); } Ok(contents) } } -impl McBufReadable for i64 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for i64 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_i64::()?) } } -impl McBufReadable for u64 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - i64::read_from(buf).map(|i| i as u64) +impl AzaleaRead for u64 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + i64::azalea_read(buf).map(|i| i as u64) } } -impl McBufReadable for bool { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - let byte = u8::read_from(buf)?; +impl AzaleaRead for bool { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let byte = u8::azalea_read(buf)?; if byte > 1 { warn!("Boolean value was not 0 or 1, but {}", byte); } @@ -285,46 +298,46 @@ impl McBufReadable for bool { } } -impl McBufReadable for u8 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for u8 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_u8()?) } } -impl McBufReadable for i8 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - u8::read_from(buf).map(|i| i as i8) +impl AzaleaRead for i8 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + u8::azalea_read(buf).map(|i| i as i8) } } -impl McBufReadable for f32 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for f32 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_f32::()?) } } -impl McBufReadable for f64 { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for f64 { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_f64::()?) } } -impl McBufReadable for Option { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - let present = bool::read_from(buf)?; +impl AzaleaRead for Option { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let present = bool::azalea_read(buf)?; Ok(if present { - Some(T::read_from(buf)?) + Some(T::azalea_read(buf)?) } else { None }) } } -impl McBufVarReadable for Option { - fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { - let present = bool::read_from(buf)?; +impl AzaleaReadVar for Option { + fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result { + let present = bool::azalea_read(buf)?; Ok(if present { - Some(T::var_read_from(buf)?) + Some(T::azalea_read_var(buf)?) } else { None }) @@ -332,11 +345,11 @@ impl McBufVarReadable for Option { } // [String; 4] -impl McBufReadable for [T; N] { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for [T; N] { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { let mut contents = Vec::with_capacity(N); for _ in 0..N { - contents.push(T::read_from(buf)?); + contents.push(T::azalea_read(buf)?); } contents.try_into().map_err(|_| { unreachable!("Panic is not possible since the Vec is the same size as the array") @@ -344,14 +357,14 @@ impl McBufReadable for [T; N] { } } -impl McBufReadable for simdnbt::owned::NbtTag { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for simdnbt::owned::NbtTag { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(simdnbt::owned::read_tag(buf).map_err(simdnbt::Error::from)?) } } -impl McBufReadable for simdnbt::owned::NbtCompound { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for simdnbt::owned::NbtCompound { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { match simdnbt::owned::read_tag(buf).map_err(simdnbt::Error::from)? { simdnbt::owned::NbtTag::Compound(compound) => Ok(compound), _ => Err(BufReadError::Custom("Expected compound tag".to_string())), @@ -359,17 +372,17 @@ impl McBufReadable for simdnbt::owned::NbtCompound { } } -impl McBufReadable for simdnbt::owned::Nbt { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for simdnbt::owned::Nbt { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(simdnbt::owned::read_unnamed(buf)?) } } -impl McBufReadable for Box +impl AzaleaRead for Box where - T: McBufReadable, + T: AzaleaRead, { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { - Ok(Box::new(T::read_from(buf)?)) + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + Ok(Box::new(T::azalea_read(buf)?)) } } diff --git a/azalea-buf/src/serializable_uuid.rs b/azalea-buf/src/serializable_uuid.rs index d4ec0315..53eccbbb 100755 --- a/azalea-buf/src/serializable_uuid.rs +++ b/azalea-buf/src/serializable_uuid.rs @@ -2,7 +2,7 @@ use std::io::{Cursor, Write}; use uuid::Uuid; -use crate::{read::BufReadError, McBufReadable, McBufWritable}; +use crate::{read::BufReadError, AzaleaRead, AzaleaWrite}; pub trait SerializableUuid { fn to_int_array(&self) -> [u32; 4]; @@ -34,24 +34,24 @@ impl SerializableUuid for Uuid { } } -impl McBufReadable for Uuid { - fn read_from(buf: &mut Cursor<&[u8]>) -> Result { +impl AzaleaRead for Uuid { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { Ok(Uuid::from_int_array([ - u32::read_from(buf)?, - u32::read_from(buf)?, - u32::read_from(buf)?, - u32::read_from(buf)?, + u32::azalea_read(buf)?, + u32::azalea_read(buf)?, + u32::azalea_read(buf)?, + u32::azalea_read(buf)?, ])) } } -impl McBufWritable for Uuid { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for Uuid { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let [a, b, c, d] = self.to_int_array(); - a.write_into(buf)?; - b.write_into(buf)?; - c.write_into(buf)?; - d.write_into(buf)?; + a.azalea_write(buf)?; + b.azalea_write(buf)?; + c.azalea_write(buf)?; + d.azalea_write(buf)?; Ok(()) } } @@ -79,10 +79,10 @@ mod tests { fn read_write() { let u = Uuid::parse_str("6536bfed-8695-48fd-83a1-ecd24cf2a0fd").unwrap(); let mut buf = Vec::new(); - u.write_into(&mut buf).unwrap(); + u.azalea_write(&mut buf).unwrap(); println!("{buf:?}"); assert_eq!(buf.len(), 16); - let u2 = Uuid::read_from(&mut Cursor::new(&buf)).unwrap(); + let u2 = Uuid::azalea_read(&mut Cursor::new(&buf)).unwrap(); assert_eq!(u, u2); } } diff --git a/azalea-buf/src/write.rs b/azalea-buf/src/write.rs index 49215a5a..1092586d 100755 --- a/azalea-buf/src/write.rs +++ b/azalea-buf/src/write.rs @@ -16,26 +16,26 @@ fn write_utf_with_len( len ); } - string.as_bytes().to_vec().write_into(buf)?; + string.as_bytes().to_vec().azalea_write(buf)?; Ok(()) } -pub trait McBufWritable { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>; +pub trait AzaleaWrite { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error>; } -pub trait McBufVarWritable { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>; +pub trait AzaleaWriteVar { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error>; } -impl McBufWritable for i32 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for i32 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { WriteBytesExt::write_i32::(buf, *self) } } -impl McBufVarWritable for i32 { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWriteVar for i32 { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let mut buffer = [0]; let mut value = *self; if value == 0 { @@ -53,85 +53,85 @@ impl McBufVarWritable for i32 { } } -impl McBufWritable for UnsizedByteArray { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for UnsizedByteArray { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { buf.write_all(self) } } -impl McBufWritable for Vec { - default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - self[..].write_into(buf) +impl AzaleaWrite for Vec { + default fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + self[..].azalea_write(buf) } } -impl McBufWritable for [T] { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - (self.len() as u32).var_write_into(buf)?; +impl AzaleaWrite for [T] { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + (self.len() as u32).azalea_write_var(buf)?; for item in self { - T::write_into(item, buf)?; + T::azalea_write(item, buf)?; } Ok(()) } } -impl McBufWritable for HashMap { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - u32::var_write_into(&(self.len() as u32), buf)?; +impl AzaleaWrite for HashMap { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + u32::azalea_write_var(&(self.len() as u32), buf)?; for (key, value) in self { - key.write_into(buf)?; - value.write_into(buf)?; + key.azalea_write(buf)?; + value.azalea_write(buf)?; } Ok(()) } } -impl McBufVarWritable for HashMap { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - u32::var_write_into(&(self.len() as u32), buf)?; +impl AzaleaWriteVar for HashMap { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + u32::azalea_write_var(&(self.len() as u32), buf)?; for (key, value) in self { - key.write_into(buf)?; - value.var_write_into(buf)?; + key.azalea_write(buf)?; + value.azalea_write_var(buf)?; } Ok(()) } } -impl McBufWritable for Vec { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - (self.len() as u32).var_write_into(buf)?; +impl AzaleaWrite for Vec { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + (self.len() as u32).azalea_write_var(buf)?; buf.write_all(self) } } -impl McBufWritable for String { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for String { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { write_utf_with_len(buf, self, MAX_STRING_LENGTH.into()) } } -impl McBufWritable for &str { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for &str { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { write_utf_with_len(buf, self, MAX_STRING_LENGTH.into()) } } -impl McBufWritable for u32 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - i32::write_into(&(*self as i32), buf) +impl AzaleaWrite for u32 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + i32::azalea_write(&(*self as i32), buf) } } -impl McBufVarWritable for u32 { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - i32::var_write_into(&(*self as i32), buf) +impl AzaleaWriteVar for u32 { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + i32::azalea_write_var(&(*self as i32), buf) } } -impl McBufVarWritable for i64 { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWriteVar for i64 { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let mut buffer = [0]; let mut value = *self; if value == 0 { @@ -149,146 +149,146 @@ impl McBufVarWritable for i64 { } } -impl McBufVarWritable for u64 { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - i64::var_write_into(&(*self as i64), buf) +impl AzaleaWriteVar for u64 { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + i64::azalea_write_var(&(*self as i64), buf) } } -impl McBufWritable for u16 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - i16::write_into(&(*self as i16), buf) +impl AzaleaWrite for u16 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + i16::azalea_write(&(*self as i16), buf) } } -impl McBufVarWritable for u16 { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - i32::var_write_into(&(*self as i32), buf) +impl AzaleaWriteVar for u16 { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + i32::azalea_write_var(&(*self as i32), buf) } } -impl McBufVarWritable for Vec { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - u32::var_write_into(&(self.len() as u32), buf)?; +impl AzaleaWriteVar for Vec { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + u32::azalea_write_var(&(self.len() as u32), buf)?; for i in self { - i.var_write_into(buf)?; + i.azalea_write_var(buf)?; } Ok(()) } } -impl McBufWritable for u8 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for u8 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { WriteBytesExt::write_u8(buf, *self) } } -impl McBufWritable for i16 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for i16 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { WriteBytesExt::write_i16::(buf, *self) } } -impl McBufWritable for i64 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for i64 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { WriteBytesExt::write_i64::(buf, *self) } } -impl McBufWritable for u64 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - i64::write_into(&(*self as i64), buf) +impl AzaleaWrite for u64 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + i64::azalea_write(&(*self as i64), buf) } } -impl McBufWritable for bool { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for bool { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let byte = u8::from(*self); - byte.write_into(buf) + byte.azalea_write(buf) } } -impl McBufWritable for i8 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - (*self as u8).write_into(buf) +impl AzaleaWrite for i8 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + (*self as u8).azalea_write(buf) } } -impl McBufWritable for f32 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for f32 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { WriteBytesExt::write_f32::(buf, *self) } } -impl McBufWritable for f64 { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for f64 { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { WriteBytesExt::write_f64::(buf, *self) } } -impl McBufWritable for Option { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for Option { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { if let Some(s) = self { - true.write_into(buf)?; - s.write_into(buf)?; + true.azalea_write(buf)?; + s.azalea_write(buf)?; } else { - false.write_into(buf)?; + false.azalea_write(buf)?; }; Ok(()) } } -impl McBufVarWritable for Option { - fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWriteVar for Option { + fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { if let Some(s) = self { - true.write_into(buf)?; - s.var_write_into(buf)?; + true.azalea_write(buf)?; + s.azalea_write_var(buf)?; } else { - false.write_into(buf)?; + false.azalea_write(buf)?; }; Ok(()) } } // [T; N] -impl McBufWritable for [T; N] { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for [T; N] { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { for i in self { - i.write_into(buf)?; + i.azalea_write(buf)?; } Ok(()) } } -impl McBufWritable for simdnbt::owned::NbtTag { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for simdnbt::owned::NbtTag { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let mut data = Vec::new(); self.write(&mut data); buf.write_all(&data) } } -impl McBufWritable for simdnbt::owned::NbtCompound { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for simdnbt::owned::NbtCompound { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let mut data = Vec::new(); simdnbt::owned::NbtTag::Compound(self.clone()).write(&mut data); buf.write_all(&data) } } -impl McBufWritable for simdnbt::owned::Nbt { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { +impl AzaleaWrite for simdnbt::owned::Nbt { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { let mut data = Vec::new(); self.write_unnamed(&mut data); buf.write_all(&data) } } -impl McBufWritable for Box +impl AzaleaWrite for Box where - T: McBufWritable, + T: AzaleaWrite, { - fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - T::write_into(&**self, buf) + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + T::azalea_write(&**self, buf) } } -- cgit v1.2.3