next
After each call to this function, and on deinit(), the memory returned from this function becomes invalid. A copy must be made in order to keep a reference to the path.
Function parameters
Parameters
- self:*Walker
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
- default_mode
- = 0o755
Source
Implementation
pub fn next(self: *Walker) !?Walker.Entry {
const gpa = self.allocator;
while (self.stack.items.len != 0) {
// `top` and `containing` become invalid after appending to `self.stack`
var top = &self.stack.items[self.stack.items.len - 1];
var containing = top;
var dirname_len = top.dirname_len;
if (top.iter.next() catch |err| {
// If we get an error, then we want the user to be able to continue
// walking if they want, which means that we need to pop the directory
// that errored from the stack. Otherwise, all future `next` calls would
// likely just fail with the same error.
var item = self.stack.pop().?;
if (self.stack.items.len != 0) {
item.iter.dir.close();
}
return err;
}) |base| {
self.name_buffer.shrinkRetainingCapacity(dirname_len);
if (self.name_buffer.items.len != 0) {
try self.name_buffer.append(gpa, fs.path.sep);
dirname_len += 1;
}
try self.name_buffer.ensureUnusedCapacity(gpa, base.name.len + 1);
self.name_buffer.appendSliceAssumeCapacity(base.name);
self.name_buffer.appendAssumeCapacity(0);
if (base.kind == .directory) {
var new_dir = top.iter.dir.openDir(base.name, .{ .iterate = true }) catch |err| switch (err) {
error.NameTooLong => unreachable, // no path sep in base.name
else => |e| return e,
};
{
errdefer new_dir.close();
try self.stack.append(gpa, .{
.iter = new_dir.iterateAssumeFirstIteration(),
.dirname_len = self.name_buffer.items.len - 1,
});
top = &self.stack.items[self.stack.items.len - 1];
containing = &self.stack.items[self.stack.items.len - 2];
}
}
return .{
.dir = containing.iter.dir,
.basename = self.name_buffer.items[dirname_len .. self.name_buffer.items.len - 1 :0],
.path = self.name_buffer.items[0 .. self.name_buffer.items.len - 1 :0],
.kind = base.kind,
};
} else {
var item = self.stack.pop().?;
if (self.stack.items.len != 0) {
item.iter.dir.close();
}
}
}
return null;
}