mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 06:13:07 +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
56 lines
1.8 KiB
Zig
56 lines
1.8 KiB
Zig
const std = @import("../std.zig");
|
|
const mem = std.mem;
|
|
const fs = std.fs;
|
|
const File = std.fs.File;
|
|
|
|
pub const BufferedAtomicFile = struct {
|
|
atomic_file: fs.AtomicFile,
|
|
file_writer: File.Writer,
|
|
buffered_writer: BufferedWriter,
|
|
allocator: mem.Allocator,
|
|
|
|
pub const buffer_size = 4096;
|
|
pub const BufferedWriter = std.io.BufferedWriter(buffer_size, File.Writer);
|
|
pub const Writer = std.io.GenericWriter(*BufferedWriter, BufferedWriter.Error, BufferedWriter.write);
|
|
|
|
/// TODO when https://github.com/ziglang/zig/issues/2761 is solved
|
|
/// this API will not need an allocator
|
|
pub fn create(
|
|
allocator: mem.Allocator,
|
|
dir: fs.Dir,
|
|
dest_path: []const u8,
|
|
atomic_file_options: fs.Dir.AtomicFileOptions,
|
|
) !*BufferedAtomicFile {
|
|
var self = try allocator.create(BufferedAtomicFile);
|
|
self.* = BufferedAtomicFile{
|
|
.atomic_file = undefined,
|
|
.file_writer = undefined,
|
|
.buffered_writer = undefined,
|
|
.allocator = allocator,
|
|
};
|
|
errdefer allocator.destroy(self);
|
|
|
|
self.atomic_file = try dir.atomicFile(dest_path, atomic_file_options);
|
|
errdefer self.atomic_file.deinit();
|
|
|
|
self.file_writer = self.atomic_file.file.deprecatedWriter();
|
|
self.buffered_writer = .{ .unbuffered_writer = self.file_writer };
|
|
return self;
|
|
}
|
|
|
|
/// always call destroy, even after successful finish()
|
|
pub fn destroy(self: *BufferedAtomicFile) void {
|
|
self.atomic_file.deinit();
|
|
self.allocator.destroy(self);
|
|
}
|
|
|
|
pub fn finish(self: *BufferedAtomicFile) !void {
|
|
try self.buffered_writer.flush();
|
|
try self.atomic_file.finish();
|
|
}
|
|
|
|
pub fn writer(self: *BufferedAtomicFile) Writer {
|
|
return .{ .context = &self.buffered_writer };
|
|
}
|
|
};
|