mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 14:23:09 +00:00
0e37ff0d59
added adapter to AnyWriter and GenericWriter to help bridge the gap
between old and new API
make std.testing.expectFmt work at compile-time
std.fmt no longer has a dependency on std.unicode. Formatted printing
was never properly unicode-aware. Now it no longer pretends to be.
Breakage/deprecations:
* std.fs.File.reader -> std.fs.File.deprecatedReader
* std.fs.File.writer -> std.fs.File.deprecatedWriter
* std.io.GenericReader -> std.io.Reader
* std.io.GenericWriter -> std.io.Writer
* std.io.AnyReader -> std.io.Reader
* std.io.AnyWriter -> std.io.Writer
* std.fmt.format -> std.fmt.deprecatedFormat
* std.fmt.fmtSliceEscapeLower -> std.ascii.hexEscape
* std.fmt.fmtSliceEscapeUpper -> std.ascii.hexEscape
* std.fmt.fmtSliceHexLower -> {x}
* std.fmt.fmtSliceHexUpper -> {X}
* std.fmt.fmtIntSizeDec -> {B}
* std.fmt.fmtIntSizeBin -> {Bi}
* std.fmt.fmtDuration -> {D}
* std.fmt.fmtDurationSigned -> {D}
* {} -> {f} when there is a format method
* format method signature
- anytype -> *std.io.Writer
- inferred error set -> error{WriteFailed}
- options -> (deleted)
* std.fmt.Formatted
- now takes context type explicitly
- no fmt string
70 lines
2.1 KiB
Zig
70 lines
2.1 KiB
Zig
const Directory = @This();
|
|
const std = @import("../../std.zig");
|
|
const assert = std.debug.assert;
|
|
const fs = std.fs;
|
|
const fmt = std.fmt;
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
/// This field is redundant for operations that can act on the open directory handle
|
|
/// directly, but it is needed when passing the directory to a child process.
|
|
/// `null` means cwd.
|
|
path: ?[]const u8,
|
|
handle: fs.Dir,
|
|
|
|
pub fn clone(d: Directory, arena: Allocator) Allocator.Error!Directory {
|
|
return .{
|
|
.path = if (d.path) |p| try arena.dupe(u8, p) else null,
|
|
.handle = d.handle,
|
|
};
|
|
}
|
|
|
|
pub fn cwd() Directory {
|
|
return .{
|
|
.path = null,
|
|
.handle = fs.cwd(),
|
|
};
|
|
}
|
|
|
|
pub fn join(self: Directory, allocator: Allocator, paths: []const []const u8) ![]u8 {
|
|
if (self.path) |p| {
|
|
// TODO clean way to do this with only 1 allocation
|
|
const part2 = try fs.path.join(allocator, paths);
|
|
defer allocator.free(part2);
|
|
return fs.path.join(allocator, &[_][]const u8{ p, part2 });
|
|
} else {
|
|
return fs.path.join(allocator, paths);
|
|
}
|
|
}
|
|
|
|
pub fn joinZ(self: Directory, allocator: Allocator, paths: []const []const u8) ![:0]u8 {
|
|
if (self.path) |p| {
|
|
// TODO clean way to do this with only 1 allocation
|
|
const part2 = try fs.path.join(allocator, paths);
|
|
defer allocator.free(part2);
|
|
return fs.path.joinZ(allocator, &[_][]const u8{ p, part2 });
|
|
} else {
|
|
return fs.path.joinZ(allocator, paths);
|
|
}
|
|
}
|
|
|
|
/// Whether or not the handle should be closed, or the path should be freed
|
|
/// is determined by usage, however this function is provided for convenience
|
|
/// if it happens to be what the caller needs.
|
|
pub fn closeAndFree(self: *Directory, gpa: Allocator) void {
|
|
self.handle.close();
|
|
if (self.path) |p| gpa.free(p);
|
|
self.* = undefined;
|
|
}
|
|
|
|
pub fn format(self: Directory, writer: *std.io.Writer, comptime f: []const u8) std.io.Writer.Error!void {
|
|
comptime assert(f.len == 0);
|
|
if (self.path) |p| {
|
|
try writer.writeAll(p);
|
|
try writer.writeAll(fs.path.sep_str);
|
|
}
|
|
}
|
|
|
|
pub fn eql(self: Directory, other: Directory) bool {
|
|
return self.handle.fd == other.handle.fd;
|
|
}
|