I am trying to work out how to do a :-

class Type {
public:
std::string name;
....
};

std::unordered_map<std::pair<const Type *, const Type*>, bool, std::hash<Type>> subTypeMemorization;

Godbolt attempt xxample :-

https://godbolt.org/z/r4YrG841E

Many thanks in advance,

Aaron

Am 01.10.2023 um 22:59 schrieb Aaron Gray:
> I am trying to work out how to do a :-
>
> class Type {
> public:
> std::string name;
> ....
> };
> std::unordered_map<std::pair<const Type *, const Type*>, bool, std::hash<Type>> subTypeMemorization;
> Godbolt attempt xxample :-
>
> https://godbolt.org/z/r4YrG841E

You must specialize the hasher yourself:

#include <string>
#include <utility>
#include <unordered_map>
#include <functional>

using namespace std;

struct Type
{ string name;
};

template<>
struct hash<pair<Type *, Type *>>
{ size_t operator ()( pair<Type *, Type *> const &key )
{
size_t hash = 0;
hash ^= key.first ? std::hash<string>()( key.first->name ) :
std::hash<void *>()( nullptr );
hash ^= key.second ? std::hash<string>()( key.first->name ) :
std::hash<void *>()( nullptr );
return hash;
}
};

unordered_map<pair<Type *, Type *>, bool> map;

Am 02.10.2023 um 13:18 schrieb Bonita Montero:
> Am 01.10.2023 um 22:59 schrieb Aaron Gray:
>> I am trying to work out how to do a :-
>>
>> class Type {
>> public:
>>      std::string name;
>>      ....
>> };
>> std::unordered_map<std::pair<const Type *, const Type*>, bool,
>> std::hash<Type>> subTypeMemorization;
>> Godbolt attempt xxample :-
>>
>>      https://godbolt.org/z/r4YrG841E
>
> You must specialize the hasher yourself:
>
> #include <string>
> #include <utility>
> #include <unordered_map>
> #include <functional>
>
> using namespace std;
>
> struct Type
> {
>     string name;
> };
>
> template<>
> struct hash<pair<Type *, Type *>>
> {
>     size_t operator ()( pair<Type *, Type *> const &key )
>     {
>         size_t hash = 0;
>         hash ^= key.first ? std::hash<string>()( key.first->name ) :
> std::hash<void *>()( nullptr );
>         hash ^= key.second ? std::hash<string>()( key.first->name ) :
> std::hash<void *>()( nullptr );
hash ^= key.second ? std::hash<string>()( key.second->name )
: std::hash<void *>()( nullptr );

>         return hash;
>     }
> };
>
> unordered_map<pair<Type *, Type *>, bool> map;
>
>

On Monday, 2 October 2023 at 12:20:05 UTC+1, Bonita Montero wrote:
> > You must specialize the hasher yourself:

Bonita,

Great, I found another solution on Stack Overflow but will look into this one as it looks cleaner and more cannonical, thanks a lot.

https://stackoverflow.com/posts/32685618/revisions

Regards,

Aaron

Am 02.10.2023 um 14:10 schrieb Aaron Gray:

> Bonita,
> Great, I found another solution on Stack Overflow but will look into this one as it looks cleaner and more cannonical, thanks a lot.
> https://stackoverflow.com/posts/32685618/revisions

The problem I have with that solution for you is that it will hash
the Type-pointer values of first and second and not the both strings
themselfes. This may lead to different hashes for identical strings
I'm hashing either the strings, or if either Pointer is nullptr, the
nullptr-hash.

On Monday, 2 October 2023 at 15:48:18 UTC+1, Bonita Montero wrote:
> Am 02.10.2023 um 14:10 schrieb Aaron Gray:
>
> > Bonita,
> > Great, I found another solution on Stack Overflow but will look into this one as it looks cleaner and more cannonical, thanks a lot.
> > https://stackoverflow.com/posts/32685618/revisions
> The problem I have with that solution for you is that it will hash
> the Type-pointer values of first and second and not the both strings
> themselfes. This may lead to different hashes for identical strings
> I'm hashing either the strings, or if either Pointer is nullptr, the
> nullptr-hash.

Hash functions are not my strong point but I can see you are covering the domain consistently in your code where the Stack Overflow example is almost random and probably overlapping input domains.

Thanks for pointing that out !

Aaron

Am 02.10.2023 um 19:35 schrieb Aaron Gray:

> Thanks for pointing that out !

Maybe that should be the final solution:

template<>
struct hash<pair<Type*, Type*>>
{ size_t operator ()(pair<Type*, Type*> const& key)
{
size_t h = 0;
std::hash<string_view> hsv;
auto extend = [&]( auto, Type *pT ) { h ^= hsv( pT ?
string_view( pT->name.begin(), pT->name.end() ) : string_view( "" ) ); };
extend( false_type(), key.first );
extend( true_type(), key.second );
return h;
}
};

I use lambdas to save code. To force them to be inlined I make
them generic and call each instntiation only once. To instantiate
the lambda above twice I call them with different bool_constant<X>
types.

On Tuesday, 3 October 2023 at 12:05:24 UTC+1, Bonita Montero wrote:
> Am 02.10.2023 um 19:35 schrieb Aaron Gray:
>
> > Thanks for pointing that out !
> Maybe that should be the final solution:
>
> template<>
> struct hash<pair<Type*, Type*>>
> {
> size_t operator ()(pair<Type*, Type*> const& key)
> {
> size_t h = 0;
> std::hash<string_view> hsv;
> auto extend = [&]( auto, Type *pT ) { h ^= hsv( pT ?
> string_view( pT->name.begin(), pT->name.end() ) : string_view( "" ) ); };
> extend( false_type(), key.first );
> extend( true_type(), key.second );
> return h;
> }
> };
>
> I use lambdas to save code. To force them to be inlined I make
> them generic and call each instntiation only once. To instantiate
> the lambda above twice I call them with different bool_constant<X>
> types.

I am not sure about this. I prefer your previous example.

Regards,

Aaron