type_id.h

#pragma once
 
#include <string>
#include <cgv/type/standard_types.h>
#include <cgv/type/lib_begin.h>
 
namespace cgv {
    namespace type {
        namespace info {
 
enum TypeId { 
    TI_UNDEF, 
    TI_BIT,   
 
    TI_VOID,  
 
    TI_BOOL,  
    TI_INT8,  
    TI_INT16, 
    TI_INT32, 
    TI_INT64, 
    TI_UINT8, 
    TI_UINT16, 
    TI_UINT32, 
    TI_UINT64, 
    TI_FLT16,  
    TI_FLT32, 
    TI_FLT64, 
    TI_WCHAR,  
    TI_STRING, 
    TI_WSTRING, 
 
    TI_ENUM,            
    TI_REFERENCE,   
    TI_POINTER,     
    TI_ARRAY,       
    TI_FUNCTION_POINTER, 
    TI_MEMBER_POINTER,   
    TI_METHOD_POINTER,  
    TI_STRUCT,           
    TI_CLASS,               
    TI_UNION,               
 
    TI_CONST,            
    TI_EXPRESSION,       
    TI_PARAMETER,        
    TI_SIGNATURE,        
    TI_FUNCTION,         
    TI_BASE,             
    TI_MEMBER,           
    TI_METHOD,           
    TI_CONSTRUCTOR,      
    TI_INSTANCE,         
    TI_TYPEDEF,          
    TI_TYPENAME,         
    TI_CLASSNAME,        
    TI_TEMPLATE,            
 
    TI_LAST,    
 
    TI_CHAR = TI_INT8, 
    TI_FIRST = TI_UNDEF, 
    TI_FIRST_STD_TYPE = TI_BOOL, 
    TI_LAST_STD_TYPE = TI_WSTRING, 
    TI_FIRST_TYPE = TI_VOID, 
    TI_LAST_TYPE = TI_UNION, 
};
 
inline bool is_unsigned_integral(TypeId tid) { return tid>=TI_UINT8 && tid<=TI_UINT64; }
inline bool is_signed_integral(TypeId tid)   { return tid>=TI_INT8 && tid<=TI_INT64; }
inline bool is_integral(TypeId tid)          { return tid>=TI_INT8 && tid<=TI_UINT64; }
inline bool is_floating(TypeId tid)          { return tid>=TI_FLT16 && tid<=TI_FLT64; }
inline bool is_number(TypeId tid)            { return tid>=TI_INT8 && tid<=TI_FLT64; }
inline bool is_fundamental(TypeId tid)       { return tid>=TI_FIRST_STD_TYPE && tid<=TI_LAST_STD_TYPE; }
inline bool is_compound(TypeId tid)          { return tid>=TI_STRUCT && tid<=TI_UNION; }
inline bool is_type(TypeId tid)              { return tid>=TI_FIRST_TYPE && tid<=TI_LAST_TYPE || tid > TI_LAST; }
 
extern CGV_API TypeId get_new_type_id();
 
 
template <typename T>
struct type_id {
    static TypeId get_id() { static TypeId ti = get_new_type_id(); return ti; }
};
 
template <> struct type_id<void>         { static TypeId get_id() { return TI_VOID; } };
template <> struct type_id<bool>         { static TypeId get_id() { return TI_BOOL; } };
template <> struct type_id<int8_type>    { static TypeId get_id() { return TI_INT8; } };
template <> struct type_id<int16_type>   { static TypeId get_id() { return TI_INT16; } };
template <> struct type_id<int32_type>   { static TypeId get_id() { return TI_INT32; } };
template <> struct type_id<int64_type>   { static TypeId get_id() { return TI_INT64; } };
template <> struct type_id<uint8_type>   { static TypeId get_id() { return TI_UINT8;  } };
template <> struct type_id<uint16_type>  { static TypeId get_id() { return TI_UINT16; } };
template <> struct type_id<uint32_type>  { static TypeId get_id() { return TI_UINT32; } };
template <> struct type_id<uint64_type>  { static TypeId get_id() { return TI_UINT64; } };
template <> struct type_id<flt32_type>   { static TypeId get_id() { return TI_FLT32; } };
template <> struct type_id<flt64_type>   { static TypeId get_id() { return TI_FLT64; } };
template <> struct type_id<wchar_type>   { static TypeId get_id() { return TI_WCHAR; } };
template <> struct type_id<std::string>  { static TypeId get_id() { return TI_STRING; } };
template <> struct type_id<std::wstring> { static TypeId get_id() { return TI_WSTRING; } };
 
extern CGV_API unsigned int get_type_size(TypeId tid);
 
extern CGV_API const char* get_type_name(TypeId tid);
 
extern CGV_API TypeId get_type_id(const std::string& _type_name);
 
        }
    }
}
 
#include <cgv/config/lib_end.h>