tiny.simd.AlignedVector

1pub fn Vector(comptime T: type) type {2    return struct {3        storage: ?Allocation(T) = null,4        len_value: usize = 0,56        const Self = @This();78        pub fn init(9            allocator: std.mem.Allocator,10            initial: []const T,11        ) Error!Self {12            var self = try initCapacity(allocator, initial.len);13            if (initial.len != 0) {14                @memcpy(self.storage.?.values[0..initial.len], initial);15                self.len_value = initial.len;16            }17            return self;18        }1920        pub fn initCapacity(21            allocator: std.mem.Allocator,22            capacity_value: usize,23        ) Error!Self {24            if (capacity_value == 0) return .{};25            return .{ .storage = try Allocation(T).init(allocator, capacity_value) };26        }2728        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {29            if (self.storage) |*storage| storage.deinit(allocator);30            self.* = .{};31        }3233        pub fn len(self: *const Self) usize {34            return self.len_value;35        }3637        pub fn capacity(self: *const Self) usize {38            return if (self.storage) |storage| storage.values.len else 0;39        }4041        pub fn items(self: *Self) []T {42            if (self.storage) |*storage| return storage.values[0..self.len_value];43            return @constCast((&[_]T{})[0..]);44        }4546        pub fn constItems(self: *const Self) []const T {47            if (self.storage) |*storage| return storage.values[0..self.len_value];48            return &.{};49        }5051        pub fn append(52            self: *Self,53            allocator: std.mem.Allocator,54            value: T,55        ) Error!void {56            const required = std.math.add(usize, self.len_value, 1) catch57                return error.AllocationSizeOverflow;58            try self.ensureTotalCapacity(allocator, required);59            self.storage.?.values[self.len_value] = value;60            self.len_value += 1;61        }6263        pub fn appendSlice(64            self: *Self,65            allocator: std.mem.Allocator,66            values: []const T,67        ) Error!void {68            if (values.len == 0) return;69            const required = std.math.add(usize, self.len_value, values.len) catch70                return error.AllocationSizeOverflow;71            try self.ensureTotalCapacity(allocator, required);72            @memcpy(self.storage.?.values[self.len_value..required], values);73            self.len_value = required;74        }7576        pub fn pop(self: *Self) ?T {77            if (self.len_value == 0) return null;78            self.len_value -= 1;79            return self.storage.?.values[self.len_value];80        }8182        pub fn clearRetainingCapacity(self: *Self) void {83            self.len_value = 0;84        }8586        pub fn ensureTotalCapacity(87            self: *Self,88            allocator: std.mem.Allocator,89            required: usize,90        ) Error!void {91            const current_capacity = self.capacity();92            if (required <= current_capacity) return;93            const grown = std.math.mul(usize, current_capacity, 2) catch required;94            const new_capacity = @max(required, @max(@as(usize, 8), grown));95            var replacement = try Allocation(T).init(allocator, new_capacity);96            if (self.storage) |*storage| {97                @memcpy(replacement.values[0..self.len_value], storage.values[0..self.len_value]);98                storage.deinit(allocator);99            }100            self.storage = replacement;101        }102    };103}

1pub const AlignedVector = aligned.Vector;