ona/source/coral/map.zig

const debug = @import("./debug.zig");

const io = @import("./io.zig");

const list = @import("./list.zig");

const math = @import("./math.zig");

pub fn Slab(comptime Value: type) type {
	return struct {
		next_index: usize,
		entries: EntryList,

		const EntryList = list.Stack(union (enum) {
			value: Value,
			next_index: usize,
		});

		const Self = @This();

		pub fn lookup(self: Self, key: usize) ?Value {
			if (key == 0 or key > self.entries.values.len) {
				return null;
			}

			return switch (self.entries.values[key - 1]) {
				.value => |value| value,
				.next_index => null,
			};
		}

		pub fn free(self: *Self) void {
			self.entries.free();

			self.next_index = 0;
		}

		pub fn insert(self: *Self, value: Value) io.AllocationError!usize {
			if (self.next_index < self.entries.values.len) {
				const index = self.next_index;
				const entry = &self.entries.values[index];

				debug.assert(entry.* == .next_index);

				self.next_index = entry.next_index;
				entry.* = .{.value = value};

				return index + 1;
			} else {
				try self.entries.push_one(.{.value = value});

				self.next_index += 1;

				return self.next_index;
			}
		}

		pub fn insert_at(self: *Self, key: usize, value: Value) bool {
			if (self.entries.values.len < key) {
				return false;
			}

			const entry = &self.entries.values[key - 1];

			if (entry.* == .value) {
				return false;
			}

			self.next_index = entry.next_index;
			entry.* = .{.value = value};

			return true;
		}

		pub fn make(allocator: io.Allocator) Self {
			return .{
				.next_index = 0,
				.entries = EntryList.make(allocator),
			};
		}

		pub fn remove(self: *Self, key: usize) ?Value {
			if (key == 0 or key > self.entries.values.len) {
				return null;
			}

			const index = key - 1;
			const entry = &self.entries.values[index];

			return switch (entry.*) {
				.next_index => null,

				.value => get_value: {
					const value = entry.value;

					entry.* = .{.next_index = self.next_index};
					self.next_index = index;

					break: get_value value;
				},
			};
		}
	};
}

pub fn StringTable(comptime Value: type) type {
	return Table([]const io.Byte, Value, struct {
		const Self = @This();

		fn equals(_: Self, key_a: []const io.Byte, key_b: []const io.Byte) bool {
			return io.equals(key_a, key_b);
		}

		fn hash(_: Self, key: []const io.Byte) usize {
			return io.djb2_hash(@typeInfo(usize).Int, key);
		}
	});
}

pub fn Table(comptime Key: type, comptime Value: type, comptime Traits: type) type {
	const load_max = 0.75;
	const hash_int = @typeInfo(usize).Int;
	const max_int = math.max_int(hash_int);
	const min_int = math.min_int(hash_int);

	return struct {
		allocator: io.Allocator,
		traits: Traits,
		count: usize,
		entries: []?Entry,

		pub const Entry = struct {
			key: Key,
			value: Value,

			fn write_into(self: Entry, table: *Self) bool {
				const hash_max = @min(max_int, table.entries.len);
				var hashed_key = math.wrap(table.traits.hash(self.key), min_int, hash_max);
				var iterations = @as(usize, 0);

				while (true) : (iterations += 1) {
					debug.assert(iterations < table.entries.len);

					const table_entry = &(table.entries[hashed_key] orelse {
						table.entries[hashed_key] = .{
							.key = self.key,
							.value = self.value,
						};

						table.count += 1;

						return true;
					});

					if (table.traits.equals(table_entry.key, self.key)) {
						return false;
					}

					hashed_key = (hashed_key +% 1) % hash_max;
				}
			}
		};

		pub const Iterable = struct {
			table: *Self,
			iterations: usize,

			pub fn next(self: *Iterable) ?Entry {
				while (self.iterations < self.table.entries.len) {
					defer self.iterations += 1;

					if (self.table.entries[self.iterations]) |entry| {
						return entry;
					}
				}

				return null;
			}
		};

		const Self = @This();

		pub fn as_iterable(self: *Self) Iterable {
			return .{
				.table = self,
				.iterations = 0,
			};
		}

		pub fn remove(self: *Self, key: Key) ?Entry {
			const hash_max = @min(max_int, self.entries.len);
			var hashed_key = math.wrap(self.traits.hash(key), min_int, hash_max);

			while (true) {
				const entry = &(self.entries[hashed_key] orelse continue);

				if (self.traits.equals(entry.key, key)) {
					const original_entry = entry.*;

					self.entries[hashed_key] = null;

					return original_entry;
				}

				hashed_key = (hashed_key +% 1) % hash_max;
			}
		}

		pub fn replace(self: *Self, key: Key, value: Value) io.AllocationError!?Entry {
			try self.rehash(load_max);

			debug.assert(self.entries.len > self.count);

			{
				const hash_max = @min(max_int, self.entries.len);
				var hashed_key = math.wrap(self.traits.hash(key), min_int, hash_max);

				while (true) {
					const entry = &(self.entries[hashed_key] orelse {
						self.entries[hashed_key] = .{
							.key = key,
							.value = value,
						};

						self.count += 1;

						return null;
					});

					if (self.traits.equals(entry.key, key)) {
						const original_entry = entry.*;

						entry.* = .{
							.key = key,
							.value = value,
						};

						return original_entry;
					}

					hashed_key = (hashed_key +% 1) % hash_max;
				}
			}
		}

		pub fn calculate_load_factor(self: Self) f32 {
			return if (self.entries.len == 0) 1 else @as(f32, @floatFromInt(self.count)) / @as(f32, @floatFromInt(self.entries.len));
		}

		pub fn clear(self: *Self) void {
			for (self.entries) |*entry| {
				entry.* = null;
			}

			self.count = 0;
		}

		pub fn free(self: *Self) void {
			if (self.entries.len == 0) {
				return;
			}

			self.allocator.deallocate(self.entries);

			self.entries = &.{};
			self.count = 0;
		}

		pub fn insert(self: *Self, key: Key, value: Value) io.AllocationError!bool {
			try self.rehash(load_max);

			debug.assert(self.entries.len > self.count);

			const entry = Entry{
				.key = key,
				.value = value,
			};

			return entry.write_into(self);
		}

		pub fn lookup(self: Self, key: Key) ?Value {
			if (self.count == 0) {
				return null;
			}

			const hash_max = @min(max_int, self.entries.len);
			var hashed_key = math.wrap(self.traits.hash(key), min_int, hash_max);
			var iterations = @as(usize, 0);

			while (iterations < self.count) : (iterations += 1) {
				const entry = &(self.entries[hashed_key] orelse return null);

				if (self.traits.equals(entry.key, key)) {
					return entry.value;
				}

				hashed_key = (hashed_key +% 1) % hash_max;
			}

			return null;
		}

		pub fn make(allocator: io.Allocator, traits: Traits) Self {
			return .{
				.allocator = allocator,
				.count = 0,
				.entries = &.{},
				.traits = traits,
			};
		}

		pub fn rehash(self: *Self, max_load: f32) io.AllocationError!void {
			if (self.calculate_load_factor() <= max_load) {
				return;
			}

			var table = make(self.allocator, self.traits);

			errdefer table.free();

			table.entries = allocate: {
				const min_count = @max(1, self.count);
				const table_size = min_count * 2;

				break: allocate try io.allocate_many(self.allocator, table_size, @as(?Entry, null));
			};

			for (self.entries) |maybe_entry| {
				if (maybe_entry) |entry| {
					debug.assert(entry.write_into(&table));
				}
			}

			self.free();

			self.* = table;
		}
	};
}