Id.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/String/String.h"
#include "Honey/String/Hash.h"

namespace honey
{


class IdLiteral;
class ByteStream;

class Id
{
    friend class IdLiteral;
public:
    Id()                                            : _hash(0) {}
    Id(const String& name)                          : debug_if(_name(name),) _hash(hash::fast(name)) {}
    Id(const String& name, szt hash)                : debug_if(_name(name),) _hash(hash) { assert(_hash == hash::fast(_name)); }
    Id(const IdLiteral& rhs);
    Id(const Id& rhs)                               : debug_if(_name(rhs._name),) _hash(rhs._hash) {}
    Id(Id&& rhs)                                    : debug_if(_name(move(rhs._name)),) _hash(rhs._hash) {}
    
    Id& operator=(const Id& rhs)                    { debug_if(_name = rhs._name;) _hash = rhs._hash; return *this; }
    Id& operator=(Id&& rhs)                         { debug_if(_name = move(rhs._name);) _hash = rhs._hash; return *this; }
    Id& operator=(const IdLiteral& rhs);
    
    bool operator==(const Id& rhs) const            { return _hash == rhs._hash; }
    bool operator!=(const Id& rhs) const            { return _hash != rhs._hash; }
    bool operator< (const Id& rhs) const            { return _hash < rhs._hash; }
    bool operator> (const Id& rhs) const            { return _hash > rhs._hash; }
    bool operator<=(const Id& rhs) const            { return _hash <= rhs._hash; }
    bool operator>=(const Id& rhs) const            { return _hash >= rhs._hash; }

    bool operator==(const IdLiteral& rhs) const;
    bool operator!=(const IdLiteral& rhs) const;
    bool operator< (const IdLiteral& rhs) const;
    bool operator> (const IdLiteral& rhs) const;
    bool operator<=(const IdLiteral& rhs) const;
    bool operator>=(const IdLiteral& rhs) const;
    
    #ifndef FINAL
        const String& name() const                  { return _name; }
    #endif
    szt hash() const                                { return _hash; }
    
    operator szt() const                            { return _hash; }

    #ifndef FINAL
        friend ostream& operator<<(ostream& os, const Id& val)      { return val._hash ? (val._name.length() ? os << val._name : os << val._hash) : os << "idnull"; }
    #else
        friend ostream& operator<<(ostream& os, const Id& val)      { return val._hash ? os << val._hash : os << "idnull"; }
    #endif
    friend ByteStream& operator<<(ByteStream& os, const Id& val);
    friend ByteStream& operator>>(ByteStream& is, Id& val);
    
protected:
    #ifndef FINAL
        String _name;
    #endif
    szt _hash;
};

class IdLiteral
{
    friend class Id;
public:
    constexpr IdLiteral()                           : debug_if(_name(""),) _hash(0) {}
    constexpr IdLiteral(const char* str, szt len)   : debug_if(_name(str),) _hash(hash::fast_(str, len)) {}
    
    constexpr bool operator==(const IdLiteral& rhs) const   { return _hash == rhs._hash; }
    constexpr bool operator!=(const IdLiteral& rhs) const   { return _hash != rhs._hash; }
    constexpr bool operator< (const IdLiteral& rhs) const   { return _hash < rhs._hash; }
    constexpr bool operator> (const IdLiteral& rhs) const   { return _hash > rhs._hash; }
    constexpr bool operator<=(const IdLiteral& rhs) const   { return _hash <= rhs._hash; }
    constexpr bool operator>=(const IdLiteral& rhs) const   { return _hash >= rhs._hash; }
    
    bool operator==(const Id& rhs) const            { return _hash == rhs._hash; }
    bool operator!=(const Id& rhs) const            { return _hash != rhs._hash; }
    bool operator< (const Id& rhs) const            { return _hash < rhs._hash; }
    bool operator> (const Id& rhs) const            { return _hash > rhs._hash; }
    bool operator<=(const Id& rhs) const            { return _hash <= rhs._hash; }
    bool operator>=(const Id& rhs) const            { return _hash >= rhs._hash; }
    
    #ifndef FINAL
        constexpr const char* name() const          { return _name; }
    #endif
    constexpr szt hash() const                      { return _hash; }
    
    constexpr operator szt() const                  { return _hash; }
    
    #ifndef FINAL
        friend ostream& operator<<(ostream& os, const IdLiteral& val)   { return val._hash ? os << val._name : os << "idnull"; }
    #else
        friend ostream& operator<<(ostream& os, const IdLiteral& val)   { return val._hash ? os << val._hash : os << "idnull"; }
    #endif
    friend ByteStream& operator<<(ByteStream& os, const IdLiteral& val);
    
private:
    #ifndef FINAL
        const char* _name;
    #endif
    szt _hash;
};

#define idnull IdLiteral()


constexpr IdLiteral operator"" _id(const char* str, szt len)     { return IdLiteral(str, len); }

inline Id::Id(const IdLiteral& rhs)                         : debug_if(_name(rhs._name),) _hash(rhs._hash) {}
inline Id& Id::operator=(const IdLiteral& rhs)              { debug_if(_name = rhs._name;) _hash = rhs._hash; return *this; }
inline bool Id::operator==(const IdLiteral& rhs) const      { return _hash == rhs._hash; }
inline bool Id::operator!=(const IdLiteral& rhs) const      { return _hash != rhs._hash; }
inline bool Id::operator<=(const IdLiteral& rhs) const      { return _hash <= rhs._hash; }
inline bool Id::operator>=(const IdLiteral& rhs) const      { return _hash >= rhs._hash; }
inline bool Id::operator< (const IdLiteral& rhs) const      { return _hash < rhs._hash; }
inline bool Id::operator> (const IdLiteral& rhs) const      { return _hash > rhs._hash; }
class NameId : public Id
{
public:
    NameId() = default;
    NameId(const String& name)                      : Id(name), _name(name) {}
    NameId(const char* name)                        : Id(name), _name(name) {}
    explicit NameId(const Id& id)                   : Id(id) {}
    NameId(const String& name, const Id& id)        : Id(id), _name(name) { assert(_name == Id::name()); }
    
    const String& name() const                      { return _name; }
    
    friend ostream& operator<<(ostream& os, const NameId& val)          { return os << val._name; }
    friend ByteStream& operator<<(ByteStream& os, const NameId& val);
    friend ByteStream& operator>>(ByteStream& is, NameId& val);
    
private:
    String _name;
};

}

template<>
struct std::hash<honey::Id>
{
    size_t operator()(const honey::Id& val) const           { return val.hash(); }
};

template<>
struct std::hash<honey::IdLiteral>
{
    size_t operator()(const honey::IdLiteral& val) const    { return val.hash(); }
};

template<>
struct std::hash<honey::NameId>
{
    size_t operator()(const honey::NameId& val) const       { return val.hash(); }
};