key_hash.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/dof.h"
 
namespace Kratos
{
 
 
 
    using IndexType = std::size_t;
 
    using HashType = std::size_t;
 
 
 
    template <class TClassType>
    inline void HashCombine(
        HashType& Seed,
        const TClassType& Value
        )
    {
        std::hash<TClassType> hasher;
        Seed ^= hasher(Value) + 0x9e3779b9 + (Seed<<6) + (Seed>>2);
    }
 
    template <class TClassType>
    inline HashType HashRange(
        TClassType First,
        TClassType Last
        )
    {
        HashType seed = 0;
 
        while (First!=Last) {
            HashCombine(seed, *First);
            ++First;
        }
 
        return seed;
    }
 
 
    class VariableData; // forward declaration
 
    template<class TClassType>
    struct KeyComparorRange
    {
        bool operator()(
            const TClassType& first,
            const TClassType& second
            ) const
        {
            if(first.size() != second.size()) {
                return false;
            }
 
            auto it_first = first.begin();
            auto it_second = second.begin();
 
            while(it_first != first.end()) { // NOTE: We already checked that are same size
                if(*it_first != *it_second) {
                    return false;
                }
                if(it_first != first.end()) {
                    ++it_first;
                    ++it_second;
                }
            }
 
            return true;
        }
    };
 
    template<class TClassType>
    struct KeyHasherRange
    {
        HashType operator()(const TClassType& rRange) const
        {
            return HashRange(rRange.begin(), rRange.end());
        }
    };
 
    struct KRATOS_API(KRATOS_CORE) VariableHasher
    {
        HashType operator()(const VariableData& rVariable) const;
    };
 
    struct KRATOS_API(KRATOS_CORE) VariableComparator
    {
        bool operator()(
            const VariableData& rFirst,
            const VariableData& rSecond
            ) const;
    };
 
    struct KRATOS_API(KRATOS_CORE) pVariableHasher
    {
        HashType operator()(const VariableData* pVariable) const;
    };
 
    struct KRATOS_API(KRATOS_CORE) pVariableComparator
    {
        bool operator()(
            const VariableData* pFirst,
            const VariableData* pSecond
            ) const;
    };
 
    template<class TIndexedObject>
    struct IndexedObjectHasher
    {
        HashType operator()(const TIndexedObject& rIndexedObject) const
        {
            return rIndexedObject.Id();
        }
    };
 
    template<class TIndexedObject>
    struct IndexedObjectComparator
    {
        bool operator()(
            const TIndexedObject& rFirst,
            const TIndexedObject& rSecond
            ) const
        {
            return rFirst.Id() == rSecond.Id();
        }
    };
 
    template<class TpIndexedObject>
    struct IndexedObjectPointerHasher
    {
        HashType operator()(const TpIndexedObject pIndexedObject) const
        {
            return pIndexedObject->Id();
        }
    };
 
    template<class TpIndexedObject>
    struct IndexedObjectPointerComparator
    {
        bool operator()(
            const TpIndexedObject pFirst,
            const TpIndexedObject pSecond
            ) const
        {
            return pFirst->Id() == pSecond->Id();
        }
    };
 
    template<class TSharedPointer>
    struct SharedPointerHasher
    {
        HashType operator()(const TSharedPointer& pPointer) const
        {
            return reinterpret_cast<HashType>(pPointer.get());
        }
    };
 
    template<class TSharedPointer>
    struct SharedPointerComparator
    {
        bool operator()(
            const TSharedPointer& first,
            const TSharedPointer& second
            ) const
        {
            return first.get() == second.get();
        }
    };
 
    template<class TVectorIndex>
    struct VectorIndexHasher
    {
        HashType operator()(const TVectorIndex& k) const
        {
            return HashRange(k.begin(), k.end());
        }
    };
 
    template<class TVectorIndex>
    struct VectorIndexComparor
    {
        bool operator()(const TVectorIndex& lhs, const TVectorIndex& rhs) const
        {
            if(lhs.size() != rhs.size())
                return false;
 
            for(IndexType i = 0; i < lhs.size(); i++) {
                if(lhs[i] != rhs[i]) return false;
            }
 
            return true;
        }
    };
 
    struct DofPointerHasher
    {
        HashType operator()(const Dof<double>::Pointer& pDoF) const
        {
            HashType seed = 0;
            HashCombine(seed, pDoF->Id());
            HashCombine(seed, (pDoF->GetVariable()).Key());
            return seed;
        }
    };
 
    struct DofPointerComparor
    {
        bool operator()(const Dof<double>::Pointer& pDoF1, const Dof<double>::Pointer& pDoF2) const
        {
            return (((pDoF1->Id() == pDoF2->Id() && (pDoF1->GetVariable()).Key()) == (pDoF2->GetVariable()).Key()));
        }
    };
 
    template<class TType1, class TType2>
    struct PairHasher
    {
        HashType operator()(const std::pair<TType1, TType2>& rPair) const
        {
            HashType seed = 0;
            HashCombine<TType1>(seed, rPair.first);
            HashCombine<TType2>(seed, rPair.second);
            return seed;
        }
    };
 
    template<class TType1, class TType2>
    struct PairComparor
    {
        bool operator()(const std::pair<TType1, TType2>& rPair1, const std::pair<TType1, TType2>& rPair2) const
        {
            return ((std::get<0>(rPair1) == std::get<0>(rPair2)) && (std::get<1>(rPair1) == std::get<1>(rPair2)));
        }
    };
 
 
} // namespace Kratos.
 
namespace std 
{
    template<typename T1, typename T2>
    struct hash<std::pair<T1, T2>> 
    {
        size_t operator()(const std::pair<T1, T2>& p) const 
        {
            size_t seed = 0;
            const size_t h1 = std::hash<T1>()(p.first);
            const size_t h2 = std::hash<T2>()(p.second);
            Kratos::HashCombine(seed, h1);
            Kratos::HashCombine(seed, h2);
            return seed;
        }
    };
} // namespace std.