feat(anytype): add format

Author: RossComputerGuy

any+/anytype.zig

@@ -1,9 +1,13 @@
 const std = @import("std");
 const Self = @This();
 
+// TODO: use any-writer when it exists
+const PointerFormat = *const fn (*anyopaque, options: std.fmt.FormatOptions, std.io.FixedBufferStream(u8)) anyerror!void;
+
 type: []const u8,
 size: usize = 0,
 ptr: *anyopaque,
+ptrFormat: ?PointerFormat = null,
 
 /// Initializes a runtime anytype from a comptime anytype.
 pub inline fn init(value: anytype) Self {
@@ -13,11 +17,22 @@ pub inline fn init(value: anytype) Self {
 /// Explicitly initialize a runtime anytype to fit the type T.
 pub inline fn initExplicit(comptime T: type, value: T) Self {
     var size: usize = @sizeOf(T);
+    var ptrFormat: ?PointerFormat = null;
     const ptr: *anyopaque = switch (@typeInfo(T)) {
         .Int, .ComptimeInt => @ptrFromInt(value),
         .Float, .ComptimeFloat => @ptrFromInt(@as(usize, @bitCast(@as(f128, @floatCast(value))))),
         .Enum => @ptrFromInt(@intFromEnum(value)),
-        .Struct, .Union => @constCast(&value),
+        .Struct, .Union => blk: {
+            if (@hasDecl(T, "format")) {
+                ptrFormat = (struct {
+                    fn func(selfPointer: *anyopaque, options: std.fmt.FormatOptions, stream: std.io.FixedBufferStream(u8)) !void {
+                        const self: *T = @ptrCast(@alignCast(selfPointer));
+                        return self.format("", options, stream.writer());
+                    }
+                }).func;
+            }
+            break :blk @constCast(&value);
+        },
         .Pointer => |p| switch (@typeInfo(p.child)) {
             .Array => blk: {
                 size = value.len * @sizeOf(p.child);
@@ -32,6 +47,7 @@ pub inline fn initExplicit(comptime T: type, value: T) Self {
         .type = @typeName(T),
         .size = size,
         .ptr = ptr,
+        .ptrFormat = ptrFormat,
     };
 }
 
@@ -70,6 +86,34 @@ pub inline fn len(self: Self, comptime T: type) usize {
     return @divExact(self.size, size);
 }
 
+pub inline fn format(self: Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+    if (self.ptrFormat) |ptrFormat| {
+        const size = comptime if (std.mem.indexOf(u8, fmt, "%")) |sizeStart| std.fmt.parseInt(comptime_int, fmt[sizeStart..]) else 0x1000;
+
+        const trunc_msg = "(msg truncated)";
+        var buf: [size + trunc_msg.len]u8 = undefined;
+
+        const stream = std.io.fixedBufferStream(buf[0..size]);
+        ptrFormat(self.ptr, options, stream) catch |err| switch (err) {
+            error.NoSpaceLeft => blk: {
+                @memcpy(buf[size..], trunc_msg);
+                break :blk &buf;
+            },
+            else => return err,
+        };
+
+        try writer.writeAll(buf);
+    } else {
+        try writer.writeAll(@typeName(Self));
+        try writer.print("{{ .size = {}, .len = {}, .type = \"{s}\", .ptr = {*} }}", .{
+            self.size,
+            self.len(),
+            self.type,
+            self.ptr,
+        });
+    }
+}
+
 test "Casting integers and floats" {
     comptime var i: usize = 0;
     inline while (i < std.math.maxInt(u8)) : (i += 1) {