hash_funcs.h

Go to the documentation of this file.

#ifndef HASH_FUNCS_H
#define HASH_FUNCS_H
 
#include <functional>
#include <memory>
#include <tuple>
#include <utility>
 
namespace mazes
{
 
 
    struct uni_hash
    {
        template <class T1>
        std::size_t operator()(const T1 &p) const
        {
            auto hash1 = std::hash<T1>{}(p);
            auto hash2 = std::hash<T1>{}(p) + 0x9e3779b9;
            return hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2));
        }
    };
 
    struct pair_hash
    {
 
        template <class T1, class T2>
        std::size_t operator()(const std::pair<T1, T2> &p) const
        {
            auto hash1 = std::hash<T1>{}(p.first);
            auto hash2 = std::hash<T2>{}(p.second);
            return hash1 ^ hash2;
        }
    }; // pair_hash
 
    struct tri_hash
    {
        template <class T1, class T2, class T3>
        std::size_t operator()(const std::tuple<T1, T2, T3> &p) const
        {
            auto hash1 = std::hash<T1>{}(std::get<0>(p));
            auto hash2 = std::hash<T2>{}(std::get<1>(p));
            auto hash3 = std::hash<T3>{}(std::get<2>(p));
            return hash1 ^ hash2 ^ hash3;
        }
    };
 
    struct weak_ptr_hash
    {
 
        template <typename T>
        std::size_t operator()(const std::weak_ptr<T> &weak) const
        {
            if (auto shared = weak.lock())
            {
                return std::hash<std::shared_ptr<T>>{}(shared);
            }
 
            // Return 0 for expired weak_ptr
            return 0;
        }
    };
 
} // namespace mazes
 
#endif // HASH_FUNCS_H