Reflection.h

Go to the documentation of this file.

#ifndef REFLECTION_H
#define REFLECTION_H

#include <typeinfo>
#include <vector>

#define GET_TYPE_ID(lValue, constCharPtr){const std::type_info& typeInfo = typeid(lValue); constCharPtr = typeInfo.name();}

class IReflect
{
public:
    virtual ~IReflect() { }
};

class IType
{
public:
    virtual const char* getTypeId() = 0;

    virtual size_t getSize() = 0;

    virtual IReflect* createInstance() = 0;
};

class TypeManager
{
private:
    static std::vector<IType*> _types;

    template<class ClassType>
    class Type : public IType
    {
    protected:
        const char* _typeName;
    public:

        Type()
        {
            //the typeid mechanism maintains type_info instances
            //in at least VS2005, it is safe to hold onto just the name reference
            //this may not be safe in all compilers
            //ClassType type;
            const std::type_info & typeInfo = typeid(ClassType);

            _typeName = typeInfo.name();
        }       

        virtual const char* getTypeId()
        {
            return _typeName;
        };

        virtual size_t getSize()
        {
            return sizeof(ClassType);
        }

        virtual IReflect* createInstance()
        {
            //If ClassType does not implement IReflect,
            //then we must be cautious to not cause a memory leak
            ClassType* instance = new ClassType();
            IReflect* reflected = dynamic_cast<IReflect*>(instance);
            if(reflected == NULL)
                delete instance;
            return reflected;
        }
    };

public:
    static void Release()
    {
        for(size_t i=0; i<_types.size(); ++i)
        {
            IType* t = _types[i];
            delete t;
        }
    }
    template<class ClassType>
    static bool ContainsType()
    {
        Type<ClassType> type;

        for(size_t i=0; i<_types.size(); ++i)
            if(strcmp(_types[i]->getTypeId(), type.getTypeId) == 0)
                return true;

        return false;
    }

    template<class ClassType>
    static IType* GetType()
    {
        Type<ClassType>* type = new Type<ClassType>();
        for(size_t i=0; i<_types.size(); ++i)
            if(strcmp(_types[i]->getTypeId(), type->getTypeId()) == 0)
            {
                //delete type we created, we already have one
                delete type;
                return _types[i];
            }

        IType* ptr = dynamic_cast<IType*>(type);
        //do not delete type, because now it's going into the vector
        _types.push_back(ptr);
        return ptr;
    }

    static IType* GetType(const char* typeId)
    {
        for(size_t i=0; i<_types.size(); ++i)
            if(strcmp(_types[i]->getTypeId(), typeId) == 0)
                return _types[i];

        return NULL;
    }

    static IType* GetType(IReflect* object)
    {
        const std::type_info& typeInfo = typeid(*object);
        return GetType(typeInfo.name());
    }

    template<class ClassType>
    static const char* GetTypeId()
    {
        const std::type_info& typeInfo = typeid(ClassType);
        return typeInfo.name();
    }

    static size_t GetSize(IReflect* object)
    {
        IType* type = GetType(object);
        if(type == NULL)
            return 0;
        return type->getSize();
    }

    template<class ClassType>
    static ClassType CastType(void* object)
    {
        if(object == NULL)
            return NULL;
        ClassType ret = (ClassType)object;
        return dynamic_cast<ClassType>(ret);
    }
};

#endif