From a425b89a4f5156aaf6bf167dcb0b5651d57efc17 Mon Sep 17 00:00:00 2001 From: kcbanner Date: Sat, 19 Jul 2025 15:46:47 -0400 Subject: [PATCH] - Remove usingnamespace usage - Update to latest build API --- .gitignore | 4 +- build.zig | 13 ++- src/sparse_set.zig | 194 ++++++++++++++++++++++++--------------------- 3 files changed, 116 insertions(+), 95 deletions(-) diff --git a/.gitignore b/.gitignore index 24ada04..7166bfe 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ -zig-cache/ -docs/ \ No newline at end of file +.zig-cache/ +docs/ diff --git a/build.zig b/build.zig index a6f74cf..15af6d0 100644 --- a/build.zig +++ b/build.zig @@ -9,9 +9,11 @@ pub fn build(b: *std.Build) void { const mode_str = @tagName(test_mode); const tests = b.addTest(.{ .name = mode_str ++ " ", - .root_source_file = b.path("src/test.zig"), - .target = target, - .optimize = test_mode, + .root_module = b.createModule(.{ + .root_source_file = b.path("src/test.zig"), + .target = target, + .optimize = test_mode, + }), }); const run_test_step = b.addRunArtifact(tests); @@ -21,7 +23,10 @@ pub fn build(b: *std.Build) void { } const tests = b.addTest(.{ - .root_source_file = b.path("src/sparse_set.zig"), + .root_module = b.createModule(.{ + .root_source_file = b.path("src/sparse_set.zig"), + .target = target, + }), }); const install_docs = b.addInstallDirectory(.{ diff --git a/src/sparse_set.zig b/src/sparse_set.zig index b613ca0..989a6bb 100644 --- a/src/sparse_set.zig +++ b/src/sparse_set.zig @@ -167,16 +167,14 @@ pub fn SparseSet(comptime config: SparseSetConfig) type { return self.dense_to_sparse[0..self.dense_count]; } - // A bit of a hack to comptime add a function - // TODO: Rewrite after https://github.com/ziglang/zig/issues/1717 - pub usingnamespace switch (value_layout) { - .InternalArrayOfStructs => struct { - /// Returns a slice that can be used to loop over the values. - pub fn toValueSlice(self: Self) []ValueT { - return self.values[0..self.dense_count]; - } - }, - else => struct {}, + /// Returns a slice that can be used to loop over the values. + fn _toValueSlice(self: Self) []ValueT { + return self.values[0..self.dense_count]; + } + + pub const toValueSlice = switch (value_layout) { + .InternalArrayOfStructs => _toValueSlice, + else => {}, }; /// Returns how many dense indices are still available @@ -239,62 +237,66 @@ pub fn SparseSet(comptime config: SparseSetConfig) type { return self.add(sparse); } - // TODO: Rewrite after https://github.com/ziglang/zig/issues/1717 - pub usingnamespace switch (value_layout) { - .InternalArrayOfStructs => struct { - /// Registers the sparse value and matches it to a dense index - /// Grows .dense_to_sparse and .values if needed and resizing is allowed. - /// Note: If resizing is allowed, you must use an allocator that you are sure - /// will never fail for your use cases. - /// If that is not an option, use addOrError. - pub fn addValue(self: *Self, sparse: SparseT, value: ValueT) DenseT { - if (allow_resize == .ResizeAllowed) { - if (self.dense_count == self.capacity_dense) { - self.capacity_dense = self.capacity_dense * 2; - self.dense_to_sparse = self.allocator.realloc(self.dense_to_sparse, self.capacity_dense) catch unreachable; - if (value_layout == .InternalArrayOfStructs) { - self.values = self.allocator.realloc(self.values, self.capacity_dense) catch unreachable; - } - } + /// Registers the sparse value and matches it to a dense index + /// Grows .dense_to_sparse and .values if needed and resizing is allowed. + /// Note: If resizing is allowed, you must use an allocator that you are sure + /// will never fail for your use cases. + /// If that is not an option, use addOrError. + fn _addValue(self: *Self, sparse: SparseT, value: ValueT) DenseT { + if (allow_resize == .ResizeAllowed) { + if (self.dense_count == self.capacity_dense) { + self.capacity_dense = self.capacity_dense * 2; + self.dense_to_sparse = self.allocator.realloc(self.dense_to_sparse, self.capacity_dense) catch unreachable; + if (value_layout == .InternalArrayOfStructs) { + self.values = self.allocator.realloc(self.values, self.capacity_dense) catch unreachable; } - - assert(sparse < self.capacity_sparse); - assert(self.dense_count < self.capacity_dense); - assert(!self.hasSparse(sparse)); - self.dense_to_sparse[self.dense_count] = sparse; - self.sparse_to_dense[sparse] = @intCast(self.dense_count); - self.values[self.dense_count] = value; - self.dense_count += 1; - return @intCast(self.dense_count - 1); } + } - /// May return error.OutOfBounds or error.AlreadyRegistered, otherwise calls add. - /// Grows .dense_to_sparse and .values if needed and resizing is allowed. - pub fn addValueOrError(self: *Self, sparse: SparseT, value: ValueT) !DenseT { - if (sparse >= self.capacity_sparse) { - return error.OutOfBounds; - } + assert(sparse < self.capacity_sparse); + assert(self.dense_count < self.capacity_dense); + assert(!self.hasSparse(sparse)); + self.dense_to_sparse[self.dense_count] = sparse; + self.sparse_to_dense[sparse] = @intCast(self.dense_count); + self.values[self.dense_count] = value; + self.dense_count += 1; + return @intCast(self.dense_count - 1); + } - if (try self.hasSparseOrError(sparse)) { - return error.AlreadyRegistered; - } + pub const addValue = switch (value_layout) { + .InternalArrayOfStructs => _addValue, + else => {}, + }; - if (self.dense_count == self.capacity_dense) { - if (allow_resize == .ResizeAllowed) { - self.capacity_dense = self.capacity_dense * 2; - self.dense_to_sparse = try self.allocator.realloc(self.dense_to_sparse, self.capacity_dense); - if (value_layout == .InternalArrayOfStructs) { - self.values = try self.allocator.realloc(self.values, self.capacity_dense); - } - } else { - return error.OutOfBounds; - } - } + /// May return error.OutOfBounds or error.AlreadyRegistered, otherwise calls add. + /// Grows .dense_to_sparse and .values if needed and resizing is allowed. + fn _addValueOrError(self: *Self, sparse: SparseT, value: ValueT) !DenseT { + if (sparse >= self.capacity_sparse) { + return error.OutOfBounds; + } - return self.addValue(sparse, value); + if (try self.hasSparseOrError(sparse)) { + return error.AlreadyRegistered; + } + + if (self.dense_count == self.capacity_dense) { + if (allow_resize == .ResizeAllowed) { + self.capacity_dense = self.capacity_dense * 2; + self.dense_to_sparse = try self.allocator.realloc(self.dense_to_sparse, self.capacity_dense); + if (value_layout == .InternalArrayOfStructs) { + self.values = try self.allocator.realloc(self.values, self.capacity_dense); + } + } else { + return error.OutOfBounds; } - }, - else => struct {}, + } + + return self.addValue(sparse, value); + } + + pub const addValueOrError = switch (value_layout) { + .InternalArrayOfStructs => _addValueOrError, + else => {}, }; /// Removes the sparse/dense index, and replaces it with the last ones. @@ -406,39 +408,53 @@ pub fn SparseSet(comptime config: SparseSetConfig) type { return self.getByDense(dense); } - // TODO: Rewrite after https://github.com/ziglang/zig/issues/1717 - pub usingnamespace switch (value_layout) { - .InternalArrayOfStructs => struct { - /// Returns a pointer to the SOA value corresponding to the sparse parameter. - pub fn getValueBySparse(self: Self, sparse: SparseT) *ValueT { - assert(self.hasSparse(sparse)); - const dense = self.sparse_to_dense[sparse]; - return &self.values[dense]; - } + /// Returns a pointer to the SOA value corresponding to the sparse parameter. + fn _getValueBySparse(self: Self, sparse: SparseT) *ValueT { + assert(self.hasSparse(sparse)); + const dense = self.sparse_to_dense[sparse]; + return &self.values[dense]; + } - /// First tries hasSparse, then returns getValueBySparse(). - pub fn getValueBySparseOrError(self: Self, sparse: SparseT) !*ValueT { - if (!try self.hasSparseOrError(sparse)) { - return error.NotRegistered; - } - return self.getValueBySparse(sparse); - } + pub const getValueBySparse = switch (value_layout) { + .InternalArrayOfStructs => _getValueBySparse, + else => {}, + }; - /// Returns a pointer to the SOA value corresponding to the sparse parameter. - pub fn getValueByDense(self: Self, dense: DenseT) *ValueT { - assert(dense < self.dense_count); - return &self.values[dense]; - } + /// First tries hasSparse, then returns getValueBySparse(). + fn _getValueBySparseOrError(self: Self, sparse: SparseT) !*ValueT { + if (!try self.hasSparseOrError(sparse)) { + return error.NotRegistered; + } + return self.getValueBySparse(sparse); + } - /// Returns error.OutOfBounds or getValueByDense(). - pub fn getValueByDenseOrError(self: Self, dense: DenseT) !*ValueT { - if (dense >= self.dense_count) { - return error.OutOfBounds; - } - return self.getValueByDense(dense); - } - }, - else => struct {}, + pub const getValueBySparseOrError = switch (value_layout) { + .InternalArrayOfStructs => _getValueBySparseOrError, + else => {}, + }; + + /// Returns a pointer to the SOA value corresponding to the sparse parameter. + fn _getValueByDense(self: Self, dense: DenseT) *ValueT { + assert(dense < self.dense_count); + return &self.values[dense]; + } + + pub const getValueByDense = switch (value_layout) { + .InternalArrayOfStructs => _getValueByDense, + else => {}, + }; + + /// Returns error.OutOfBounds or getValueByDense(). + fn _getValueByDenseOrError(self: Self, dense: DenseT) !*ValueT { + if (dense >= self.dense_count) { + return error.OutOfBounds; + } + return self.getValueByDense(dense); + } + + pub const getValueByDenseOrError = switch (value_layout) { + .InternalArrayOfStructs => _getValueByDenseOrError, + else => {}, }; }; }