Create recursive iterator

src/Tools/psxcdgen_ex/src/main.rs

@@ -6,12 +6,17 @@ fn populate() -> Result<CDDesc, Error> {
     let     file   = Data::new("Planschi.jpg")?;
     let     file2  = Data::new("Wuff.png")?;
     let     folder = {
-        let mut folder = Directory::new("Sub")?;
+        let mut folder     = Directory::new("Sub")?;
-        let     file   = Data::new("Schwimm.jpg")?;
+        let     sub_folder = {
-        let     file2  = Data::new("Miau.png")?;
+            let mut folder = Directory::new("SubSub")?;
 
-        folder.add_data(file);
+            folder.add_data(Data::new("Blubb.bin")?);
-        folder.add_data(file2);
+            folder
+        };
+
+        folder.add_dir(sub_folder);
+        folder.add_data(Data::new("Schwimm.jpg")?);
+        folder.add_data(Data::new("Miau.png")?);
         folder
     };
 
@@ -25,9 +30,8 @@ fn run_main() -> Result<(), Error> {
     fn dump_dir(dir: DirectoryIterator) {
         for element in dir {
             match element {
-                DirectoryIteratorElement::Root(root)     => println!("{}", root),
+                DirectoryIteratorElement::Directory(dir) => println!("{}", dir),
                 DirectoryIteratorElement::Data(data)     => println!("{}", data),
-                DirectoryIteratorElement::Directory(dir) => dump_dir(dir),
             }
         }
 

src/Tools/psxcdgen_ex/src/types/iterator.rs

@@ -18,7 +18,7 @@ impl<'a> std::iter::Iterator for DirectoryIterator<'a> {
         match std::mem::replace(&mut self.state, DirectoryIteratorState::Done) {
             DirectoryIteratorState::Root => {
                 self.state = DirectoryIteratorState::Data(self.parent.data.iter());
-                return Some(DirectoryIteratorElement::Root(&self.parent));
+                return Some(DirectoryIteratorElement::Directory(&self.parent));
             }
             DirectoryIteratorState::Data(mut iter) => {
                 if let Some(data) = iter.next() {
@@ -33,14 +33,25 @@ impl<'a> std::iter::Iterator for DirectoryIterator<'a> {
             },
             DirectoryIteratorState::Directory(mut iter) => {
                 if let Some(dir) = iter.next() {
-                    self.state = DirectoryIteratorState::Directory(iter);
+                    self.state = DirectoryIteratorState::SubDir((iter, std::boxed::Box::new(dir.iter())));
-                    return Some(DirectoryIteratorElement::Directory(dir.iter()));
+                    return self.next();
                 }
 
                 else {
                     return self.next();
                 }
             },
+            DirectoryIteratorState::SubDir((base_iter, mut iter)) => {
+                if let Some(element) = iter.next() {
+                    self.state = DirectoryIteratorState::SubDir((base_iter, iter));
+                    return Some(element);
+                }
+
+                else {
+                    self.state = DirectoryIteratorState::Directory(base_iter);
+                    return self.next();
+                }
+            },
             DirectoryIteratorState::Done => {
                 return None;
             }
@@ -52,11 +63,11 @@ enum DirectoryIteratorState<'a> {
     Root,
     Data(std::slice::Iter<'a, Data>),
     Directory(std::slice::Iter<'a, Directory>),
+    SubDir((std::slice::Iter<'a, Directory>, std::boxed::Box<DirectoryIterator<'a>>)),
     Done
 }
 
 pub enum DirectoryIteratorElement<'a> {
-    Root(&'a Directory),
+    Directory(&'a Directory),
     Data(&'a Data),
-    Directory(DirectoryIterator<'a>),
 }