Provides generic hashing for any eligible type. Strategy is provided to determine if pointers should be followed or not.
pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) voidpub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
const Key = @TypeOf(key);
const Hasher = switch (@typeInfo(@TypeOf(hasher))) {
.pointer => |ptr| ptr.child,
else => @TypeOf(hasher),
};
if (strat == .Shallow and std.meta.hasUniqueRepresentation(Key)) {
@call(.always_inline, Hasher.update, .{ hasher, mem.asBytes(&key) });
return;
}
switch (@typeInfo(Key)) {
.noreturn,
.@"opaque",
.spirv,
.undefined,
.null,
.comptime_float,
.comptime_int,
.type,
.enum_literal,
.frame,
.float,
=> @compileError("unable to hash type " ++ @typeName(Key)),
.void => return,
// Help the optimizer see that hashing an int is easy by inlining!
// TODO Check if the situation is better after #561 is resolved.
.int => |int| switch (int.signedness) {
.signed => hash(hasher, @as(@Int(.unsigned, int.bits), @bitCast(key)), strat),
.unsigned => {
if (std.meta.hasUniqueRepresentation(Key)) {
@call(.always_inline, Hasher.update, .{ hasher, std.mem.asBytes(&key) });
} else {
// Take only the part containing the key value, the remaining
// bytes are undefined and must not be hashed!
const byte_size = @divCeil(@bitSizeOf(Key), 8);
@call(.always_inline, Hasher.update, .{ hasher, std.mem.asBytes(&key)[0..byte_size] });
}
},
},
.bool => hash(hasher, @intFromBool(key), strat),
.@"enum" => hash(hasher, @backingInt(key), strat),
.error_set => hash(hasher, @intFromError(key), strat),
.@"anyframe", .@"fn" => hash(hasher, @intFromPtr(key), strat),
.pointer => @call(.always_inline, hashPointer, .{ hasher, key, strat }),
.optional => if (key) |k| hash(hasher, k, strat),
.array => hashArray(hasher, key, strat),
.vector => |info| {
if (std.meta.hasUniqueRepresentation(Key)) {
hasher.update(mem.asBytes(&key));
} else {
comptime var i = 0;
inline while (i < info.len) : (i += 1) {
hash(hasher, key[i], strat);
}
}
},
.@"struct" => |info| {
inline for (info.field_names) |field_name| {
// We reuse the hash of the previous field as the seed for the
// next one so that they're dependant.
hash(hasher, @field(key, field_name), strat);
}
},
.@"union" => |info| blk: {
if (info.tag_type) |tag_type| {
const tag = std.meta.activeTag(key);
hash(hasher, tag, strat);
inline for (info.field_names, info.field_types) |field_name, field_type| {
if (@field(tag_type, field_name) == tag) {
if (field_type != void) {
hash(hasher, @field(key, field_name), strat);
}
break :blk;
}
}
unreachable;
} else @compileError("cannot hash untagged union type: " ++ @typeName(Key) ++ ", provide your own hash function");
},
.error_union => blk: {
const payload = key catch |err| {
hash(hasher, err, strat);
break :blk;
};
hash(hasher, payload, strat);
},
}
}