generic metadata parsing

src/austin.zig

···
     multiprocess: bool = false,
     duration: usize = 0,
     gc: ?usize = null,
+
+    // Add metadata about which fields signal end of parsing
+    const EndFields = std.StaticStringMap(void).initComptime(.{
+        .{"duration"}, .{"gc"},
+    });
+
+    pub fn parseField(self: *Metadata, field_name: []const u8, value: []const u8) !bool {
+        // Returns true if this field signals end of parsing
+
+        // Use comptime reflection to generate parsing for each field
+        inline for (std.meta.fields(Metadata)) |field| {
+            if (std.mem.eql(u8, field_name, field.name)) {
+                const field_ptr = &@field(self, field.name);
+
+                switch (field.type) {
+                    std.SemanticVersion => {
+                        field_ptr.* = try std.SemanticVersion.parse(value);
+                    },
+                    usize => {
+                        field_ptr.* = try std.fmt.parseUnsigned(usize, value, 0);
+                    },
+                    bool => {
+                        field_ptr.* = std.mem.eql(u8, "on", value);
+                    },
+                    @TypeOf(self.mode) => {
+                        field_ptr.* = std.meta.stringToEnum(@TypeOf(self.mode), value) orelse return error.UnknownMetadataFieldValue;
+                    },
+                    ?usize => {
+                        field_ptr.* = try std.fmt.parseUnsigned(usize, value, 0);
+                    },
+                    else => @compileError("Unsupported metadata field type: " ++ @typeName(field.type)),
+                }
+
+                return EndFields.has(field.name);
+            }
+        }
+
+        return error.UnknownMetadataField;
+    }
 };
 
 const MetadataFields = std.meta.FieldEnum(Metadata);
···
                 const input = mem.trimStart(u8, line.items, "# ");
                 var it = mem.tokenizeScalar(u8, input, ':');
 
-                const key = std.meta.stringToEnum(
-                    MetadataFields,
-                    it.next() orelse return error.MissingKey,
-                ) orelse return error.UnknownMetadataField;
+                const key = it.next() orelse return error.MissingKey;
                 const value = mem.trimStart(u8, it.next() orelse return error.MissingValue, " ");
 
-                switch (key) {
-                    .austin => profile.meta.austin = try .parse(value),
-                    .interval => profile.meta.interval = try std.fmt.parseUnsigned(usize, value, 0),
-                    .memory => profile.meta.memory = try std.fmt.parseUnsigned(usize, value, 0),
-                    .mode => profile.meta.mode = std.meta.stringToEnum(
-                        @TypeOf(profile.meta.mode),
-                        value,
-                    ) orelse return error.UnknownMetadataFieldValue,
-                    .multiprocess => profile.meta.multiprocess = std.mem.eql(u8, "on", value),
-                    .duration => {
-                        profile.meta.duration = try std.fmt.parseUnsigned(usize, value, 0);
-                        reached_end = true;
-                    },
-                    .gc => {
-                        profile.meta.gc = try std.fmt.parseUnsigned(usize, value, 0);
-                        reached_end = true;
+                reached_end = profile.meta.parseField(key, value) catch |err| switch (err) {
+                    error.UnknownMetadataField => {
+                        log.warn("Unknown metadata field: {s}", .{key});
+                        continue;
                     },
-                }
+                    else => return err,
+                };
             } else {
                 // Sample
                 const sample = self.parseSample(line, line_num) catch |err| {