pub const Slice = struct {
    /// This array is indexed by the field index which can be obtained
    /// by using @intFromEnum() on the Field enum
    ptrs: [fields.len][*]u8,
    len: usize,
    capacity: usize,

    pub const empty: Slice = .{
        .ptrs = undefined,
        .len = 0,
        .capacity = 0,
    };

    pub fn items(self: Slice, comptime field: Field) []FieldType(field) {
        const F = FieldType(field);
        if (self.capacity == 0) {
            return &[_]F{};
        }
        const byte_ptr = self.ptrs[@intFromEnum(field)];
        const casted_ptr: [*]F = if (@sizeOf(F) == 0)
            undefined
        else
            @ptrCast(@alignCast(byte_ptr));
        return casted_ptr[0..self.len];
    }

    pub fn set(self: *Slice, index: usize, elem: T) void {
        const e = switch (@typeInfo(T)) {
            .@"struct" => elem,
            .@"union" => Elem.fromT(elem),
            else => unreachable,
        };
        inline for (fields, 0..) |field_info, i| {
            self.items(@as(Field, @enumFromInt(i)))[index] = @field(e, field_info.name);
        }
    }

    pub fn get(self: Slice, index: usize) T {
        var result: Elem = undefined;
        inline for (fields, 0..) |field_info, i| {
            @field(result, field_info.name) = self.items(@as(Field, @enumFromInt(i)))[index];
        }
        return switch (@typeInfo(T)) {
            .@"struct" => result,
            .@"union" => Elem.toT(result.tags, result.data),
            else => unreachable,
        };
    }

    pub fn toMultiArrayList(self: Slice) Self {
        if (self.ptrs.len == 0 or self.capacity == 0) {
            return .{};
        }
        const unaligned_ptr = self.ptrs[sizes.fields[0]];
        const aligned_ptr: [*]align(@alignOf(Elem)) u8 = @alignCast(unaligned_ptr);
        return .{
            .bytes = aligned_ptr,
            .len = self.len,
            .capacity = self.capacity,
        };
    }

    pub fn deinit(self: *Slice, gpa: Allocator) void {
        var other = self.toMultiArrayList();
        other.deinit(gpa);
        self.* = undefined;
    }

    /// This function is used in the debugger pretty formatters in tools/ to fetch the
    /// child field order and entry type to facilitate fancy debug printing for this type.
    fn dbHelper(self: *Slice, child: *Elem, field: *Field, entry: *Entry) void {
        _ = self;
        _ = child;
        _ = field;
        _ = entry;
    }
}