impl Write instead of Vec<u8> for consistency

1 files changed, 45 insertions, 83 deletions

diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 57ec3a48..34bcafeb 100755
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -8,49 +8,10 @@ use byteorder::{BigEndian, WriteBytesExt};
 use std::io::Write;
 use uuid::Uuid;
 
-pub trait Writable {
+pub trait Writable: Write {
     fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
     where
         F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
-        T: Sized,
-        Self: Sized;
-    fn write_int_id_list(&mut self, list: &Vec<i32>) -> Result<(), std::io::Error>;
-    fn write_map<KF, VF, KT, VT>(
-        &mut self,
-        map: Vec<(KT, VT)>,
-        key_writer: KF,
-        value_writer: VF,
-    ) -> Result<(), std::io::Error>
-    where
-        KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
-        VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
-        Self: Sized;
-
-    fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error>;
-    fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
-    fn write_varint(&mut self, value: i32) -> Result<(), std::io::Error>;
-    fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error>;
-    fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error>;
-    fn write_short(&mut self, n: i16) -> Result<(), std::io::Error>;
-    fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
-    fn write_int(&mut self, n: i32) -> Result<(), std::io::Error>;
-    fn write_boolean(&mut self, b: bool) -> Result<(), std::io::Error>;
-    fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error>;
-    fn write_long(&mut self, n: i64) -> Result<(), std::io::Error>;
-    fn write_resource_location(
-        &mut self,
-        location: &ResourceLocation,
-    ) -> Result<(), std::io::Error>;
-    fn write_float(&mut self, n: f32) -> Result<(), std::io::Error>;
-    fn write_double(&mut self, n: f64) -> Result<(), std::io::Error>;
-    fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error>;
-}
-
-impl Writable for Vec<u8> {
-    fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
-    where
-        F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
-        Self: Sized,
     {
         self.write_varint(list.len() as i32)?;
         for item in list {
@@ -72,7 +33,6 @@ impl Writable for Vec<u8> {
     where
         KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
         VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
-        Self: Sized,
     {
         self.write_varint(map.len() as i32)?;
         for (key, value) in map {
@@ -87,7 +47,7 @@ impl Writable for Vec<u8> {
     }
 
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
-        self.extend_from_slice(bytes);
+        self.write_all(bytes);
         Ok(())
     }
 
@@ -140,7 +100,10 @@ impl Writable for Vec<u8> {
         self.write_byte(if b { 1 } else { 0 })
     }
 
-    fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error> {
+    fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error>
+    where
+        Self: Sized,
+    {
         nbt.write(self)
             .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
     }
@@ -164,7 +127,10 @@ impl Writable for Vec<u8> {
         self.write_utf(&location.to_string())
     }
 
-    fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error> {
+    fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error>
+    where
+        Self: Sized,
+    {
         let [a, b, c, d] = uuid.to_int_array();
         a.write_into(self)?;
         b.write_into(self)?;
@@ -174,34 +140,30 @@ impl Writable for Vec<u8> {
     }
 }
 
-pub trait McBufWritable
-where
-    Self: Sized,
-{
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
+impl<W: Write + ?Sized> Writable for W {}
+
+pub trait McBufWritable {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
-pub trait McBufVarintWritable
-where
-    Self: Sized,
-{
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
+pub trait McBufVarintWritable {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
 impl McBufWritable for i32 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_int(buf, *self)
     }
 }
 
 impl McBufVarintWritable for i32 {
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_varint(*self)
     }
 }
 
 impl McBufWritable for UnsizedByteArray {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_bytes(self)
     }
 }
@@ -209,132 +171,132 @@ impl McBufWritable for UnsizedByteArray {
 // TODO: use specialization when that gets stabilized into rust
 // to optimize for Vec<u8> byte arrays
 impl<T: McBufWritable> McBufWritable for Vec<T> {
-    default fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_list(self, |buf, i| T::write_into(i, buf))
     }
 }
 
 impl McBufWritable for Vec<u8> {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte_array(self)
     }
 }
 
 // string
 impl McBufWritable for String {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_utf(self)
     }
 }
 
 // ResourceLocation
 impl McBufWritable for ResourceLocation {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_resource_location(self)
     }
 }
 
 // u32
 impl McBufWritable for u32 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i16::write_into(&(*self as i16), buf)
     }
 }
 
 // u32 varint
 impl McBufVarintWritable for u32 {
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i32::varint_write_into(&(*self as i32), buf)
     }
 }
 
 // u16
 impl McBufWritable for u16 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i16::write_into(&(*self as i16), buf)
     }
 }
 
 // u16 varint
 impl McBufVarintWritable for u16 {
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i32::varint_write_into(&(*self as i32), buf)
     }
 }
 
 // u8
 impl McBufWritable for u8 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(*self)
     }
 }
 
 // i16
 impl McBufWritable for i16 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_short(buf, *self)
     }
 }
 
 // i64
 impl McBufWritable for i64 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_long(buf, *self)
     }
 }
 
 // u64
 impl McBufWritable for u64 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i64::write_into(&(*self as i64), buf)
     }
 }
 
 // bool
 impl McBufWritable for bool {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_boolean(*self)
     }
 }
 
 // i8
 impl McBufWritable for i8 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(*self as u8)
     }
 }
 
 // f32
 impl McBufWritable for f32 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_float(*self)
     }
 }
 
 // f64
 impl McBufWritable for f64 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_double(*self)
     }
 }
 
 // GameType
 impl McBufWritable for GameType {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u8::write_into(&self.to_id(), buf)
     }
 }
 
 // Option<GameType>
 impl McBufWritable for Option<GameType> {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(GameType::to_optional_id(self) as u8)
     }
 }
 
 // Option<String>
 impl<T: McBufWritable> McBufWritable for Option<T> {
-    default fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         if let Some(s) = self {
             buf.write_boolean(true)?;
             s.write_into(buf)?;
@@ -347,14 +309,14 @@ impl<T: McBufWritable> McBufWritable for Option<T> {
 
 // azalea_nbt::Tag
 impl McBufWritable for azalea_nbt::Tag {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_nbt(self)
     }
 }
 
 // Difficulty
 impl McBufWritable for Difficulty {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u8::write_into(&self.id(), buf)
     }
 }
@@ -371,7 +333,7 @@ impl McBufWritable for Component {
     //     let component = Component::deserialize(json).map_err(|e| e.to_string())?;
     //     Ok(component)
     // }
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         // component doesn't have serialize implemented yet
         todo!()
     }
@@ -379,7 +341,7 @@ impl McBufWritable for Component {
 
 // Slot
 impl McBufWritable for Slot {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         match self {
             Slot::Empty => buf.write_byte(0)?,
             Slot::Present(i) => {
@@ -395,7 +357,7 @@ impl McBufWritable for Slot {
 
 // Slot
 impl McBufWritable for Uuid {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_uuid(self)?;
 
         Ok(())
@@ -404,7 +366,7 @@ impl McBufWritable for Uuid {
 
 // BlockPos
 impl McBufWritable for BlockPos {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_long(
             (((self.x & 0x3FFFFFF) as i64) << 38)
                 | (((self.z & 0x3FFFFFF) as i64) << 12)
@@ -415,7 +377,7 @@ impl McBufWritable for BlockPos {
 
 // Direction
 impl McBufWritable for Direction {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_varint(*self as i32)
     }
 }