DoxigAlpha

openDirZ

Same as openDir except the parameter is null-terminated.

Function parameters

Parameters

#
sub_path_c:[*:0]const u8

Type definitions in this namespace

Types

#
SymLinkFlags
Use with `Dir.symLink`, `Dir.atomicSymLink`, and `symLinkAbsolute` to

Functions in this namespace

Functions

#
iterateAssumeFirstIteration
Like `iterate`, but will not reset the directory cursor before the first
walk
Recursively iterates over a directory.
openFile
Opens a file for reading or writing, without attempting to create a new file.
openFileZ
Same as `openFile` but the path parameter is null-terminated.
openFileW
Same as `openFile` but Windows-only and the path parameter is
createFile
Creates, opens, or overwrites a file with write access.
createFileZ
Same as `createFile` but the path parameter is null-terminated.
createFileW
Same as `createFile` but Windows-only and the path parameter is
makeDir
Creates a single directory with a relative or absolute path.
makeDirZ
Same as `makeDir`, but `sub_path` is null-terminated.
makeDirW
Creates a single directory with a relative or absolute null-terminated WTF-16 LE-encoded path.
makePath
Calls makeDir iteratively to make an entire path
makePathStatus
Same as `makePath` except returns whether the path already existed or was successfully created.
makeOpenPath
This function performs `makePath`, followed by `openDir`.
realpath
This function returns the canonicalized absolute pathname of
realpathZ
Same as `Dir.realpath` except `pathname` is null-terminated.
realpathW
Windows-only.
realpathAlloc
Same as `Dir.realpath` except caller must free the returned memory.
setAsCwd
Changes the current working directory to the open directory handle.
openDir
Opens a directory at the given path.
openDirZ
Same as `openDir` except the parameter is null-terminated.
openDirW
Same as `openDir` except the path parameter is WTF-16 LE encoded, NT-prefixed.
deleteFile
Delete a file name and possibly the file it refers to, based on an open directory handle.
deleteFileZ
Same as `deleteFile` except the parameter is null-terminated.
deleteFileW
Same as `deleteFile` except the parameter is WTF-16 LE encoded.
deleteDir
Returns `error.DirNotEmpty` if the directory is not empty.
deleteDirZ
Same as `deleteDir` except the parameter is null-terminated.
deleteDirW
Same as `deleteDir` except the parameter is WTF16LE, NT prefixed.
rename
Change the name or location of a file or directory.
renameZ
Same as `rename` except the parameters are null-terminated.
renameW
Same as `rename` except the parameters are WTF16LE, NT prefixed.
symLink
Creates a symbolic link named `sym_link_path` which contains the string `target_path`.
symLinkWasi
WASI-only.
symLinkZ
Same as `symLink`, except the pathname parameters are null-terminated.
symLinkW
Windows-only.
atomicSymLink
Same as `symLink`, except tries to create the symbolic link until it
readLink
Read value of a symbolic link.
readLinkWasi
WASI-only.
readLinkZ
Same as `readLink`, except the `sub_path_c` parameter is null-terminated.
readLinkW
Windows-only.
readFile
Read all of file contents using a preallocated buffer.
readFileAlloc
On success, caller owns returned buffer.
readFileAllocOptions
On success, caller owns returned buffer.
deleteTree
Whether `sub_path` describes a symlink, file, or directory, this function
deleteTreeMinStackSize
Like `deleteTree`, but only keeps one `Iterator` active at a time to minimize the function's stack size.
writeFile
Writes content to the file system, using the file creation flags provided.
access
Test accessing `sub_path`.
accessZ
Same as `access` except the path parameter is null-terminated.
accessW
Same as `access` except asserts the target OS is Windows and the path parameter is
updateFile
Check the file size, mtime, and mode of `source_path` and `dest_path`.
copyFile
Atomically creates a new file at `dest_path` within `dest_dir` with the
atomicFile
Directly access the `.file` field, and then call `AtomicFile.finish` to
statFile
Returns metadata for a file inside the directory.
chmod
Changes the mode of the directory.
chown
Changes the owner and group of the directory.
setPermissions
Sets permissions according to the provided `Permissions` struct.

Error sets in this namespace

Error Sets

#

= posix.fd_t

Values

#
Handle
= posix.fd_t

Source

Implementation

#
pub fn openDirZ(self: Dir, sub_path_c: [*:0]const u8, args: OpenOptions) OpenError!Dir {
    switch (native_os) {
        .windows => {
            const sub_path_w = try windows.cStrToPrefixedFileW(self.fd, sub_path_c);
            return self.openDirW(sub_path_w.span().ptr, args);
        },
        // Use the libc API when libc is linked because it implements things
        // such as opening absolute directory paths.
        .wasi => if (!builtin.link_libc) {
            return openDir(self, mem.sliceTo(sub_path_c, 0), args);
        },
        .haiku => {
            const rc = posix.system._kern_open_dir(self.fd, sub_path_c);
            if (rc >= 0) return .{ .fd = rc };
            switch (@as(posix.E, @enumFromInt(rc))) {
                .FAULT => unreachable,
                .INVAL => unreachable,
                .BADF => unreachable,
                .ACCES => return error.AccessDenied,
                .LOOP => return error.SymLinkLoop,
                .MFILE => return error.ProcessFdQuotaExceeded,
                .NAMETOOLONG => return error.NameTooLong,
                .NFILE => return error.SystemFdQuotaExceeded,
                .NODEV => return error.NoDevice,
                .NOENT => return error.FileNotFound,
                .NOMEM => return error.SystemResources,
                .NOTDIR => return error.NotDir,
                .PERM => return error.PermissionDenied,
                .BUSY => return error.DeviceBusy,
                else => |err| return posix.unexpectedErrno(err),
            }
        },
        else => {},
    }

    var symlink_flags: posix.O = switch (native_os) {
        .wasi => .{
            .read = true,
            .NOFOLLOW = args.no_follow,
            .DIRECTORY = true,
        },
        else => .{
            .ACCMODE = .RDONLY,
            .NOFOLLOW = args.no_follow,
            .DIRECTORY = true,
            .CLOEXEC = true,
        },
    };

    if (@hasField(posix.O, "PATH") and !args.iterate)
        symlink_flags.PATH = true;

    return self.openDirFlagsZ(sub_path_c, symlink_flags);
}