86 lines
2.5 KiB
Zig
86 lines
2.5 KiB
Zig
// adapted from https://github.com/prime31/zig-ecs/blob/master/src/ecs/utils.zig
|
|
|
|
const std = @import("std");
|
|
|
|
/// stores a single object of type T for each T added
|
|
pub const TypeStore = struct {
|
|
map: std.AutoHashMap(u32, usize),
|
|
allocator: *std.mem.Allocator,
|
|
|
|
pub fn init(allocator: *std.mem.Allocator) TypeStore {
|
|
return TypeStore{
|
|
.map = std.AutoHashMap(u32, usize).init(allocator),
|
|
.allocator = allocator,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *TypeStore) void {
|
|
var iter = self.map.iterator();
|
|
self.map.deinit();
|
|
}
|
|
|
|
/// adds instance, returning a pointer to the item as it lives in the store
|
|
pub fn add(self: *TypeStore, instance: anytype) void {
|
|
var ptr = @ptrToInt(&instance);
|
|
_ = self.map.put(typeId(@TypeOf(instance)), ptr) catch unreachable;
|
|
}
|
|
|
|
pub fn get(self: *TypeStore, comptime T: type) *T {
|
|
if (self.map.get(typeId(T))) |ptr| {
|
|
return @intToPtr(*T, ptr);
|
|
}
|
|
unreachable;
|
|
}
|
|
|
|
pub fn getConst(self: *TypeStore, comptime T: type) T {
|
|
return self.get(T).*;
|
|
}
|
|
|
|
pub fn remove(self: *TypeStore, comptime T: type) void {
|
|
if (self.map.get(typeId(T))) |ptr| {
|
|
_ = self.map.remove(typeId(T));
|
|
}
|
|
}
|
|
|
|
pub fn has(self: *TypeStore, comptime T: type) bool {
|
|
return self.map.contains(typeId(T));
|
|
}
|
|
|
|
fn typeId(comptime T: type) u32 {
|
|
comptime return hashStringFnv(u32, @typeName(T));
|
|
}
|
|
|
|
fn hashStringFnv(comptime ReturnType: type, comptime str: []const u8) ReturnType {
|
|
std.debug.assert(ReturnType == u32 or ReturnType == u64);
|
|
|
|
const prime = if (ReturnType == u32) @as(u32, 16777619) else @as(u64, 1099511628211);
|
|
var value = if (ReturnType == u32) @as(u32, 2166136261) else @as(u64, 14695981039346656037);
|
|
for (str) |c| {
|
|
value = (value ^ @intCast(u32, c)) *% prime;
|
|
}
|
|
return value;
|
|
}
|
|
};
|
|
|
|
test "TypeStore" {
|
|
const Vector = struct { x: f32 = 0, y: f32 = 0, z: f32 = 0 };
|
|
|
|
var store = TypeStore.init(std.testing.allocator);
|
|
defer store.deinit();
|
|
|
|
var orig = Vector{ .x = 5, .y = 6, .z = 8 };
|
|
store.add(orig);
|
|
std.testing.expect(store.has(Vector));
|
|
std.testing.expectEqual(store.get(Vector).*, orig);
|
|
|
|
var v = store.get(Vector);
|
|
std.testing.expectEqual(v.*, Vector{ .x = 5, .y = 6, .z = 8 });
|
|
v.*.x = 666;
|
|
|
|
var v2 = store.get(Vector);
|
|
std.testing.expectEqual(v2.*, Vector{ .x = 666, .y = 6, .z = 8 });
|
|
|
|
store.remove(Vector);
|
|
std.testing.expect(!store.has(Vector));
|
|
}
|