Share Oar path type with file system

src/engine/main.zig

@@ -15,7 +15,7 @@ fn run(app: *sys.AppContext, graphics: *sys.GraphicsContext) anyerror!void {
     defer _ = gpa.deinit();
 
     {
-        var file_access = try (try app.data().joinedPath(&.{"ona.lua"})).open(.readonly);
+        var file_access = try app.data().open(try sys.Path.joined(&.{"ona.lua"}), .readonly);
 
         defer file_access.close();
 

src/engine/sys.zig

@@ -273,13 +273,6 @@ pub const FileSystem = union(enum) {
     native: []const u8,
     archive: Archive,
 
-    ///
-    /// Platform-agnostic mechanism for referencing files and directories on a [FileSystem].
-    ///
-    pub const Path = struct {
-        file_system: *FileSystem,
-        path: oar.Path,
-
     ///
     /// With files typically being backed by a block device, they can produce a variety of
     /// errors - from physical to virtual errors - these are all encapsulated by the API as
@@ -303,11 +296,11 @@ pub const FileSystem = union(enum) {
     /// [OpenMode.readonly] indicates that an existing file is opened in a read-only state,
     /// disallowing write access.
     ///
-        /// [OpenMode.overwrite] indicates that an empty file has been created or an existing file
+    /// [OpenMode.overwrite] indicates that an empty file has been created or an existing file has
-        /// has been completely overwritten into.
+    /// been completely overwritten into.
     ///
-        /// [OpenMode.append] indicates that an existing file that has been opened for reading from
+    /// [OpenMode.append] indicates that an existing file that has been opened for reading from and
-        /// and writing to on the end of existing data.
+    /// writing to on the end of existing data.
     ///
     pub const OpenMode = enum {
         readonly,
@@ -316,38 +309,13 @@ pub const FileSystem = union(enum) {
     };
 
     ///
-        /// Returns `true` if the length of `path` is empty, otherwise `false`.
+    /// Attempts to open the file identified by `path` with `mode` as the mode for opening the file.
     ///
-        pub fn isEmpty(path: Path) bool {
+    /// Returns a [FileAccess] reference that provides access to the file referenced by `path`or a
-            return (path.length == 0);
+    /// [OpenError] if it failed.
-        }
-
     ///
-        /// Returns `true` if `this` is equal to `that`, otherwise `false`.
+    pub fn open(file_system: *FileSystem, path: Path, mode: OpenMode) OpenError!ona.io.FileAccess {
-        ///
+        switch (file_system.*) {
-        pub fn equals(this: Path, that: Path) bool {
-            return (this.file_system == that.file_system) and
-                std.mem.eql(u8, this.buffer[0 .. this.length], that.buffer[0 .. that.length]);
-        }
-
-        ///
-        /// The maximum possible byte-length of a [Path].
-        ///
-        /// Note that paths are encoded using UTF-8, meaning that a character may be bigger than one
-        /// byte. Because of this, it is not safe to asume that a path may hold [max] individual
-        /// characters.
-        ///
-        pub const max = 255;
-
-        ///
-        /// Attempts to open the file identified by `path` with `mode` as the mode for opening the
-        /// file.
-        ///
-        /// Returns a [FileAccess] reference that provides access to the file referenced by `path`
-        /// or a [OpenError] if it failed.
-        ///
-        pub fn open(path: Path, mode: OpenMode) OpenError!ona.io.FileAccess {
-            switch (path.file_system.*) {
             .archive => |*archive| {
                 if (mode != .readonly) return error.ModeUnsupported;
 
@@ -426,24 +394,29 @@ pub const FileSystem = union(enum) {
                         }
                     };
 
-                        if (archive.index_cache.lookup(path.path)) |index| {
+                    const Header = oar.Entry;
+
+                    if (archive.index_cache.lookup(path)) |index| {
                         archive.file_access.seek(index) catch return error.FileNotFound;
 
                         entry.* = .{
                             .owner = &archive.file_access,
                             .cursor = 0,
 
-                                .header = (oar.Entry.next(archive.file_access) catch return error.FileNotFound) orelse {
+                            .header = (Header.next(archive.file_access) catch
+                                return error.FileNotFound) orelse {
+
                                 // Remove cannot fail if lookup succeeded.
-                                    std.debug.assert(archive.index_cache.remove(path.path) != null);
+                                std.debug.assert(archive.index_cache.remove(path) != null);
 
                                 return error.FileNotFound;
                             },
                         };
                     } else {
-                            while (oar.Entry.next(archive.file_access) catch return error.FileNotFound) |entry_header| {
+                        while (Header.next(archive.file_access) catch
-                                if (entry.header.path.equals(path.path))
+                            return error.FileNotFound) |entry_header| {
-                                    entry.* = .{
+
+                            if (entry.header.path.equals(path)) entry.* = .{
                                 .owner = &archive.file_access,
                                 .cursor = 0,
                                 .header = entry_header,
@@ -475,19 +448,17 @@ pub const FileSystem = union(enum) {
                 if (native.len == 0) return error.FileNotFound;
 
                 var path_buffer = std.mem.zeroes([4096]u8);
-                    const seperator_length = @boolToInt(native[native.len - 1] != seperator);
+                const seperator_length = @boolToInt(native[native.len - 1] != oar.Path.seperator);
 
-                    if ((native.len + seperator_length + path.path.length) >=
+                if ((native.len + seperator_length + path.length) >=
                     path_buffer.len) return error.FileNotFound;
 
                 std.mem.copy(u8, path_buffer[0 ..], native);
 
-                    if (seperator_length != 0) path_buffer[native.len] = seperator;
+                if (seperator_length != 0) path_buffer[native.len] = oar.Path.seperator;
 
                 std.mem.copy(u8, path_buffer[native.len .. path_buffer.
-                        len], path.path.buffer[0 .. path.path.length]);
+                    len], path.buffer[0 .. path.length]);
-
-                    ext.SDL_ClearError();
 
                 const FileAccess = ona.io.FileAccess;
 
@@ -567,6 +538,8 @@ pub const FileSystem = union(enum) {
                     }
                 };
 
+                ext.SDL_ClearError();
+
                 return FileAccess{
                     .context = ext.SDL_RWFromFile(&path_buffer, switch (mode) {
                         .readonly => "rb",
@@ -587,67 +560,6 @@ pub const FileSystem = union(enum) {
             },
         }
     }
-
-        pub const seperator = '/';
-    };
-
-    ///
-    /// [PathError.TooLong] occurs when creating a path that is greater than the maximum size **in
-    /// bytes**.
-    ///
-    pub const PathError = error {
-        TooLong,
-    };
-
-    ///
-    /// Attempts to create a [Path] with `file_system` as the file-system root and the path
-    /// components in `sequences` as a fully qualified path from the root.
-    ///
-    /// A [Path] value is returned containing the fully qualified path from the file-system root or
-    /// a [PathError] if it could not be created.
-    ///
-    pub fn joinedPath(file_system: *FileSystem, sequences: []const []const u8) PathError!Path {
-        var path = Path{
-            .file_system = file_system,
-            .path = oar.Path.empty,
-        };
-
-        if (sequences.len != 0) {
-            const last_sequence_index = sequences.len - 1;
-
-            for (sequences) |sequence, index| if (sequence.len != 0) {
-                var components = ona.io.Spliterator(u8){
-                    .source = sequence,
-                    .delimiter = "/",
-                };
-
-                while (components.next()) |component| if (component.len != 0) {
-                    for (component) |byte| {
-                        if (path.path.length == Path.max) return error.TooLong;
-
-                        path.path.buffer[path.path.length] = byte;
-                        path.path.length += 1;
-                    }
-
-                    if (components.hasNext()) {
-                        if (path.path.length == Path.max) return error.TooLong;
-
-                        path.path.buffer[path.path.length] = '/';
-                        path.path.length += 1;
-                    }
-                };
-
-                if (index < last_sequence_index) {
-                    if (path.path.length == Path.max) return error.TooLong;
-
-                    path.path.buffer[path.path.length] = '/';
-                    path.path.length += 1;
-                }
-            };
-        }
-
-        return path;
-    }
 };
 
 ///
@@ -721,6 +633,11 @@ pub const Log = enum(u32) {
     }
 };
 
+///
+/// Path to a file on a [FileSystem].
+///
+pub const Path = oar.Path;
+
 ///
 /// [RunError.InitFailure] occurs if a necessary resource fails to be acquired or allocated.
 ///
@@ -774,7 +691,7 @@ pub fn runGraphics(comptime Error: anytype,
     defer ext.SDL_DestroyRenderer(renderer);
 
     var cwd_file_system = FileSystem{.native ="./"};
-    var data_access = try (try cwd_file_system.joinedPath(&.{"./data.oar"})).open(.readonly);
+    var data_access = try cwd_file_system.open(try Path.joined(&.{"./data.oar"}), .readonly);
 
     defer data_access.close();
 

src/oar/main.zig

@@ -55,6 +55,14 @@ pub const Path = extern struct {
     buffer: [255]u8,
     length: u8,
 
+    ///
+    /// [Error.TooLong] occurs when creating a path that is greater than the maximum path size **in
+    /// bytes**.
+    ///
+    pub const Error = error {
+        TooLong,
+    };
+
     ///
     /// An empty [Path] with a length of `0`.
     ///
@@ -74,6 +82,63 @@ pub const Path = extern struct {
     pub fn hash(path: Path) usize {
         return ona.io.hashBytes(path.buffer[0 .. path.length]);
     }
+
+    ///
+    /// Attempts to create a [Path] with the path components in `sequences` as a fully qualified
+    /// path from root.
+    ///
+    /// A [Path] value is returned containing the fully qualified path from the file-system root or
+    /// a [Error] if it could not be created.
+    ///
+    pub fn joined(sequences: []const []const u8) Error!Path {
+        var path = empty;
+
+        if (sequences.len != 0) {
+            const last_sequence_index = sequences.len - 1;
+
+            for (sequences) |sequence, index| if (sequence.len != 0) {
+                var components = ona.io.Spliterator(u8){
+                    .source = sequence,
+                    .delimiter = "/",
+                };
+
+                while (components.next()) |component| if (component.len != 0) {
+                    for (component) |byte| {
+                        if (path.length == max) return error.TooLong;
+
+                        path.buffer[path.length] = byte;
+                        path.length += 1;
+                    }
+
+                    if (components.hasNext()) {
+                        if (path.length == max) return error.TooLong;
+
+                        path.buffer[path.length] = '/';
+                        path.length += 1;
+                    }
+                };
+
+                if (index < last_sequence_index) {
+                    if (path.length == max) return error.TooLong;
+
+                    path.buffer[path.length] = '/';
+                    path.length += 1;
+                }
+            };
+        }
+
+        return path;
+    }
+
+    ///
+    /// Maximum number of **bytes** in a [Path].
+    ///
+    pub const max = 255;
+
+    ///
+    /// Textual separator between components of a [Path].
+    ///
+    pub const seperator = '/';
 };
 
 ///