TnbHashable.h

[詳解]

#pragma once
#include "TnbSerializer.h"
#include "TnbComparator.h"
 
 
 
namespace TNB
{
 
 
 
template<typename TYP>
class CHashableT : public IComparableT< TNB::CHashableT<TYP> >, public ISerializable
{
    DWORD   m_dwHash;   
    TYP     m_typ;      
 
public:
 
    CHashableT(void) : m_typ(TYP()), m_dwHash(HASH::CalcHash(m_typ))
    {
    }
 
    CHashableT(const CHashableT<TYP>& t) : m_typ(t.m_typ), m_dwHash(t.m_dwHash)
    {
    }
 
    CHashableT(const TYP& t) : m_typ(t)
    {
        m_dwHash = HASH::CalcHash(m_typ);
    }
 
    CHashableT& operator=(const CHashableT<TYP>& other)
    {
        m_typ = other.m_typ;
        m_dwHash = other.m_dwHash;
        return *this;
    }
 
    CHashableT& operator=(const TYP& t)
    {
        m_typ = t;
        m_dwHash = HASH::CalcHash(m_typ);
        return *this;
    }
 
    DWORD GetHashCode(void) const
    {
        return m_dwHash;
    }
 
    virtual INT_PTR Compare(const CHashableT<TYP>& t) const
    {
        return IComparatorT<TYP>::GetDefault().CompareTo(m_typ, t.m_typ);
    }
 
    virtual bool IsEqual(const CHashableT<TYP>& t) const 
    {
        if ( m_dwHash != t.m_dwHash )
        {
            return false;   //ハッシュ値が異なるので、絶対違う
        }
        return IComparatorT<TYP>::GetDefault().IsEqualTo(m_typ, t.m_typ);
    }
 
    const TYP& At(void) const
    {
        return m_typ; 
    }
 
    operator const TYP&(void) const
    {
        return m_typ; 
    }
 
    virtual void Serialize(ISerializer& _sr) const  
    {
        _sr << m_typ;
    }
 
    virtual void Deserialize(const IDeserializer& ds)
    {
        ds >> m_typ;
        m_dwHash = HASH::CalcHash(m_typ);
    }
};
 
 
 
namespace HASH
{
    inline DWORD CalcHash(DWORD dw)
    {
        return dw;
    }
};
 
 
}; // TNB