test ReadStream with SGD decoding

src/fot/stream.rs

@@ -10,11 +10,10 @@ pub struct ReadStream<'a> {
 }
 
 impl<'a> ReadStream<'a> {
-    pub fn new(raw: &Raw, offset: usize) -> ReadStream {
+    pub fn new(raw: &Raw, start: usize) -> ReadStream {
-        ReadStream {
+        let mut rdr = Cursor::new(&raw.mem[..]);
-            raw: raw,
+        rdr.set_position(start as u64);
-            rdr: Cursor::new(&raw.mem[offset..]),
+        ReadStream { raw: raw, rdr: rdr }
-        }
     }
 
     pub fn offset(&self) -> usize {

src/fot/world.rs

@@ -1,6 +1,7 @@
 use super::decoder::Decoder;
 use super::fstring::FString;
 use super::raw::Raw;
+use super::stream::ReadStream;
 use super::tag::Tag;
 use anyhow::anyhow;
 use anyhow::Result;
@@ -23,37 +24,27 @@ impl World {
 
     pub fn test(&self) -> Result<()> {
         let sgd_start: usize = 0x4E;
-        let mut cur = sgd_start;
+        let mut sgd = ReadStream::new(&self.data, sgd_start);
-        cur += Tag::decode(&self.data, sgd_start, 0)?.get_enc_size();
+        let _ = sgd.read::<Tag>(0)?;
-        cur += 0x48;
+        sgd.skip(0x48);
 
-        let mut rdr = Cursor::new(&self.data.mem[..]);
+        let n = sgd.read_u32()?;
-        rdr.set_position(cur as u64);
+        dbg!(sgd.offset(), n);
-        let N = rdr.read_u32::<LittleEndian>()?;
+        let mut names: Vec<FString> = Vec::with_capacity(n as usize);
-
+        for _ in 0..n {
-        let mut names: Vec<FString> = Vec::new();
+            names.push(sgd.read::<FString>(0)?);
-        cur += 4;
-        for _ in 0..N {
-            let name = FString::decode(&self.data, cur, 0)?;
-            cur += name.get_enc_size();
-            names.push(name);
         }
         dbg!(names);
 
-        let unk1 = rdr.read_u32::<LittleEndian>()?;
+        let unk1 = sgd.read_u32()?;
-        cur += 4;
+        dbg!(unk1);
-        for _ in 0..N {
+        for _ in 0..n {
-            rdr.set_position(cur as u64);
+            let m = sgd.read_u32()?;
-            let M = rdr.read_u32::<LittleEndian>()?;
+            let mut replics: Vec<FString> = Vec::with_capacity(m as usize);
-            cur += 4;
+            for _ in 0..m {
-            dbg!(M, cur);
+                replics.push(sgd.read::<FString>(0)?);
-            let mut strings: Vec<FString> = Vec::new();
-            for _ in 0..M {
-                let str = FString::decode(&self.data, cur, 0)?;
-                cur += str.get_enc_size();
-                strings.push(str);
             }
-            dbg!(strings);
+            dbg!(replics);
         }
 
         Ok(())