@pkmn/engine 0.1.0-dev.ce4c0b2a → 0.1.0-dev.d127cb34

package/src/lib/common/util.zig

@@ -3,10 +3,13 @@ const std = @import("std");
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
-const Pointer = if (@hasField(std.builtin.Type, "pointer")) .pointer else .Pointer;
-
 pub fn PointerType(comptime P: type, comptime C: type) type {
-    return if (@field(@typeInfo(P), @tagName(Pointer)).is_const) *const C else *C;
+    const ptr_info = @typeInfo(P).pointer;
+    const is_const = if (@hasField(@TypeOf(ptr_info), "attrs"))
+        ptr_info.attrs.@"const"
+    else
+        ptr_info.is_const;
+    return if (is_const) *const C else *C;
 }
 
 test PointerType {
@@ -14,10 +17,25 @@ test PointerType {
     try expectEqual(*const f64, PointerType(*const i32, f64));
 }
 
+pub fn EnumFieldsLen(comptime E: type) usize {
+    const info = @typeInfo(E).@"enum";
+    return if (@hasField(@TypeOf(info), "fields"))
+        info.fields.len
+    else
+        info.field_names.len;
+}
+
+test EnumFieldsLen {
+    const E1 = enum { A, B, C };
+    const E2 = enum(u8) { A = 0, B = 10, C = 20, D = 30 };
+    try expectEqual(3, EnumFieldsLen(E1));
+    try expectEqual(4, EnumFieldsLen(E2));
+}
+
 pub fn isPointerTo(p: anytype, comptime P: type) bool {
     const info = @typeInfo(@TypeOf(p));
     return switch (info) {
-        Pointer => @field(info, @tagName(Pointer)).child == P,
+        .pointer => info.pointer.child == P,
         else => false,
     };
 }
@@ -29,33 +47,18 @@ test isPointerTo {
     try expect(isPointerTo(&s, S));
 }
 
-// NOTE: std.mem.bytesAsValue backported from ziglang/zig#18061
-pub fn bytesAsValue(comptime T: type, bytes: anytype) BytesAsValueReturnType(T, @TypeOf(bytes)) {
-    return @as(BytesAsValueReturnType(T, @TypeOf(bytes)), @ptrCast(bytes));
-}
+pub fn repeat(comptime xs: anytype, comptime n: usize) [xs.len * n]@TypeOf(xs[0]) {
+    comptime {
+        const T = @TypeOf(xs[0]);
+        var ts: [xs.len * n]T = undefined;
 
-fn BytesAsValueReturnType(comptime T: type, comptime B: type) type {
-    return CopyPtrAttrs(B, .One, T);
-}
+        var i: usize = 0;
+        while (i < n) : (i += 1) {
+            for (xs, 0..) |v, j| {
+                ts[i * xs.len + j] = v;
+            }
+        }
 
-fn CopyPtrAttrs(
-    comptime source: type,
-    comptime size: std.builtin.Type.Pointer.Size,
-    comptime child: type,
-) type {
-    const info = @field(@typeInfo(source), @tagName(Pointer));
-    const args = .{
-        .size = size,
-        .is_const = info.is_const,
-        .is_volatile = info.is_volatile,
-        .is_allowzero = info.is_allowzero,
-        .alignment = info.alignment,
-        .address_space = info.address_space,
-        .child = child,
-        .sentinel = null,
-    };
-    return @Type(if (@hasField(std.builtin.Type, "pointer"))
-        .{ .pointer = args }
-    else
-        .{ .Pointer = args });
+        return ts;
+    }
 }