implement LongArray read/write operations (fixes #1)

Fixes this error when trying to open an NBT file:

    caused by: Got unknown type id c trying to read NBT compound

Thanks to ravomavain@ for fixing an issue in which the length of the
array is stored in a 32 bit int

src/unstable/data.rs

@@ -15,6 +15,7 @@ pub enum NBT {
     List(Vec<NBT>),
     Compound(Vec<(Vec<u8>, NBT)>),
     IntArray(Vec<i32>),
+    LongArray(Vec<i64>),
 }
 impl NBT {
     pub fn get<S: AsRef<[u8]>>(&self, val: S) -> Option<&NBT> {
@@ -55,6 +56,7 @@ impl NBT {
             &NBT::List(..) => "List",
             &NBT::Compound(..) => "Compound",
             &NBT::IntArray(..) => "IntArray",
+            &NBT::LongArray(..) => "LongArray",
         }
     }
     /// Returns the type of the tag as a single u8
@@ -72,6 +74,7 @@ impl NBT {
             &NBT::List(..) => 9,
             &NBT::Compound(..) => 10,
             &NBT::IntArray(..) => 11,
+            &NBT::LongArray(..) => 12,
         }
     }
 }

src/unstable/read.rs

@@ -77,6 +77,7 @@ fn read_compound<R: Read>(reader: &mut R) -> Result<NBT> {
                 0x09 => read_list(reader)?,
                 0x0a => read_compound(reader)?,
                 0x0b => read_int_array(reader)?,
+                0x0c => read_long_array(reader)?,
                 x => {
                     bail!("Got unknown type id {:x} trying to read NBT compound", x);
                 }
@@ -167,6 +168,7 @@ fn read_list<R: Read>(reader: &mut R) -> Result<NBT> {
             0x9 => read_list(reader)?,
             0xa => read_compound(reader)?,
             0xb => read_int_array(reader)?,
+            0xc => read_long_array(reader)?,
             x => bail!("Got unknown type id {:x} trying to read NBT list", x),
         });
     }
@@ -191,3 +193,21 @@ fn read_int_array<R: Read>(reader: &mut R) -> Result<NBT> {
 
     Ok(NBT::IntArray(ret))
 }
+
+fn read_long_array<R: Read>(reader: &mut R) -> Result<NBT> {
+    let length = match read_int(reader)? {
+        NBT::Int(val) => val as usize,
+        _ => unreachable!(),
+    };
+
+    let mut ret: Vec<i64> = Vec::new();
+
+    for _ in 0..length {
+        ret.push(match read_long(reader)? {
+            NBT::Long(val) => val,
+            _ => unreachable!(),
+        });
+    }
+
+    Ok(NBT::LongArray(ret))
+}

src/unstable/string_read.rs

@@ -162,6 +162,7 @@ fn read_tag(tokens: &mut Tokens, tag_type: &str) -> Result<NBT> {
         "List" => read_list(tokens),
         "Compound" => read_compound(tokens),
         "IntArray" => read_int_array(tokens),
+        "LongArray" => read_long_array(tokens),
         x => bail!("Unknown tag type {}", x),
     }
 }
@@ -311,3 +312,18 @@ fn read_int_array(tokens: &mut Tokens) -> Result<NBT> {
     }
     Ok(NBT::IntArray(tmp))
 }
+
+fn read_long_array(tokens: &mut Tokens) -> Result<NBT> {
+    let len = match read_int(tokens)? {
+        NBT::Int(x) => x,
+        _ => unreachable!(),
+    };
+    let mut tmp = Vec::with_capacity(len as usize);
+    for _ in 0..len {
+        tmp.push(match read_long(tokens)? {
+            NBT::Long(x) => x,
+            _ => unreachable!(),
+        });
+    }
+    Ok(NBT::LongArray(tmp))
+}

src/unstable/string_write.rs

@@ -116,6 +116,13 @@ fn write_tag<W: Write>(w: &mut W, tag: &NBT, indent: u64, compound: bool) -> Res
                 writeln!(w, "{}", val)?;
             }
         }
+        &NBT::LongArray(ref x) => {
+            writeln!(w, " {}", x.len())?;
+            for val in x {
+                write_indent(w, indent)?;
+                writeln!(w, "{}", val)?;
+            }
+        }
     }
 
     Ok(())

src/unstable/tests/string_read.rs

@@ -70,6 +70,13 @@ fn invalid_tag_type() {
     assert!(err_msg.contains("Unknown tag type NotATagType"));
 }
 
+#[test]
+fn long_array() {
+    /* LongArray should compile */
+    let _: NBTFile =
+        try_parse_string(r#"None Compound "tag" Compound "BlockEntityTag" LongArray "Items" 0 String "id" "minecraft:shulker_box" End End End"#).unwrap();
+}
+
 #[test]
 fn unquoted_string() {
     /* Since the rewrite of the tokenizer, strings without quotation marks have

src/unstable/write.rs

@@ -52,6 +52,7 @@ fn write_tag<W: Write>(w: &mut W, tag: &NBT) -> Result<()> {
         &NBT::List(ref x) => write_list(w, x),
         &NBT::Compound(ref x) => write_compound(w, x, true),
         &NBT::IntArray(ref x) => write_int_array(w, x),
+        &NBT::LongArray(ref x) => write_long_array(w, x),
     }
 }
 
@@ -132,3 +133,13 @@ fn write_int_array<W: Write>(w: &mut W, val: &Vec<i32>) -> Result<()> {
 
     Ok(())
 }
+
+fn write_long_array<W: Write>(w: &mut W, val: &Vec<i64>) -> Result<()> {
+    write_int(w, val.len() as i32)?;
+
+    for x in val {
+        write_long(w, *x)?;
+    }
+
+    Ok(())
+}