lib/tldr/src/profiling/check/report/count.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const std = @import("std");
 2 
 3 const check = @import("../root.zig");
 4 
 5 const Allocator = check.model.Allocator;
 6 const Count = check.Count;
 7 const Result = check.model.Result;
 8 
 9 pub fn findResult(results: []const Result, case_name: []const u8, linker: []const u8) ?Result {
10     for (results) |result| {
11         if (std.mem.eql(u8, result.case, case_name) and std.mem.eql(u8, result.linker, linker)) return result;
12     }
13     return null;
14 }
15 
16 pub fn sortedResults(allocator: Allocator, results: []const Result) ![]Result {
17     const owned = try allocator.dupe(Result, results);
18     std.mem.sort(Result, owned, {}, resultLess);
19     return owned;
20 }
21 
22 fn resultLess(_: void, left: Result, right: Result) bool {
23     const case_order = std.mem.order(u8, left.case, right.case);
24     if (case_order != .eq) return case_order == .lt;
25     return std.mem.lessThan(u8, left.linker, right.linker);
26 }
27 
28 const CountField = enum {
29     status,
30     support,
31     product_stage,
32 };
33 
34 pub fn resultCounts(allocator: Allocator, results: []const Result, field: CountField) ![]Count {
35     var counts: std.ArrayList(Count) = .empty;
36     for (results) |result| {
37         const value = switch (field) {
38             .status => result.status,
39             .support => result.support,
40             .product_stage => result.product_stage,
41         };
42         try incrementCount(allocator, &counts, value);
43     }
44     const owned = try counts.toOwnedSlice(allocator);
45     std.mem.sort(Count, owned, {}, countLess);
46     return owned;
47 }
48 
49 fn incrementCount(allocator: Allocator, counts: *std.ArrayList(Count), name: []const u8) !void {
50     for (counts.items) |*count| {
51         if (std.mem.eql(u8, count.name, name)) {
52             count.count += 1;
53             return;
54         }
55     }
56     try counts.append(allocator, .{ .name = name, .count = 1 });
57 }
58 
59 fn countLess(_: void, left: Count, right: Count) bool {
60     return std.mem.lessThan(u8, left.name, right.name);
61 }
62 
63 pub fn countValue(counts: []const Count, name: []const u8) usize {
64     for (counts) |count| if (std.mem.eql(u8, count.name, name)) return count.count;
65     return 0;
66 }
67 
68 pub fn errorCount(results: []const Result) usize {
69     var count: usize = 0;
70     for (results) |result| {
71         if (!std.mem.eql(u8, result.status, "pass")) count += 1;
72     }
73     return count;
74 }
75 
76 test {
77     std.testing.refAllDecls(@This());
78 }