# Error with HashMap where the key is a struct containing a pointer to another struct

**URL:** <https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273>\
**Category:** Help\
**Tags:** memory-management, standard-library\
**Created:** [December 11, 2024, 1:51pm UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273 "2024-12-11T13:51:38Z")\
**Posts on this page:** 7\
**Page:** 1

<div class="post-metadata">

**Author:** ![cool-banana](https://ziggit.dev/letter_avatar_proxy/v4/letter/c/8491ac/32.png) [@cool-banana](https://ziggit.dev/u/cool-banana)\
**Post date:** [December 11, 2024, 1:51pm UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/1 "2024-12-11T13:51:38Z")

</div>

Hi. I am playing around with HashMap in zig. In this file, I try to use HashMaps to keep track of packages. Each package is single file named as `<author>.<name>.<version>.ext`. `author` and `name` are strings while `version` is an unsigned integer. I have created two structs to represent a package, one is `Package` which contains the `author` and `name`. The other is `PackageVersioned` containing a pointer to the corresponding `Package` and the `version`.

I record all `Package`s I see in `PackageMap` thus ensuring that a single `Package` (`name` and `author` combination) is not duplicated. Then for the `PackageVersioned` I try to get the pointer to the corresponding `Package` from `PackageMap` then use it to construct a `PackageVersioned` then shove it into the `PackageVersionedMap`.

I know this is a bit stupid but this is mostly an exercise to wrap my head around working with pointers in this scenario. If I make `PackageVersioned` contain a copy of `Package` rather than a pointer to it, it works flawlessly. However when I use a pointer I get this error that I don’t understand. I was hoping someone here could take a look and tell me what mistake I have made.

The code is a single zig file I name `hmap_test.zig`:

> **hmap\_test.zig**
>
> ```zig
> const std = @import("std");
> 
> //
> // Package struct stuff BEGIN
> //
> const Package = struct {
> author: []const u8,
> name: []const u8,
> };
> 
> const PCtx = struct {
> const Self = @This();
> pub fn eql(_: Self, s1: Package, s2: Package) bool {
> return std.mem.eql(u8, s1.author, s2.author) and std.mem.eql(u8, s1.name, s2.name);
> }
> pub fn hash(_: Self, s: Package) u64 {
> var wyhash = std.hash.Wyhash.init(0);
> wyhash.update(s.author);
> wyhash.update(s.name);
> return wyhash.final();
> }
> };
> 
> const PackageMap = std.HashMap(
> Package,
> void,
> PCtx,
> std.hash_map.default_max_load_percentage,
> );
> //
> // Package struct stuff END
> //
> 
> //
> // PackageVersioned struct stuff BEGIN
> //
> const PackageVersioned = struct {
> package: *const Package, // This is now a pointer to TestStruct1
> version: u8,
> };
> 
> const PVCtx = struct {
> const Self = @This();
> pub fn eql(_: Self, s1: PackageVersioned, s2: PackageVersioned) bool {
> return (std.mem.eql(u8, s1.package.author, s2.package.author) and
> std.mem.eql(u8, s1.package.name, s2.package.name) and
> s1.version == s2.version);
> }
> pub fn hash(_: Self, s: PackageVersioned) u64 {
> var wyhash = std.hash.Wyhash.init(0);
> wyhash.update(s.package.author);
> wyhash.update(s.package.name);
> wyhash.update(std.mem.asBytes(&s.version));
> return wyhash.final();
> }
> };
> 
> const PackageVersionedMap = std.HashMap(
> PackageVersioned,
> std.ArrayList([]const u8),
> PVCtx,
> std.hash_map.default_max_load_percentage,
> );
> //
> // PackageVersioned struct stuff END
> //
> 
> /// This function checks if the author, name combination exists in map1. If not it is
> /// `put`. Then the pointer to the Package key having the corresponding author and name
> /// is returned.
> fn registerPackage(map1: *PackageMap, author: []const u8, name: []const u8) !*Package {
> const s = Package{ .author = author, .name = name };
> if (!map1.contains(s)) {
> try map1.put(s, {});
> }
> return map1.getKeyPtr(s).?;
> }
> 
> /// This function first gets a `*Package `using `registerPackage`. Then it checks if
> /// the combination of `*Package` and `version` exists in map2. If not, it is `put`
> /// as the key with the value being an empty ArrayList. Then the path is appended
> /// to this ArrayList.
> fn registerPackageVersioned(
> map1: *PackageMap,
> map2: *PackageVersionedMap,
> author: []const u8,
> name: []const u8,
> version: u8,
> value: []const u8,
> ) !void {
> const s1_ptr = try registerPackage(map1, author, name);
> const s2 = PackageVersioned{ .package = s1_ptr, .version = version };
> if (!map2.contains(s2)) {
> try map2.put(s2, std.ArrayList([]const u8).init(map2.allocator));
> }
> var list = map2.getPtr(s2).?;
> try list.append(value);
> }
> 
> pub fn main() !void {
> var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
> defer arena.deinit();
> const allocator = arena.allocator();
> 
> var map1 = PackageMap.init(allocator);
> defer map1.deinit();
> var map2 = PackageVersionedMap.init(allocator);
> defer map2.deinit();
> 
> // Just register a bunch of packages. No dupes as of now.
> try registerPackageVersioned(&map1, &map2, "Sharon", "Penamouth", 14, "Sharon.Penamouth.14.ext");
> try registerPackageVersioned(&map1, &map2, "Travis", "Jerryburgh", 1, "Travis.Jerryburgh.1.ext");
> try registerPackageVersioned(&map1, &map2, "Nicole", "Newmanmouth", 3, "Nicole.Newmanmouth.3.ext");
> try registerPackageVersioned(&map1, &map2, "Brittany", "West Karenfurt", 10, "Brittany.West Karenfurt.10.ext");
> try registerPackageVersioned(&map1, &map2, "Karen", "Bushview", 20, "Karen.Bushview.20.ext");
> try registerPackageVersioned(&map1, &map2, "Adam", "South Michael", 10, "Adam.South Michael.10.ext");
> try registerPackageVersioned(&map1, &map2, "James", "West Derrickborough", 6, "James.West Derrickborough.6.ext");
> try registerPackageVersioned(&map1, &map2, "William", "Reynoldsville", 13, "William.Reynoldsville.13.ext");
> try registerPackageVersioned(&map1, &map2, "Andrew", "East Alyssaton", 10, "Andrew.East Alyssaton.10.ext");
> try registerPackageVersioned(&map1, &map2, "Ashley", "Port Hailey", 12, "Ashley.Port Hailey.12.ext");
> try registerPackageVersioned(&map1, &map2, "Jessica", "North Mary", 7, "Jessica.North Mary.7.ext");
> try registerPackageVersioned(&map1, &map2, "Lori", "Johnsport", 1, "Lori.Johnsport.1.ext");
> try registerPackageVersioned(&map1, &map2, "Cody", "Mcdanielstad", 19, "Cody.Mcdanielstad.19.ext");
> try registerPackageVersioned(&map1, &map2, "Megan", "Lake Kenneth", 15, "Megan.Lake Kenneth.15.ext");
> try registerPackageVersioned(&map1, &map2, "Steven", "Port Stacyville", 8, "Steven.Port Stacyville.8.ext");
> try registerPackageVersioned(&map1, &map2, "Bradley", "New Patricia", 7, "Bradley.New Patricia.7.ext");
> try registerPackageVersioned(&map1, &map2, "Lance", "West Craigfort", 3, "Lance.West Craigfort.3.ext");
> try registerPackageVersioned(&map1, &map2, "Courtney", "Lake Alexandrashire", 8, "Courtney.Lake Alexandrashire.8.ext");
> try registerPackageVersioned(&map1, &map2, "Julie", "Danielport", 2, "Julie.Danielport.2.ext");
> try registerPackageVersioned(&map1, &map2, "Christopher", "Jimenezshire", 17, "Christopher.Jimenezshire.17.ext");
> try registerPackageVersioned(&map1, &map2, "Anthony", "West Andrea", 20, "Anthony.West Andrea.20.ext");
> 
> // Print a human readable representation of our package database
> var iter = map2.iterator();
> while (iter.next()) |entry| {
> std.debug.print(
> "[{s}, {s}, {}]: [ ",
> .{
> entry.key_ptr.package.author,
> entry.key_ptr.package.name,
> entry.key_ptr.version,
> },
> );
> for (entry.value_ptr.items) |item| {
> std.debug.print("{s}, ", .{item});
> }
> std.debug.print("]\n", .{});
> }
> }
> 
> test "hash functions" {
> const allocator = std.testing.allocator;
> const author1 = "author1";
> const author1_dupe1 = try allocator.dupe(u8, author1);
> defer allocator.free(author1_dupe1);
> const author1_dupe2 = try allocator.dupe(u8, author1);
> defer allocator.free(author1_dupe2);
> std.debug.assert(&author1_dupe1 != &author1_dupe2);
> 
> const ctx1 = PCtx{};
> const p1 = Package{ .author = author1_dupe1, .name = "name1" };
> const p2 = Package{ .author = author1_dupe2, .name = "name1" };
> const p3 = Package{ .author = "author2", .name = "name2" };
> std.debug.assert(&p1 != &p2);
> std.debug.assert(ctx1.hash(p1) == ctx1.hash(p2));
> std.debug.assert(ctx1.eql(p1, p2));
> std.debug.assert(ctx1.hash(p1) != ctx1.hash(p3));
> 
> const ctx2 = PVCtx{};
> const pv1 = PackageVersioned{ .package = &p1, .version = 1 };
> const pv2 = PackageVersioned{ .package = &p2, .version = 1 };
> const pv3 = PackageVersioned{ .package = &p2, .version = 2 };
> std.debug.assert(&pv1 != &pv2);
> std.debug.assert(ctx2.hash(pv1) == ctx2.hash(pv2));
> std.debug.assert(ctx2.eql(pv1, pv2));
> std.debug.assert(ctx2.hash(pv2) != ctx2.hash(pv3));
> }
> 
> ```

This is the error encountered when I do `zig run hmap_test.zig`:

> **Output**
>
> ```zig
> General protection exception (no address available)
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/mem.zig:1747:5: 0x1080422 in update (hmap_test)
> const value: T = @bitCast(buffer.*);
> ^
> /home/me/zig_stuff/var_doctor/hmap_test.zig:51:22: 0x1072964 in hash (hmap_test)
> wyhash.update(s.package.author);
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:1100:34: 0x10c4866 in putAssumeCapacityNoClobberContext (hmap_test)
> const hash = ctx.hash(key);
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:1689:58: 0x10a7548 in grow (hmap_test)
> map.putAssumeCapacityNoClobberContext(k, v, ctx);
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:1536:30: 0x1090bb7 in growIfNeeded (hmap_test)
> try self.grow(allocator, capacityForSize(self.load() + new_count), ctx);
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:1357:34: 0x1072b39 in getOrPutContextAdapted__anon_9187 (hmap_test)
> self.growIfNeeded(allocator, 1, ctx) catch |err| {
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:1342:56: 0x105be8e in getOrPutContext (hmap_test)
> const gop = try self.getOrPutContextAdapted(allocator, key, ctx, ctx);
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:1268:52: 0x103feb0 in putContext (hmap_test)
> const result = try self.getOrPutContext(allocator, key, ctx);
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/hash_map.zig:552:45: 0x103a639 in put (hmap_test)
> return self.unmanaged.putContext(self.allocator, key, value, self.ctx);
> ^
> /home/me/zig_stuff/var_doctor/hmap_test.zig:94:21: 0x103a4b4 in registerPackageVersioned (hmap_test)
> try map2.put(s2, std.ArrayList([]const u8).init(map2.allocator));
> ^
> /home/me/zig_stuff/var_doctor/hmap_test.zig:117:33: 0x103abe3 in main (hmap_test)
> try registerPackageVersioned(&map1, &map2, "James", "West Derrickborough", 6, "James.West Derrickborough.6.ext");
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/start.zig:617:37: 0x1039ad2 in posixCallMainAndExit (hmap_test)
> const result = root.main() catch |err| {
> ^
> /home/me/zig_stuff/zig-linux-x86_64-0.14.0-dev/lib/std/start.zig:248:5: 0x10396af in _start (hmap_test)
> asm volatile (switch (native_arch) {
> ^
> ???:?:?: 0x0 in ??? (???)
> zsh: IOT instruction zig run hmap_test.zig
> 
> ```

Any input is appreciated. Thank you.

---

<div class="post-metadata">

**Author:** ![dimdin](https://ziggit.dev/user_avatar/ziggit.dev/dimdin/32/1457_2.png) [@dimdin](https://ziggit.dev/u/dimdin)\
**Post date:** [December 11, 2024, 2:56pm UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/2 "2024-12-11T14:56:53Z")

</div>

You must allocate the keys, using an allocator, for both maps.

* * *

In `registerPackage` the `const s` allocates the memory for the `Package` in the stack. The stack is reset and `Package` lifetime ends when the function exits.  
The same holds for `const s2` in function `registerPackageVersioned`.

What is happening is:

- `try map2.put(s2, ...` is called
- `s2` is `const s2 = PackageVersioned{ .package = s1_ptr, .version = version };` which is valid because we are in the same function.
- `s1_ptr` is invalid because s1\_ptr is a pointer to s1 allocated in `const s1_ptr = try registerPackage(map1, author, name);` and replaced on the stack by other contents.
- in `map2.put` `PVCtx` `hash` is called and in the line: `wyhash.update(s.package.author);` the program crashes because `s.package` is invalid.

* * *

You can use `const p = allocator.create(Package);` (p type is `*Package`)  
and you must free the memory when done, using `allocator.destroy(p);`

See: [Zig's HashMap - Part 1](https://www.openmymind.net/Zigs-HashMap-Part-1/) it is a tutorial for HashMap, it starts with nodes list allocations using allocator create and destroy.

---

<div class="post-metadata">

**Author:** ![ktz\_alias](https://ziggit.dev/user_avatar/ziggit.dev/ktz_alias/32/1202_2.png) [@ktz\_alias](https://ziggit.dev/u/ktz_alias)\
**Post date:** [December 11, 2024, 3:40pm UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/3 "2024-12-11T15:40:45Z")

</div>

`std.HashMap` calls `grow` method to reallocate the memory automatically.  
Already allocated memory is deallocated.

You use `map1` key as the key of `map2` instance.  
But after the `map1` is reallocated, the key of `map2` is invalidated.

So as [@dimdin](https://ziggit.dev/u/dimdin) mentioned, `Package` data must be allocated on the heap.

---

<div class="post-metadata">

**Author:** ![cool-banana](https://ziggit.dev/letter_avatar_proxy/v4/letter/c/8491ac/32.png) [@cool-banana](https://ziggit.dev/u/cool-banana)\
**Post date:** [December 12, 2024, 6:56am UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/4 "2024-12-12T06:56:02Z")

</div>

I understand what is happening now but I am having trouble articulating a solution. In the linked blogpost, I can wrap my head around how they use `var node = allocator.create(...)`. Since it returns a pointer to a `Node`, the assignment is straightforward like `LL.head = node`.

In my case I am not sure how to use the product of `allocator.create()` correctly. For example, here is the updated code:

> **hmap\_test.zig**
>
> ```zig
> const std = @import("std");
> 
> //
> // Package struct stuff BEGIN
> //
> const Package = struct {
> author: []const u8,
> name: []const u8,
> };
> 
> const PCtx = struct {
> const Self = @This();
> pub fn eql(_: Self, s1: Package, s2: Package) bool {
> return std.mem.eql(u8, s1.author, s2.author) and std.mem.eql(u8, s1.name, s2.name);
> }
> pub fn hash(_: Self, s: Package) u64 {
> var wyhash = std.hash.Wyhash.init(0);
> wyhash.update(s.author);
> wyhash.update(s.name);
> return wyhash.final();
> }
> };
> 
> const PackageMap = std.HashMap(
> Package,
> void,
> PCtx,
> std.hash_map.default_max_load_percentage,
> );
> //
> // Package struct stuff END
> //
> 
> //
> // PackageVersioned struct stuff BEGIN
> //
> const PackageVersioned = struct {
> package: *const Package, // This is now a pointer to TestStruct1
> version: u8,
> };
> 
> const PVCtx = struct {
> const Self = @This();
> pub fn eql(_: Self, s1: PackageVersioned, s2: PackageVersioned) bool {
> return (std.mem.eql(u8, s1.package.author, s2.package.author) and
> std.mem.eql(u8, s1.package.name, s2.package.name) and
> s1.version == s2.version);
> }
> pub fn hash(_: Self, s: PackageVersioned) u64 {
> var wyhash = std.hash.Wyhash.init(0);
> wyhash.update(s.package.author);
> wyhash.update(s.package.name);
> wyhash.update(std.mem.asBytes(&s.version));
> return wyhash.final();
> }
> };
> 
> const PackageVersionedMap = std.HashMap(
> PackageVersioned,
> std.ArrayList([]const u8),
> PVCtx,
> std.hash_map.default_max_load_percentage,
> );
> //
> // PackageVersioned struct stuff END
> //
> 
> /// This function checks if the author, name combination exists in map1. If not it is
> /// `put`. Then the pointer to the Package key having the corresponding author and name
> /// is returned.
> fn registerPackage(
> p_map: *PackageMap,
> author: []const u8,
> name: []const u8,
> allocator: std.mem.Allocator,
> ) !*Package {
> if (!p_map.contains(Package{ .author = author, .name = name })) {
> const pkg = try allocator.create(Package);
> pkg.author = try allocator.dupe(u8, author);
> pkg.name = try allocator.dupe(u8, name);
> try p_map.put(pkg.*, {});
> }
> return p_map.getKeyPtr(Package{ .author = author, .name = name }).?;
> }
> 
> /// This function first gets a `*Package `using `registerPackage`. Then it checks if
> /// the combination of `*Package` and `version` exists in map2. If not, it is `put`
> /// as the key with the value being an empty ArrayList. Then the path is appended
> /// to this ArrayList.
> fn registerPackageVersioned(
> p_map: *PackageMap,
> pv_map: *PackageVersionedMap,
> author: []const u8,
> name: []const u8,
> version: u8,
> value: []const u8,
> allocator: std.mem.Allocator,
> ) !void {
> const pkg_ptr = try registerPackage(p_map, author, name, allocator);
> const pkg_versioned = PackageVersioned{ .package = pkg_ptr, .version = version };
> if (!pv_map.contains(pkg_versioned)) {
> const pv = try allocator.create(PackageVersioned);
> pv.package = pkg_ptr;
> pv.version = version;
> try pv_map.put(
> pv.*,
> std.ArrayList([]const u8).init(allocator),
> );
> }
> var list = pv_map.getPtr(pkg_versioned).?;
> try list.append(value);
> std.debug.print("REGISTERED: {s}.{s}.{}\n", .{ author, name, version });
> }
> 
> pub fn main() !void {
> var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
> defer arena.deinit();
> const allocator = arena.allocator();
> 
> var p_map = PackageMap.init(allocator);
> defer p_map.deinit();
> var pv_map = PackageVersionedMap.init(allocator);
> defer pv_map.deinit();
> 
> // Just register a bunch of packages. No dupes as of now.
> try registerPackageVersioned(&p_map, &pv_map, "Sharon", "Penamouth", 14, "Sharon.Penamouth.14.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Travis", "Jerryburgh", 1, "Travis.Jerryburgh.1.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Nicole", "Newmanmouth", 3, "Nicole.Newmanmouth.3.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Brittany", "West Karenfurt", 10, "Brittany.West Karenfurt.10.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Karen", "Bushview", 20, "Karen.Bushview.20.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Adam", "South Michael", 10, "Adam.South Michael.10.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "James", "West Derrickborough", 6, "James.West Derrickborough.6.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "William", "Reynoldsville", 13, "William.Reynoldsville.13.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Andrew", "East Alyssaton", 10, "Andrew.East Alyssaton.10.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Ashley", "Port Hailey", 12, "Ashley.Port Hailey.12.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Jessica", "North Mary", 7, "Jessica.North Mary.7.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Lori", "Johnsport", 1, "Lori.Johnsport.1.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Cody", "Mcdanielstad", 19, "Cody.Mcdanielstad.19.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Megan", "Lake Kenneth", 15, "Megan.Lake Kenneth.15.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Steven", "Port Stacyville", 8, "Steven.Port Stacyville.8.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Bradley", "New Patricia", 7, "Bradley.New Patricia.7.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Lance", "West Craigfort", 3, "Lance.West Craigfort.3.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Courtney", "Lake Alexandrashire", 8, "Courtney.Lake Alexandrashire.8.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Julie", "Danielport", 2, "Julie.Danielport.2.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Christopher", "Jimenezshire", 17, "Christopher.Jimenezshire.17.ext", allocator);
> try registerPackageVersioned(&p_map, &pv_map, "Anthony", "West Andrea", 20, "Anthony.West Andrea.20.ext", allocator);
> 
> // Try only registering packages
> // _ = try registerPackage(&map1, "Sharon", "Penamouth", allocator);
> // _ = try registerPackage(&map1, "Travis", "Jerryburgh", allocator);
> // _ = try registerPackage(&map1, "Nicole", "Newmanmouth", allocator);
> // _ = try registerPackage(&map1, "Brittany", "West Karenfurt", allocator);
> // _ = try registerPackage(&map1, "Karen", "Bushview", allocator);
> // _ = try registerPackage(&map1, "Adam", "South Michael", allocator);
> // _ = try registerPackage(&map1, "James", "West Derrickborough", allocator);
> // _ = try registerPackage(&map1, "William", "Reynoldsville", allocator);
> // _ = try registerPackage(&map1, "Andrew", "East Alyssaton", allocator);
> // _ = try registerPackage(&map1, "Ashley", "Port Hailey", allocator);
> // _ = try registerPackage(&map1, "Jessica", "North Mary", allocator);
> // _ = try registerPackage(&map1, "Lori", "Johnsport", allocator);
> // _ = try registerPackage(&map1, "Cody", "Mcdanielstad", allocator);
> // _ = try registerPackage(&map1, "Megan", "Lake Kenneth", allocator);
> // _ = try registerPackage(&map1, "Steven", "Port Stacyville", allocator);
> // _ = try registerPackage(&map1, "Bradley", "New Patricia", allocator);
> // _ = try registerPackage(&map1, "Lance", "West Craigfort", allocator);
> // _ = try registerPackage(&map1, "Courtney", "Lake Alexandrashire", allocator);
> // _ = try registerPackage(&map1, "Julie", "Danielport", allocator);
> // _ = try registerPackage(&map1, "Christopher", "Jimenezshire", allocator);
> // _ = try registerPackage(&map1, "Anthony", "West Andrea", allocator);
> 
> // Human readable representation of PackageMap
> var p_iter = p_map.keyIterator();
> while (p_iter.next()) |key| {
> std.debug.print("{s}.{s}\n", .{ key.author, key.name });
> }
> 
> // Print a human readable representation of our package database
> var pv_iter = pv_map.iterator();
> while (pv_iter.next()) |entry| {
> std.debug.print(
> "[{s}, {s}, {}]: [ ",
> .{
> entry.key_ptr.package.author,
> entry.key_ptr.package.name,
> entry.key_ptr.version,
> },
> );
> for (entry.value_ptr.items) |item| {
> std.debug.print("{s}, ", .{item});
> }
> std.debug.print("]\n", .{});
> }
> }
> 
> test "hash functions" {
> const allocator = std.testing.allocator;
> const author1 = "author1";
> const author1_dupe1 = try allocator.dupe(u8, author1);
> defer allocator.free(author1_dupe1);
> const author1_dupe2 = try allocator.dupe(u8, author1);
> defer allocator.free(author1_dupe2);
> std.debug.assert(&author1_dupe1 != &author1_dupe2);
> 
> const ctx1 = PCtx{};
> const p1 = Package{ .author = author1_dupe1, .name = "name1" };
> const p2 = Package{ .author = author1_dupe2, .name = "name1" };
> const p3 = Package{ .author = "author2", .name = "name2" };
> std.debug.assert(&p1 != &p2);
> std.debug.assert(ctx1.hash(p1) == ctx1.hash(p2));
> std.debug.assert(ctx1.eql(p1, p2));
> std.debug.assert(ctx1.hash(p1) != ctx1.hash(p3));
> 
> const ctx2 = PVCtx{};
> const pv1 = PackageVersioned{ .package = &p1, .version = 1 };
> const pv2 = PackageVersioned{ .package = &p2, .version = 1 };
> const pv3 = PackageVersioned{ .package = &p2, .version = 2 };
> std.debug.assert(&pv1 != &pv2);
> std.debug.assert(ctx2.hash(pv1) == ctx2.hash(pv2));
> std.debug.assert(ctx2.eql(pv1, pv2));
> std.debug.assert(ctx2.hash(pv2) != ctx2.hash(pv3));
> }
> 
> ```

I am `create`ing in `registerPackage` and `registerPackageVersioned`. But then I am immediately derefencing the product of `create` which makes me think I am using it wrong. The same error persists.

Any hints about this? Sorry if I did not make sense.

---

<div class="post-metadata">

**Author:** ![andrewrk](https://ziggit.dev/user_avatar/ziggit.dev/andrewrk/32/7011_2.png) [@andrewrk](https://ziggit.dev/u/andrewrk)\
**Post date:** [December 12, 2024, 9:11am UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/5 "2024-12-12T09:11:53Z")

</div>

Or you can use ArrayHashMap and use indexes.

---

<div class="post-metadata">

**Author:** ![ktz\_alias](https://ziggit.dev/user_avatar/ziggit.dev/ktz_alias/32/1202_2.png) [@ktz\_alias](https://ziggit.dev/u/ktz_alias)\
**Post date:** [December 12, 2024, 12:16pm UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/6 "2024-12-12T12:16:58Z")

</div>

This is because adding a key to the `HaskMap` may lead to reallocate entries.  
So you can not use `getKeyPtr` method to return the key.

You need to declare `PackageMap` key type as the pointer.

```zig
const PackageMap = std.HashMap(
    *Package, // MODIFIED
    void,
    PCtx,
    std.hash_map.default_max_load_percentage,
);

```

And `PCtx` also accepts the pointer.

```zig
const PCtx = struct {
    const Self = @This();
    pub fn eql(_: Self, s1: *Package, s2: *Package) bool { // MODIFIED
        return std.mem.eql(u8, s1.author, s2.author) and std.mem.eql(u8, s1.name, s2.name);
    }
    pub fn hash(_: Self, s: *Package) u64 { // MODIFIED
        var wyhash = std.hash.Wyhash.init(0);
        wyhash.update(s.author);
        wyhash.update(s.name);
        return wyhash.final();
    }
};

```

`registerPackage` function is following:

```zig
fn registerPackage(
    p_map: *PackageMap,
    author: []const u8,
    name: []const u8,
    allocator: std.mem.Allocator,
) !*Package {
    const pkg = try allocator.create(Package);
    pkg.* = .{
        .author = try allocator.dupe(u8, author),
        .name = try allocator.dupe(u8, name),
    };

    const entry = try p_map.getOrPut(pkg);
    if (entry.found_existing) {
        allocator.free(pkg.author);
        allocator.free(pkg.name);
        allocator.destroy(pkg);
        return entry.key_ptr.*;
    }

    entry.value_ptr.* = {};
    return pkg;
}

```

Additionally, in `Human readable representation of PackageMap` line, I’ve modifed following:

```zig
    var p_iter = p_map.keyIterator();
    while (p_iter.next()) |key| {
       // std.debug.print("{s}.{s}\n", .{ key.author, key.name });
       std.debug.print("{s}.{s}\n", .{ key.*.author, key.*.name });
    }

```

---

<div class="post-metadata">

**Author:** ![cool-banana](https://ziggit.dev/letter_avatar_proxy/v4/letter/c/8491ac/32.png) [@cool-banana](https://ziggit.dev/u/cool-banana)\
**Post date:** [December 12, 2024, 3:00pm UTC](https://ziggit.dev/t/error-with-hashmap-where-the-key-is-a-struct-containing-a-pointer-to-another-struct/7273/7 "2024-12-12T15:00:56Z")

</div>

Thanks a lot. I have some thinking about to do now because without your help here it would have never occurred to me that the hashmap having a pointer type key was something that was possible in the first place.
