147 lines
3.6 KiB
Zig
Executable File
147 lines
3.6 KiB
Zig
Executable File
const debug = @import("./debug.zig");
|
|
|
|
const io = @import("./io.zig");
|
|
|
|
const math = @import("./math.zig");
|
|
|
|
const stack = @import("./stack.zig");
|
|
|
|
pub fn Dense(comptime key: Key, comptime Element: type) type {
|
|
const KeySlot = Slot(key);
|
|
const Index = math.Unsigned(key.index_bits);
|
|
|
|
return struct {
|
|
capacity: usize = 0,
|
|
values: []Element = &.{},
|
|
slots: ?[*]KeySlot = null,
|
|
erase: ?[*]Index = null,
|
|
next_free: Index = 0,
|
|
|
|
const Self = @This();
|
|
|
|
pub fn fetch(self: Self, slot: KeySlot) ?*Element {
|
|
if (slot.index >= self.values.len) {
|
|
return null;
|
|
}
|
|
|
|
const redirect = &self.slots[slot.index];
|
|
|
|
if (slot.salt != redirect.salt) {
|
|
return null;
|
|
}
|
|
|
|
return &self.values[redirect.index];
|
|
}
|
|
|
|
pub fn clear(self: *Self) void {
|
|
self.next_free = 0;
|
|
self.values = self.values[0 .. 0];
|
|
|
|
{
|
|
var index = @as(usize, 0);
|
|
|
|
while (index < self.capacity) : (index += 1) {
|
|
const slot = &self.slots[index];
|
|
|
|
slot.salt = math.max(slot.salt +% 1, 1);
|
|
slot.index = index;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn deinit(self: *Self, allocator: io.Allocator) void {
|
|
io.deallocate(allocator, self.values.ptr);
|
|
io.deallocate(allocator, self.slots);
|
|
io.deallocate(allocator, self.erase);
|
|
}
|
|
|
|
pub fn grow(self: *Self, allocator: io.Allocator, growth_amount: usize) io.AllocationError!void {
|
|
const grown_capacity = self.capacity + growth_amount;
|
|
|
|
self.values = try io.reallocate(allocator, self.values, grown_capacity);
|
|
self.slots = (try io.reallocate(allocator, self.slots.?[0 .. self.values.len], grown_capacity)).ptr;
|
|
self.erase = (try io.reallocate(allocator, self.erase.?[0 .. self.values.len], grown_capacity)).ptr;
|
|
self.capacity = grown_capacity;
|
|
|
|
// Add new values to the freelist
|
|
{
|
|
var index = @intCast(Index, self.values.len);
|
|
|
|
while (index < self.capacity) : (index += 1) {
|
|
const slot = &self.slots.?[index];
|
|
|
|
slot.salt = 1;
|
|
slot.index = index;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn insert(self: *Self, allocator: io.Allocator, value: Element) io.AllocationError!KeySlot {
|
|
if (self.values.len == self.capacity) {
|
|
try self.grow(allocator, math.max(usize, 1, self.capacity));
|
|
}
|
|
|
|
const index_of_redirect = self.next_free;
|
|
const redirect = &self.slots.?[index_of_redirect];
|
|
|
|
// redirect.index points to the next free slot.
|
|
self.next_free = redirect.index;
|
|
redirect.index = @intCast(Index, self.values.len);
|
|
self.values = self.values.ptr[0 .. self.values.len + 1];
|
|
self.values[redirect.index] = value;
|
|
self.erase.?[redirect.index] = index_of_redirect;
|
|
|
|
return KeySlot{
|
|
.index = index_of_redirect,
|
|
.salt = redirect.salt,
|
|
};
|
|
}
|
|
|
|
pub fn remove(self: *Self, slot: KeySlot) bool {
|
|
const redirect = &self.slots[slot.index];
|
|
|
|
if (slot.salt != redirect.salt) {
|
|
return false;
|
|
}
|
|
|
|
const free_index = redirect.index;
|
|
|
|
self.values = self.values[0 .. (self.values.len - 1)];
|
|
|
|
if (self.values.len > 0) {
|
|
const free_data = &self.data[free_index];
|
|
const free_erase = &self.erase[free_index];
|
|
const last_data = &self.data[self.values.len];
|
|
const last_erase = &self.erase[self.values.len];
|
|
|
|
free_data.* = last_data.*;
|
|
free_erase.* = last_erase.*;
|
|
self.slots[free_erase.*].index = free_index;
|
|
}
|
|
|
|
redirect.salt = math.max(redirect.salt +% 1, 1);
|
|
redirect.index = self.next_free;
|
|
self.next_free = slot.index;
|
|
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
|
|
pub const Key = struct {
|
|
index_bits: usize,
|
|
salt_bits: usize,
|
|
};
|
|
|
|
pub fn Slot(comptime key: Key) type {
|
|
return extern struct {
|
|
index: math.Unsigned(key.index_bits),
|
|
salt: math.Unsigned(key.salt_bits),
|
|
};
|
|
}
|
|
|
|
pub const addressable_key = Key{
|
|
.index_bits = (@bitSizeOf(usize) / 2),
|
|
.salt_bits = (@bitSizeOf(usize) / 2),
|
|
};
|