typedId.hpp

Go to the documentation of this file.

#pragma once
#ifndef TYPEDID_HPP
#define TYPEDID_HPP

/*
 * =====================================================================================
 *
 *       Filename:  typedId.hpp
 *
 *    Description: Utility class for rectangle operations.
 *
 * =====================================================================================
 */


template<unsigned short TypeNumber>
class TypedId
{
    friend class boost::serialization::access;
public:
    static const unsigned short type_number = TypeNumber;

    inline explicit TypedId()
        : id(-1)
    {
    }

    inline explicit TypedId(unsigned int id)
        : id(id)
    {
    }

    inline unsigned int getRaw() const
    {
        return id;
    }


    inline bool operator ==(const TypedId& other) const
    {
        return other.id == id;
    }

    inline bool operator !=(const TypedId& other) const
    {
        return other.id != id;
    }

    inline bool operator <(const TypedId& right) const
    {
        return id < right.id;
    }

    inline bool operator >(const TypedId& right) const
    {
        return id > right.id;
    }

    inline bool operator >=(const TypedId& right) const
    {
        return id >= right.id;
    }

    inline bool operator <=(const TypedId& right) const
    {
        return id <= right.id;
    }
private:
    template<typename Archive>
    void serialize(Archive &ar, const unsigned int version){
        ar & id;
    }

    unsigned int id;
};

template<unsigned short TypeNumber>
inline std::size_t hash_value(TypedId<TypeNumber> id)
{
    return static_cast<std::size_t>(id.getRaw());
}

template<unsigned short TypeNumber>
inline std::ostream& operator <<(std::ostream& o, const TypedId<TypeNumber>& id)
{
    o << id.getRaw();
    return o;
}


class AnyId
{
public:
    template<unsigned int TypeNumber>
    inline AnyId(const TypedId<TypeNumber>& id)
        : type(TypedId<TypeNumber>::type_number)
        , id(id.getRaw())
    {

    }

    inline bool operator ==(const AnyId& other) const
    {
        return id == other.id && type == other.type;
    }

    template<typename IdType>
    inline IdType is() const
    {
        return IdType::type_number == type;
    }


    template<typename IdType>
    inline IdType get() const
    {
        assert(type == IdType::type_number);

        return IdType(id);
    }

private:
    unsigned short type;
    unsigned int id;
};






#endif