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>