simplify nbt list optimization

4 files changed, 50 insertions, 27 deletions

diff --git a/azalea-nbt/README.md b/azalea-nbt/README.md
index 0573bce2..19498cf3 100755
--- a/azalea-nbt/README.md
+++ b/azalea-nbt/README.md
@@ -1,6 +1,3 @@
 # Azalea NBT
 
-Deserialize Minecraft NBT. This is somewhat based on [Hermatite NBT](https://github.com/PistonDevelopers/hematite_nbt).
-
-
-
+A fast NBT serializer and deserializer.
diff --git a/azalea-nbt/benches/my_benchmark.rs b/azalea-nbt/benches/my_benchmark.rs
index 51e574e3..528475d3 100755
--- a/azalea-nbt/benches/my_benchmark.rs
+++ b/azalea-nbt/benches/my_benchmark.rs
@@ -25,17 +25,18 @@ fn bench_serialize(filename: &str, c: &mut Criterion) {
         .block_on(async { Tag::read(&mut decoded_src_stream).await.unwrap() });
 
     let mut group = c.benchmark_group(filename);
+    group.sample_size(1000);
 
     group.throughput(Throughput::Bytes(decoded_src.len() as u64));
 
-    group.bench_function("Decode", |b| {
-        b.to_async(tokio::runtime::Runtime::new().unwrap())
-            .iter(|| async {
-                let mut owned_decoded_src_stream = decoded_src_stream.clone();
-                owned_decoded_src_stream.seek(SeekFrom::Start(0)).unwrap();
-                Tag::read(&mut owned_decoded_src_stream).await.unwrap();
-            })
-    });
+    // group.bench_function("Decode", |b| {
+    //     b.to_async(tokio::runtime::Runtime::new().unwrap())
+    //         .iter(|| async {
+    //             let mut owned_decoded_src_stream = decoded_src_stream.clone();
+    //             owned_decoded_src_stream.seek(SeekFrom::Start(0)).unwrap();
+    //             Tag::read(&mut owned_decoded_src_stream).await.unwrap();
+    //         })
+    // });
 
     group.bench_function("Encode", |b| {
         b.iter(|| {
diff --git a/azalea-nbt/src/encode.rs b/azalea-nbt/src/encode.rs
index ebd1070f..ef72dce2 100755
--- a/azalea-nbt/src/encode.rs
+++ b/azalea-nbt/src/encode.rs
@@ -54,29 +54,27 @@ impl Tag {
                     match first_tag {
                         Self::Int(_) => {
                             for i in value {
-                                if let Tag::Int(v) = i {
-                                    writer.write_i32::<BE>(*v)?
-                                } else {
-                                    panic!("List of Ints should only contain Ints")
-                                }
+                                writer.write_i32::<BE>(
+                                    *i.as_int().expect("List of Int should only contains Int"),
+                                )?;
                             }
                         }
                         Self::String(_) => {
                             for i in value {
-                                if let Tag::String(v) = i {
-                                    write_string(writer, v)?;
-                                } else {
-                                    panic!("List of Strings should only contain Strings")
-                                }
+                                write_string(
+                                    writer,
+                                    i.as_string()
+                                        .expect("List of String should only contain String"),
+                                )?;
                             }
                         }
                         &Self::Compound(_) => {
                             for i in value {
-                                if let Tag::Compound(v) = i {
-                                    write_compound(writer, v)?;
-                                } else {
-                                    panic!("List of Compounds should only contain Compounds")
-                                }
+                                write_compound(
+                                    writer,
+                                    i.as_compound()
+                                        .expect("List of Compound should only contain Compound"),
+                                )?;
                             }
                         }
                         _ => {
diff --git a/azalea-nbt/src/tag.rs b/azalea-nbt/src/tag.rs
index f11b8889..705dff6a 100755
--- a/azalea-nbt/src/tag.rs
+++ b/azalea-nbt/src/tag.rs
@@ -36,4 +36,31 @@ impl Tag {
             Tag::LongArray(_) => 12,
         }
     }
+
+    #[inline]
+    pub fn as_int(&self) -> Option<&i32> {
+        if let Tag::Int(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub fn as_string(&self) -> Option<&str> {
+        if let Tag::String(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub fn as_compound(&self) -> Option<&HashMap<String, Tag>> {
+        if let Tag::Compound(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
 }