source: trunk/nv/types.hh @ 44

// Copyright (C) 2012 Kornel Kisielewicz
// This file is part of NV Libraries.
// For conditions of distribution and use, see copyright notice in nv.hh

#ifndef NV_TYPES_HH
#define NV_TYPES_HH

#include <glm/glm.hpp>
#include <nv/common.hh>
#include <utility>
#include <unordered_map>
#include <string>

namespace nv
{
        enum type
        {
                INT,
                BYTE,
                SHORT,
                UINT,
                UBYTE,
                USHORT,
                FLOAT,
                FLOAT_VECTOR_2,
                FLOAT_VECTOR_3,
                FLOAT_VECTOR_4,
                FLOAT_MATRIX_2,
                FLOAT_MATRIX_3,
                FLOAT_MATRIX_4,
                INT_VECTOR_2,
                INT_VECTOR_3,
                INT_VECTOR_4
        };

        typedef glm::vec2 vec2;
        typedef glm::vec3 vec3;
        typedef glm::vec4 vec4;

        typedef glm::ivec2 ivec2;
        typedef glm::ivec3 ivec3;
        typedef glm::ivec4 ivec4;

        typedef glm::mat2 mat2;
        typedef glm::mat3 mat3;
        typedef glm::mat4 mat4;

        template < type EnumType > struct enum_to_type {};

        template <> struct enum_to_type< INT >   { typedef int type; };
        template <> struct enum_to_type< UINT >  { typedef unsigned int type; };
        template <> struct enum_to_type< SHORT > { typedef short type; };
        template <> struct enum_to_type< USHORT >{ typedef unsigned short type; };
        template <> struct enum_to_type< BYTE >  { typedef char type; };
        template <> struct enum_to_type< UBYTE > { typedef unsigned char type; };
        template <> struct enum_to_type< FLOAT > { typedef f32 type; };

        template <> struct enum_to_type< FLOAT_VECTOR_2 > { typedef vec2 type; };
        template <> struct enum_to_type< FLOAT_VECTOR_3 > { typedef vec3 type; };
        template <> struct enum_to_type< FLOAT_VECTOR_4 > { typedef vec4 type; };

        template <> struct enum_to_type< INT_VECTOR_2 > { typedef ivec2 type; };
        template <> struct enum_to_type< INT_VECTOR_3 > { typedef ivec3 type; };
        template <> struct enum_to_type< INT_VECTOR_4 > { typedef ivec4 type; };

        template <> struct enum_to_type< FLOAT_MATRIX_2 > { typedef mat2 type; };
        template <> struct enum_to_type< FLOAT_MATRIX_3 > { typedef mat3 type; };
        template <> struct enum_to_type< FLOAT_MATRIX_4 > { typedef mat4 type; };

        template < typename Type > struct type_to_enum {};

        template <> struct type_to_enum< int >           { static const type type = INT; };
        template <> struct type_to_enum< unsigned int >  { static const type type = UINT; };
        template <> struct type_to_enum< short >         { static const type type = SHORT; };
        template <> struct type_to_enum< unsigned short >{ static const type type = USHORT; };
        template <> struct type_to_enum< char >          { static const type type = BYTE; };
        template <> struct type_to_enum< unsigned char > { static const type type = UBYTE; };
        template <> struct type_to_enum< f32 > { static const type type = FLOAT; };

        template <> struct type_to_enum< vec2 > { static const type type = FLOAT_VECTOR_2; };
        template <> struct type_to_enum< vec3 > { static const type type = FLOAT_VECTOR_3; };
        template <> struct type_to_enum< vec4 > { static const type type = FLOAT_VECTOR_4; };

        template <> struct type_to_enum< ivec2 > { static const type type = INT_VECTOR_2; };
        template <> struct type_to_enum< ivec3 > { static const type type = INT_VECTOR_3; };
        template <> struct type_to_enum< ivec4 > { static const type type = INT_VECTOR_4; };

        template <> struct type_to_enum< mat2 > { static const type type = FLOAT_MATRIX_2; };
        template <> struct type_to_enum< mat3 > { static const type type = FLOAT_MATRIX_3; };
        template <> struct type_to_enum< mat4 > { static const type type = FLOAT_MATRIX_4; };

        template <typename TYPE>
    inline const char* get_type_name()
    {
        static_assert< FALSE >( "Type not implemented!" );
    }

    template <> inline const char* get_type_name<sint8> () { return "sint8"; }
    template <> inline const char* get_type_name<sint16>() { return "sint16"; }
    template <> inline const char* get_type_name<sint32>() { return "sint32"; }
    template <> inline const char* get_type_name<sint64>() { return "sint64"; }

        template <> inline const char* get_type_name<uint8> () { return "uint8"; }
    template <> inline const char* get_type_name<uint16>() { return "uint16"; }
    template <> inline const char* get_type_name<uint32>() { return "uint32"; }
    template <> inline const char* get_type_name<uint64>() { return "uint64"; }

        template <> inline const char* get_type_name<f32> () { return "f32"; }
        template <> inline const char* get_type_name<f64> () { return "f64"; }

        template <> inline const char* get_type_name<bool> () { return "bool"; }

        template <> inline const char* get_type_name<std::string> () { return "string"; }

        template <typename TYPE>
    std::size_t get_type_id()
    {
        static std::size_t type_id = std::hash<std::string>()(std::string(get_type_name<TYPE>()));
        return type_id;
    };

        struct hash_string
    {
        std::size_t hash;
        const char* text;
                hash_string() {}
                hash_string( const char* a_text ) : 
                        text( a_text ) 
                {
                        hash = std::hash<std::string>()( std::string( a_text ) ); 
                }
                inline bool operator == (const hash_string& hs ) const
                {
                        return hs.hash == hash;
                }
    };

}

namespace std {
        template<>
        struct hash<nv::hash_string> {
                size_t operator()(const nv::hash_string &hs) const 
                {
                        return hs.hash;
                }
        };
}

namespace nv
{

    struct type_entry
    {
                 // Function types for the constructor and destructor of registered types
            typedef void (*constructor_func)(void*);
            typedef void (*destructor_func)(void*);

                // Parent type database
        class type_database* type_db;

        // Scoped C++ name of the type
        hash_string name;
 
        // Pointers to the constructor and destructor functions
        constructor_func constructor;
        destructor_func  destructor;
 
        // Result of sizeof(type) operation
        size_t size;
    };
 
    class type_database
    {
    public:
                template< typename TYPE >
        type_entry& create_type()
                {
                        hash_string name( get_type_name<TYPE>() );
                        type_entry* i_type = nullptr;
                        type_map::iterator it = m_types.find( name );
                        if ( it != m_types.end() ) 
                        {
                                return *(it->second);
                        }
                        i_type          = new type_entry;
                        i_type->type_db = this;
                        i_type->name    = name;
                        i_type->size    = sizeof(TYPE);
                        
                        i_type->constructor = ConstructObject<TYPE>;
                        i_type->destructor  = DestructObject<TYPE>;

                        m_types[name] = i_type;
                        return *i_type;
                }
        type_entry* get_type( hash_string name )
                {
                        type_map::iterator it = m_types.find( name );
                        if ( it != m_types.end() ) 
                        {
                                return it->second;
                        }
                        return nullptr;
                }
    private:
        typedef std::unordered_map<hash_string, type_entry*> type_map;
        type_map m_types;
        };

        template <typename TYPE> void ConstructObject(void* object)
    {
        // Use placement new to call the constructor
        new (object) TYPE;
    }
    template <typename TYPE> void DestructObject(void* object)
    {
        // Explicit call of the destructor
        ((TYPE*)object)->TYPE::~TYPE();
    }

}

#endif NV_TYPES_HH