TypeID.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Types/Util/Hash.hpp>
 
#include <iostream>
#include <cstring>
 
namespace Infinity::Types
{
    typedef const void* TypeTag;
 
    typedef uint64_t TypeHash;
 
    struct INFINITY_API_PUBLIC TypeID
    {
        TypeTag tag;        
        TypeHash hash;      
        const char* name;   
 
        TypeID();
 
        TypeID(TypeHash hash);
 
        constexpr TypeID(TypeTag tag, TypeHash hash, const char* name)
            : tag(tag), hash(hash), name(name) { }
 
        bool canConvert(const TypeID& other) const;
 
        operator TypeHash() const
        {
            return hash;
        }
 
        void write(std::ostream& os) const;
 
        void read(std::istream& is);
 
        std::string str() const;
 
        std::string hashStr() const;
 
        static TypeHash create_stable_hash(const char* name, size_t len);
 
        constexpr bool operator==(const TypeID& other) const
        {
            return tag == other.tag;
        }
 
        constexpr bool operator!=(const TypeID& other) const
        {
            return !(*this == other);
        }
    };
 
    template<typename T>
    const TypeID& getTypeID();
}
 
namespace std
{
    template<>
    struct hash<Infinity::Types::TypeID>
    {
        size_t operator()(const Infinity::Types::TypeID& id) const
        {
            return reinterpret_cast<size_t>(id.tag);
        }
    };
}
 
#define INFINITY_TYPE(...) \
    template <> INFINITY_API_PUBLIC const ::Infinity::Types::TypeID& ::Infinity::Types::getTypeID<__VA_ARGS__>();
 
#define INFINITY_TYPE_IMPL(...) \
    template<> \
    const ::Infinity::Types::TypeID& ::Infinity::Types::getTypeID<__VA_ARGS__>() { \
        static const char* name = #__VA_ARGS__; \
        static ::Infinity::Types::TypeID id((::Infinity::Types::TypeTag)name, \
                                           ::Infinity::Types::TypeID::create_stable_hash(name, std::strlen(name)), \
                                           name); \
        return id; \
    }
 
#define INFINITY_TYPE_NAME(...)
 
#define INFINITY_TYPE_CONVERT(...)