HashedString.impl.h

#pragma once
 
namespace AtomsCore
{
    inline bool HashedString::operator<(const HashedString& src)const
    {
        return m_hash != src.m_hash ? m_hash < src.m_hash : m_string < src.m_string;
    }
 
    inline bool HashedString::operator==(const HashedString& src) const
    {
        return m_hash == src.m_hash && m_string == src.m_string;
    }
 
    inline bool HashedString::operator!=(const char* value) const
    {
        return m_string != value;
    }
 
    inline bool HashedString::operator!=(const std::string& value) const
    {
        return m_string != value;
    }
 
    inline HashedString& HashedString::operator=(const std::string& other)
    {
        MurmurHash3  hash;
        hash.append(other);
        m_hash = hash.seed[0] ^ hash.seed[1];
        m_string = other;
        return *this;
    }
 
    inline const std::string& HashedString::string() const { return m_string; }
 
    inline size_t HashedString::hash() const { return m_hash; }
 
    inline HashedString::operator const std::string & () const { return m_string; }
 
    inline const char *HashedString::c_str() const { return m_string.c_str(); }
 
    inline std::string HashedString::operator+(const char* value) const { return m_string + value; }
 
    inline std::string HashedString::operator+(const std::string& value) const { return m_string + value; }
 
    inline size_t HashedString::size() const { return m_string.size(); }
 
    inline size_t HashedString::find(const std::string& value, size_t offset) const { return m_string.find(value, offset); }
 
    inline size_t HashedString::rfind(const std::string& value, size_t offset) const { return m_string.rfind(value, offset); }
 
    inline std::string HashedString::substr(size_t offset, size_t count) const { return m_string.substr(offset, count); }
 
    inline bool HashedString::empty() const { return m_string.empty(); }
 
    template<>
    inline size_t memSize(const HashedString& data)
    {
        return memSize(data.string());
    }
 
    template <>
    inline Archive& operator<<(Archive& os, const HashedString& obj)
    {
        os << obj.string();
        return os;
    }
 
    template <>
    inline Archive& operator >> (Archive& is, HashedString& obj)
    {
        std::string value;
        is >> value;
        obj = value;
        return is;
    }
 
    inline std::ostream& operator<<(std::ostream& os, const HashedString& obj)
    {
        os << obj.string();
        return os;
    }
}
 
inline std::string operator+ (const std::string& lhs, const AtomsCore::HashedString& rhs)
{
    return lhs + rhs.string();
}
 
inline std::string operator+ (const char* lhs, const AtomsCore::HashedString& rhs)
{
    return std::string(lhs) + rhs.string();
}