make encode not a Result and small optimizations

1 files changed, 116 insertions, 128 deletions

diff --git a/azalea-nbt/src/encode.rs b/azalea-nbt/src/encode.rs
index 03715691..4d76fede 100755
--- a/azalea-nbt/src/encode.rs
+++ b/azalea-nbt/src/encode.rs
@@ -1,207 +1,199 @@
 use crate::tag::*;
-use crate::Error;
 use azalea_buf::McBufWritable;
 use byteorder::{WriteBytesExt, BE};
 use flate2::write::{GzEncoder, ZlibEncoder};
 use std::io::Write;
 
-#[inline]
-fn write_string(writer: &mut dyn Write, string: &str) -> Result<(), Error> {
-    writer.write_u16::<BE>(string.len() as u16)?;
-    writer.write_all(string.as_bytes())?;
-
-    Ok(())
+#[inline(always)]
+fn write_string(writer: &mut dyn Write, string: &str) {
+    writer.write_u16::<BE>(string.len() as u16).unwrap();
+    writer.write_all(string.as_bytes()).unwrap();
 }
 
 #[inline]
-fn write_compound(writer: &mut dyn Write, value: &NbtCompound, end_tag: bool) -> Result<(), Error> {
-    for (key, tag) in value.inner() {
+fn write_compound(writer: &mut dyn Write, value: &NbtCompound, end_tag: bool) {
+    for (key, tag) in value.iter() {
         match tag {
             Tag::End => {}
             Tag::Byte(value) => {
-                writer.write_u8(BYTE_ID)?;
-                write_string(writer, key)?;
-                writer.write_i8(*value)?;
+                writer.write_u8(BYTE_ID).unwrap();
+                write_string(writer, key);
+                writer.write_i8(*value).unwrap();
             }
             Tag::Short(value) => {
-                writer.write_u8(SHORT_ID)?;
-                write_string(writer, key)?;
-                writer.write_i16::<BE>(*value)?;
+                writer.write_u8(SHORT_ID).unwrap();
+                write_string(writer, key);
+                writer.write_i16::<BE>(*value).unwrap();
             }
             Tag::Int(value) => {
-                writer.write_u8(INT_ID)?;
-                write_string(writer, key)?;
-                writer.write_i32::<BE>(*value)?;
+                writer.write_u8(INT_ID).unwrap();
+                write_string(writer, key);
+                writer.write_i32::<BE>(*value).unwrap();
             }
             Tag::Long(value) => {
-                writer.write_u8(LONG_ID)?;
-                write_string(writer, key)?;
-                writer.write_i64::<BE>(*value)?;
+                writer.write_u8(LONG_ID).unwrap();
+                write_string(writer, key);
+                writer.write_i64::<BE>(*value).unwrap();
             }
             Tag::Float(value) => {
-                writer.write_u8(FLOAT_ID)?;
-                write_string(writer, key)?;
-                writer.write_f32::<BE>(*value)?;
+                writer.write_u8(FLOAT_ID).unwrap();
+                write_string(writer, key);
+                writer.write_f32::<BE>(*value).unwrap();
             }
             Tag::Double(value) => {
-                writer.write_u8(DOUBLE_ID)?;
-                write_string(writer, key)?;
-                writer.write_f64::<BE>(*value)?;
+                writer.write_u8(DOUBLE_ID).unwrap();
+                write_string(writer, key);
+                writer.write_f64::<BE>(*value).unwrap();
             }
             Tag::ByteArray(value) => {
-                writer.write_u8(BYTE_ARRAY_ID)?;
-                write_string(writer, key)?;
-                write_byte_array(writer, value)?;
+                writer.write_u8(BYTE_ARRAY_ID).unwrap();
+                write_string(writer, key);
+                write_byte_array(writer, value);
             }
             Tag::String(value) => {
-                writer.write_u8(STRING_ID)?;
-                write_string(writer, key)?;
-                write_string(writer, value)?;
+                writer.write_u8(STRING_ID).unwrap();
+                write_string(writer, key);
+                write_string(writer, value);
             }
             Tag::List(value) => {
-                writer.write_u8(LIST_ID)?;
-                write_string(writer, key)?;
-                write_list(writer, value)?;
+                writer.write_u8(LIST_ID).unwrap();
+                write_string(writer, key);
+                write_list(writer, value);
             }
             Tag::Compound(value) => {
-                writer.write_u8(COMPOUND_ID)?;
-                write_string(writer, key)?;
-                write_compound(writer, value, true)?;
+                writer.write_u8(COMPOUND_ID).unwrap();
+                write_string(writer, key);
+                write_compound(writer, value, true);
             }
             Tag::IntArray(value) => {
-                writer.write_u8(INT_ARRAY_ID)?;
-                write_string(writer, key)?;
-                write_int_array(writer, value)?;
+                writer.write_u8(INT_ARRAY_ID).unwrap();
+                write_string(writer, key);
+                write_int_array(writer, value);
             }
             Tag::LongArray(value) => {
-                writer.write_u8(LONG_ARRAY_ID)?;
-                write_string(writer, key)?;
-                write_long_array(writer, value)?;
+                writer.write_u8(LONG_ARRAY_ID).unwrap();
+                write_string(writer, key);
+                write_long_array(writer, value);
             }
         }
     }
     if end_tag {
-        writer.write_u8(Tag::End.id())?;
+        writer.write_u8(END_ID).unwrap();
     }
-    Ok(())
 }
 
 #[inline]
-fn write_list(writer: &mut dyn Write, value: &NbtList) -> Result<(), Error> {
+fn write_list(writer: &mut dyn Write, value: &NbtList) {
     match value {
-        NbtList::Empty => writer.write_all(&[0; 5])?,
+        NbtList::Empty => writer.write_all(&[0; 5]).unwrap(),
         NbtList::Byte(l) => {
-            writer.write_u8(BYTE_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
-            for v in l {
-                writer.write_i8(*v)?;
-            }
+            writer.write_u8(BYTE_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
+            let l = l.as_slice();
+            writer
+                .write_all(unsafe { std::slice::from_raw_parts(l.as_ptr() as *const u8, l.len()) })
+                .unwrap();
         }
         NbtList::Short(l) => {
-            writer.write_u8(SHORT_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(SHORT_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                writer.write_i16::<BE>(*v)?;
+                writer.write_i16::<BE>(*v).unwrap();
             }
         }
         NbtList::Int(l) => {
-            writer.write_u8(INT_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(INT_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                writer.write_i32::<BE>(*v)?;
+                writer.write_i32::<BE>(*v).unwrap();
             }
         }
         NbtList::Long(l) => {
-            writer.write_u8(LONG_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(LONG_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                writer.write_i64::<BE>(*v)?;
+                writer.write_i64::<BE>(*v).unwrap();
             }
         }
         NbtList::Float(l) => {
-            writer.write_u8(FLOAT_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(FLOAT_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                writer.write_f32::<BE>(*v)?;
+                writer.write_f32::<BE>(*v).unwrap();
             }
         }
         NbtList::Double(l) => {
-            writer.write_u8(DOUBLE_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(DOUBLE_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                writer.write_f64::<BE>(*v)?;
+                writer.write_f64::<BE>(*v).unwrap();
             }
         }
         NbtList::ByteArray(l) => {
-            writer.write_u8(BYTE_ARRAY_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(BYTE_ARRAY_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                write_byte_array(writer, v)?;
+                write_byte_array(writer, v);
             }
         }
         NbtList::String(l) => {
-            writer.write_u8(STRING_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(STRING_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                write_string(writer, v)?;
+                write_string(writer, v);
             }
         }
         NbtList::List(l) => {
-            writer.write_u8(LIST_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(LIST_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                write_list(writer, v)?;
+                write_list(writer, v);
             }
         }
         NbtList::Compound(l) => {
-            writer.write_u8(COMPOUND_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(COMPOUND_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                write_compound(writer, v, true)?;
+                write_compound(writer, v, true);
             }
         }
         NbtList::IntArray(l) => {
-            writer.write_u8(INT_ARRAY_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(INT_ARRAY_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                write_int_array(writer, v)?;
+                write_int_array(writer, v);
             }
         }
         NbtList::LongArray(l) => {
-            writer.write_u8(LONG_ARRAY_ID)?;
-            writer.write_i32::<BE>(l.len() as i32)?;
+            writer.write_u8(LONG_ARRAY_ID).unwrap();
+            writer.write_i32::<BE>(l.len() as i32).unwrap();
             for v in l {
-                write_long_array(writer, v)?;
+                write_long_array(writer, v);
             }
         }
     }
-
-    Ok(())
 }
 
 #[inline]
-fn write_byte_array(writer: &mut dyn Write, value: &Vec<u8>) -> Result<(), Error> {
-    writer.write_u32::<BE>(value.len() as u32)?;
-    writer.write_all(value)?;
-    Ok(())
+fn write_byte_array(writer: &mut dyn Write, value: &Vec<u8>) {
+    writer.write_u32::<BE>(value.len() as u32).unwrap();
+    writer.write_all(value).unwrap();
 }
 
 #[inline]
-fn write_int_array(writer: &mut dyn Write, value: &Vec<i32>) -> Result<(), Error> {
-    writer.write_u32::<BE>(value.len() as u32)?;
+fn write_int_array(writer: &mut dyn Write, value: &Vec<i32>) {
+    writer.write_u32::<BE>(value.len() as u32).unwrap();
     for &int in value {
-        writer.write_i32::<BE>(int)?;
+        writer.write_i32::<BE>(int).unwrap();
     }
-    Ok(())
 }
 
 #[inline]
-fn write_long_array(writer: &mut dyn Write, value: &Vec<i64>) -> Result<(), Error> {
-    writer.write_u32::<BE>(value.len() as u32)?;
+fn write_long_array(writer: &mut dyn Write, value: &Vec<i64>) {
+    writer.write_u32::<BE>(value.len() as u32).unwrap();
     for &long in value {
-        writer.write_i64::<BE>(long)?;
+        writer.write_i64::<BE>(long).unwrap();
     }
-    Ok(())
 }
 
 impl Tag {
@@ -210,42 +202,38 @@ impl Tag {
     /// [`Tag::write`] to avoid the `End` tag (this is used when writing NBT to
     /// a file).
     #[inline]
-    pub fn write_without_end(&self, writer: &mut dyn Write) -> Result<(), Error> {
+    pub fn write_without_end(&self, writer: &mut dyn Write) {
         match self {
             Tag::End => {}
-            Tag::Byte(value) => writer.write_i8(*value)?,
-            Tag::Short(value) => writer.write_i16::<BE>(*value)?,
-            Tag::Int(value) => writer.write_i32::<BE>(*value)?,
-            Tag::Long(value) => writer.write_i64::<BE>(*value)?,
-            Tag::Float(value) => writer.write_f32::<BE>(*value)?,
-            Tag::Double(value) => writer.write_f64::<BE>(*value)?,
-            Tag::ByteArray(value) => write_byte_array(writer, value)?,
-            Tag::String(value) => write_string(writer, value)?,
-            Tag::List(value) => write_list(writer, value)?,
-            Tag::Compound(value) => write_compound(writer, value, true)?,
-            Tag::IntArray(value) => write_int_array(writer, value)?,
-            Tag::LongArray(value) => write_long_array(writer, value)?,
+            Tag::Byte(value) => writer.write_i8(*value).unwrap(),
+            Tag::Short(value) => writer.write_i16::<BE>(*value).unwrap(),
+            Tag::Int(value) => writer.write_i32::<BE>(*value).unwrap(),
+            Tag::Long(value) => writer.write_i64::<BE>(*value).unwrap(),
+            Tag::Float(value) => writer.write_f32::<BE>(*value).unwrap(),
+            Tag::Double(value) => writer.write_f64::<BE>(*value).unwrap(),
+            Tag::ByteArray(value) => write_byte_array(writer, value),
+            Tag::String(value) => write_string(writer, value),
+            Tag::List(value) => write_list(writer, value),
+            Tag::Compound(value) => write_compound(writer, value, true),
+            Tag::IntArray(value) => write_int_array(writer, value),
+            Tag::LongArray(value) => write_long_array(writer, value),
         }
-
-        Ok(())
     }
 
     /// Write the compound tag as NBT data.
     ///
-    /// # Errors
+    /// # Panics
     ///
-    /// Returns an `Err` if it's not a Compound or End tag.
-    pub fn write(&self, writer: &mut impl Write) -> Result<(), Error> {
+    /// Will panic if the tag is not a Compound or End tag.
+    pub fn write(&self, writer: &mut impl Write) {
         match self {
             Tag::Compound(value) => {
-                write_compound(writer, value, false)?;
-                Ok(())
+                write_compound(writer, value, false);
             }
             Tag::End => {
-                0u8.write_into(writer)?;
-                Ok(())
+                END_ID.write_into(writer).unwrap();
             }
-            _ => Err(Error::InvalidTag),
+            _ => panic!("Not a compound tag"),
         }
     }
 
@@ -254,7 +242,7 @@ impl Tag {
     /// # Errors
     ///
     /// Returns an `Err` if it's not a Compound or End tag.
-    pub fn write_zlib(&self, writer: &mut impl Write) -> Result<(), Error> {
+    pub fn write_zlib(&self, writer: &mut impl Write) {
         let mut encoder = ZlibEncoder::new(writer, flate2::Compression::default());
         self.write(&mut encoder)
     }
@@ -264,7 +252,7 @@ impl Tag {
     /// # Errors
     ///
     /// Returns an `Err` if it's not a Compound or End tag.
-    pub fn write_gzip(&self, writer: &mut impl Write) -> Result<(), Error> {
+    pub fn write_gzip(&self, writer: &mut impl Write) {
         let mut encoder = GzEncoder::new(writer, flate2::Compression::default());
         self.write(&mut encoder)
     }
@@ -272,7 +260,7 @@ impl Tag {
 
 impl McBufWritable for Tag {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        self.write(buf)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
+        self.write(buf);
+        Ok(())
     }
 }