type_ptr.h

#pragma once
 
#include <string>
#include <cgv/type/standard_types.h>
#include <cgv/type/info/type_id.h>
 
namespace cgv {
    namespace type {
        namespace info {
 
template <TypeId type_id>
struct type_ptr
{
    static void*       cast(void* ptr)       { return ptr; }
    static const void* cast(const void* ptr) { return ptr; }
};
 
template <>
struct type_ptr<TI_BOOL>
{
    static bool*       cast(void* ptr)       { return static_cast<bool*>(ptr); }
    static const bool* cast(const void* ptr) { return static_cast<const bool*>(ptr); }
};
 
template <>
struct type_ptr<TI_INT8>
{
    static int8_type*       cast(void* ptr)       { return static_cast<int8_type*>(ptr); }
    static const int8_type* cast(const void* ptr) { return static_cast<const int8_type*>(ptr); }
};
template <>
struct type_ptr<TI_INT16>
{
    static int16_type*       cast(void* ptr)       { return static_cast<int16_type*>(ptr); }
    static const int16_type* cast(const void* ptr) { return static_cast<const int16_type*>(ptr); }
};
template <>
struct type_ptr<TI_INT32>
{
    static int32_type*       cast(void* ptr)       { return static_cast<int32_type*>(ptr); }
    static const int32_type* cast(const void* ptr) { return static_cast<const int32_type*>(ptr); }
};
template <>
struct type_ptr<TI_INT64>
{
    static int64_type*       cast(void* ptr)       { return static_cast<int64_type*>(ptr); }
    static const int64_type* cast(const void* ptr) { return static_cast<const int64_type*>(ptr); }
};
template <>
struct type_ptr<TI_UINT8>
{
    static uint8_type*       cast(void* ptr)       { return static_cast<uint8_type*>(ptr); }
    static const uint8_type* cast(const void* ptr) { return static_cast<const uint8_type*>(ptr); }
};
template <>
struct type_ptr<TI_UINT16>
{
    static uint16_type*       cast(void* ptr)       { return static_cast<uint16_type*>(ptr); }
    static const uint16_type* cast(const void* ptr) { return static_cast<const uint16_type*>(ptr); }
};
template <>
struct type_ptr<TI_UINT32>
{
    static uint32_type*       cast(void* ptr)       { return static_cast<uint32_type*>(ptr); }
    static const uint32_type* cast(const void* ptr) { return static_cast<const uint32_type*>(ptr); }
};
template <>
struct type_ptr<TI_UINT64>
{
    static uint64_type*       cast(void* ptr)       { return static_cast<uint64_type*>(ptr); }
    static const uint64_type* cast(const void* ptr) { return static_cast<const uint64_type*>(ptr); }
};
template <>
struct type_ptr<TI_FLT32>
{
    static flt32_type*       cast(void* ptr)       { return static_cast<flt32_type*>(ptr); }
    static const flt32_type* cast(const void* ptr) { return static_cast<const flt32_type*>(ptr); }
};
template <>
struct type_ptr<TI_FLT64>
{
    static flt64_type*       cast(void* ptr)       { return static_cast<flt64_type*>(ptr); }
    static const flt64_type* cast(const void* ptr) { return static_cast<const flt64_type*>(ptr); }
};
template <>
struct type_ptr<TI_STRING>
{
    static std::string*       cast(void* ptr)       { return static_cast<std::string*>(ptr); }
    static const std::string* cast(const void* ptr) { return static_cast<const std::string*>(ptr); }
};
 
template <>
struct type_ptr<TI_WCHAR>
{
    static wchar_type*       cast(void* ptr)       { return static_cast<wchar_type*>(ptr); }
    static const wchar_type* cast(const void* ptr) { return static_cast<const wchar_type*>(ptr); }
};
 
template <>
struct type_ptr<TI_WSTRING>
{
    static std::wstring*       cast(void* ptr)       { return static_cast<std::wstring*>(ptr); }
    static const std::wstring* cast(const void* ptr) { return static_cast<const std::wstring*>(ptr); }
};
 
 
        }
    }
}