authorgravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2025-06-02 02:37:19 -07:00
committergravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2025-06-02 02:37:19 -07:00
log94af3029c54900384512739110423f2ca9a0e317
treed6058a293a8cb4a65d13cb3a2fc920de44e2018a
parente7ae48cfacb0510ba610e72a9bb064e675e943ea

make fmtByteCountIEC and reduceNumber use a writer instead of allocator

2 files changed, 31 insertions(+), 33 deletions(-)

src/fmtByteCountIEC.zig+12-18
......@@ -3,31 +3,25 @@ const string = []const u8;
33const extras = @import("./lib.zig");
44const reduceNumber = extras.reduceNumber;
55
6pub fn fmtByteCountIEC(alloc: std.mem.Allocator, b: u64) !string {
7 return try reduceNumber(alloc, b, 1024, "B", "KMGTPEZYRQ");
6pub fn fmtByteCountIEC(b: u64) std.fmt.Formatter(formatByteCountIEC) {
7 return .{ .data = b };
8}
9
10fn formatByteCountIEC(bytes: u64, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
11 _ = fmt;
12 _ = options;
13 try reduceNumber(writer, bytes, 1024, "B", "KMGTPEZYRQ");
814}
915
1016test {
11 const allocator = std.testing.allocator;
12 const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 0));
13 defer allocator.free(actual);
14 try std.testing.expect(std.mem.eql(u8, actual, "1 B"));
17 try std.testing.expectFmt("1 B", "{}", .{fmtByteCountIEC(std.math.pow(u64, 1024, 0))});
1518}
1619test {
17 const allocator = std.testing.allocator;
18 const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 1));
19 defer allocator.free(actual);
20 try std.testing.expect(std.mem.eql(u8, actual, "1.000 KB"));
20 try std.testing.expectFmt("1.000 KB", "{}", .{fmtByteCountIEC(std.math.pow(u64, 1024, 1))});
2121}
2222test {
23 const allocator = std.testing.allocator;
24 const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 2));
25 defer allocator.free(actual);
26 try std.testing.expect(std.mem.eql(u8, actual, "1.000 MB"));
23 try std.testing.expectFmt("1.000 MB", "{}", .{fmtByteCountIEC(std.math.pow(u64, 1024, 2))});
2724}
2825test {
29 const allocator = std.testing.allocator;
30 const actual = try fmtByteCountIEC(allocator, std.math.pow(u64, 1024, 3));
31 defer allocator.free(actual);
32 try std.testing.expect(std.mem.eql(u8, actual, "1.000 GB"));
26 try std.testing.expectFmt("1.000 GB", "{}", .{fmtByteCountIEC(std.math.pow(u64, 1024, 3))});
3327}
src/reduceNumber.zig+19-15
......@@ -2,9 +2,9 @@ const std = @import("std");
22const string = []const u8;
33const extras = @import("./lib.zig");
44
5pub fn reduceNumber(alloc: std.mem.Allocator, input: u64, comptime unit: u64, comptime base: string, comptime prefixes: string) !string {
5pub fn reduceNumber(writer: anytype, input: u64, comptime unit: u64, comptime base: string, comptime prefixes: string) !void {
66 if (input < unit) {
7 return std.fmt.allocPrint(alloc, "{d} {s}", .{ input, base });
7 return try writer.print("{d} {s}", .{ input, base });
88 }
99 var div = unit;
1010 var exp: usize = 0;
......@@ -16,30 +16,34 @@ pub fn reduceNumber(alloc: std.mem.Allocator, input: u64, comptime unit: u64, co
1616 }
1717 const input_f: f64 = @floatFromInt(input);
1818 const div_f: f64 = @floatFromInt(div);
19 return try std.fmt.allocPrint(alloc, "{d:.3} {s}{s}", .{ input_f / div_f, prefixes[exp..][0..1], base });
19 return try writer.print("{d:.3} {s}{s}", .{ input_f / div_f, prefixes[exp..][0..1], base });
2020}
2121
2222test {
2323 const allocator = std.testing.allocator;
24 const actual = try reduceNumber(allocator, 1, 60, "s", "mh");
25 defer allocator.free(actual);
26 try std.testing.expect(std.mem.eql(u8, actual, "1 s"));
24 var list = std.ArrayList(u8).init(allocator);
25 defer list.deinit();
26 try reduceNumber(list.writer(), 1, 60, "s", "mh");
27 try std.testing.expect(std.mem.eql(u8, list.items, "1 s"));
2728}
2829test {
2930 const allocator = std.testing.allocator;
30 const actual = try reduceNumber(allocator, 60, 60, "s", "mh");
31 defer allocator.free(actual);
32 try std.testing.expect(std.mem.eql(u8, actual, "1.000 ms"));
31 var list = std.ArrayList(u8).init(allocator);
32 defer list.deinit();
33 try reduceNumber(list.writer(), 60, 60, "s", "mh");
34 try std.testing.expect(std.mem.eql(u8, list.items, "1.000 ms"));
3335}
3436test {
3537 const allocator = std.testing.allocator;
36 const actual = try reduceNumber(allocator, 3600, 60, "s", "mh");
37 defer allocator.free(actual);
38 try std.testing.expect(std.mem.eql(u8, actual, "1.000 hs"));
38 var list = std.ArrayList(u8).init(allocator);
39 defer list.deinit();
40 try reduceNumber(list.writer(), 3600, 60, "s", "mh");
41 try std.testing.expect(std.mem.eql(u8, list.items, "1.000 hs"));
3942}
4043test {
4144 const allocator = std.testing.allocator;
42 const actual = try reduceNumber(allocator, 216000, 60, "s", "mh");
43 defer allocator.free(actual);
44 try std.testing.expect(std.mem.eql(u8, actual, "60.000 hs"));
45 var list = std.ArrayList(u8).init(allocator);
46 defer list.deinit();
47 try reduceNumber(list.writer(), 216000, 60, "s", "mh");
48 try std.testing.expect(std.mem.eql(u8, list.items, "60.000 hs"));
4549}