Added some doc

src/file.zig

@@ -9,6 +9,8 @@ const Reader = @import("reader.zig").Reader;
 const DirEntry = @import("directory.zig").DirEntry;
 const MetadataReader = @import("readers/metadata.zig").MetadataReader;
 
+/// A file or directory inside of a squashfs.
+/// Make sure to call deinit();
 pub const File = struct {
     name: []const u8,
     inode: inode.Inode,
@@ -23,23 +25,25 @@ pub const File = struct {
         NotFound,
     };
 
-    fn fromDirEntry(read: *Reader, ent: DirEntry) !File {
-        var offset_rdr = read.holder.readerAt(ent.block_start + read.super.inode_table_start);
-        var meta_rdr: MetadataReader = try .init(
-            read.alloc,
+    fn fromDirEntry(reader: *Reader, ent: DirEntry) !File {
+        var offset_rdr = reader.holder.readerAt(ent.block_start + reader.super.inode_table_start);
+        var meta_rdr: MetadataReader = .init(
+            reader.alloc,
+            reader.super.decomp,
             offset_rdr.any(),
-            read.super.decomp,
         );
         defer meta_rdr.deinit();
         try meta_rdr.skip(ent.offset);
-        return .{
-            .name = ent.name,
+        const out: File = .{
+            .name = try reader.alloc.alloc(u8, ent.name.len),
             .inode = try .init(
-                read.alloc,
+                reader.alloc,
                 meta_rdr.any(),
-                read.super.block_size,
+                reader.super.block_size,
             ),
         };
+        std.mem.copyForwards(u8, @constCast(out.name), ent.name);
+        return out;
     }
 
     pub fn deinit(self: *File, alloc: std.mem.Allocator) void {
@@ -54,6 +58,14 @@ pub const File = struct {
         }
     }
 
+    pub fn isDir(self: File) bool {
+        return switch (self.inode.header.inode_type) {
+            .dir, .ext_dir => true,
+            else => false,
+        };
+    }
+
+    /// If the File is a directory, tries to return the file at path.
     pub fn open(self: *File, reader: *Reader, path: []const u8) !File {
         return self.realOpen(reader, path, true);
     }
@@ -79,6 +91,7 @@ pub const File = struct {
         return fil.realOpen(reader, clean_path[split_idx..], false);
     }
 
+    /// If the File is a symlink, returns the symlink's target path.
     pub fn symPath(self: File) ![]const u8 {
         return switch (self.inode.data) {
             .sym => |s| s.target,
@@ -87,11 +100,23 @@ pub const File = struct {
         };
     }
 
-    pub fn iterator(self: *File, read: *Reader) !FileIterator {
-        switch (self.inode.header.inode_type){
-            .dir, ext_dir => {}
+    /// If the File is a directory, returns an iterator that iterates over it's children.
+    pub fn iterator(self: *File, reader: *Reader) !FileIterator {
+        switch (self.inode.header.inode_type) {
+            .dir, .ext_dir => {},
             else => return FileError.NotDirectory,
         }
+        try self.readDirEntries(reader);
+        var files = try reader.alloc.alloc(File, self.dirEntries.?.count());
+        var dirEntryIter = self.dirEntries.?.valueIterator();
+        var i: u32 = 0;
+        while (dirEntryIter.next()) |ent| : (i += 1) {
+            files[i] = try .fromDirEntry(reader, ent.*);
+        }
+        return .{
+            .alloc = reader.alloc,
+            .files = files,
+        };
     }
 
     fn readDirEntries(self: *File, reader: *Reader) !void {
@@ -123,6 +148,7 @@ pub const File = struct {
         self.dirEntries = try directory.readDirectory(reader.alloc, meta_rdr.any(), size);
     }
 
+    /// If the file is a normal file, reads it's data.
     pub fn read(self: *File, bytes: []u8) !usize {
         if (self.data_rdr == null) {
             return FileError.NotNormalFile;
@@ -130,3 +156,25 @@ pub const File = struct {
         return self.data_rdr.?.read(bytes);
     }
 };
+
+const FileIterator = struct {
+    alloc: std.mem.Allocator,
+    files: []File,
+
+    curIndex: u32 = 0,
+
+    pub fn next(self: *FileIterator) ?File {
+        if (self.curIndex >= self.files.len) return null;
+        defer self.curIndex += 1;
+        return self.files[self.curIndex];
+    }
+    pub fn reset(self: *FileIterator) void {
+        self.curIndex = 0;
+    }
+    pub fn deinit(self: *FileIterator) void {
+        for (self.files) |*f| {
+            f.deinit(self.alloc);
+        }
+        self.alloc.free(self.files);
+    }
+};