Named storage/pools

[alektron]

I've been trying to use the functionality to create named pools as described in the Crash course under 'Beam me up, registry".
However there seems to be some kind of misunderstanding on my side since it does not seem to do quite what I would expect.
Imagine the following scenario:

auto poolATest = reg.storage<MyCompA>("Test"_hs);
auto poolBTest = reg.storage<MyCompB>("Test"_hs);

Note that the passed identifier "Test" is the same for both calls, however the component type in the <>brackets is different.
My understanding from the sentence in the crash course

EnTT allows the user to assign a name (or rather, a numeric identifier) to a type and then create multiple pools of the same type: ...
If a name isn't provided, the default storage associated with the given type is always returned.

was, that the identifier that I am passing will be 'combined' with the identifier generated from the component type.
Meaning that poolATest will NOT be the same as poolBTest since, while the passed identifier is the same, the type is different.

Trying this does however trigger an 'Unexpected type' assert in 'assure' since the second call to 'storage' seems to access the same pool as the first call.
Looking at the code, it seems to me that passing an identifier and using the component type identifier is mutually exclusive.
When no identifier is passed, the type identifier will be generated from the function parameter default value.
When an identifier is passed, it will be used as the identifier regardless of the component type.

Is this assumption correct?
Do the custom identifiers passed to 'storage' have to be unique across all types?

[skypjack]

Do the custom identifiers passed to 'storage' have to be unique across all types?

☝️

They aren't combined with the type name. Identifiers are used as-is. So, yeah, in your example they cause a conflict and thus and assert.
Consider that combining would mean concatenating and therefore probably allocating. It's not something I'd want in any case.

[alektron]

Thank you for the quick answer.
My first course of action would now have been to just create a new identifier manually by hashing the component identifier together with the name identifier. I could do this allocation free, however I do not know how that will impact possible hash collisions.
Any opinions an that?

[skypjack]

It's a 64b identifier on which you have full control. I don't see any problems.
Something like reg.storage<MyCompA>("MyCompA:Test"_hs); works just fine imho and you can easily get around it in case of problems.
I'd make it static constexpr on the type probably, just to make it simple to change it as needed in future. 👍