Type.h

Go to the documentation of this file.

#ifndef __Type_H__
#define __Type_H__

// Std. configurations
#pragma warning(disable : 4251)
#include <Base/base_defines.h>

#include <map>
#include <set>
#include <string>
#include <vector>


namespace Base
{
struct TypeData;


class BASE_EXPORT Type
{
public:
    Type(const Type& type);
    Type(void);
    virtual ~Type();

    void* createInstance(void);
    static void* createInstanceByName(const char* TypeName, bool bLoadModule = false);

    typedef void* (*instantiationMethod)(void);

    static Type fromName(const char* name);

    inline const Type getParent(void) const;
    inline void getChildren(std::set<Type>& children) const;
    inline void getAllChildren(std::set<Type>& children) const;
    inline bool isDerivedFrom(const Type type) const;
    inline bool isDerivedFrom(const std::vector<Base::Type>& types) const;

    static int getAllDerivedFrom(const Type type, std::vector<Type>& List);
    static std::vector<Type> getAllDerivedFrom(const Type type);
    static std::string getHierarchyAsString(Base::Type t);

    static int getNumTypes(void);

    static const Type createType(const Type parent, const char* name, instantiationMethod method = 0);

    unsigned int getKey(void) const;
    bool isBad(void) const;
    const std::string& getName(void) const;

    inline void operator=(const Type type);
    inline bool operator==(const Type type) const;
    inline bool operator!=(const Type type) const;

    inline bool operator<(const Type type) const;
    inline bool operator<=(const Type type) const;
    inline bool operator>=(const Type type) const;
    inline bool operator>(const Type type) const;

    inline static const Type badType(void) { return Type(); }
    static void init(void);

protected:
    static std::string getModuleName(const char* ClassName);


private:
    unsigned int index;

#pragma warning(disable : 4251)
    static std::map<std::string, unsigned int> typemap;
    static std::vector<TypeData*> typedata;
    static std::set<std::string> loadModuleSet;

    static std::vector<unsigned int> typeVector;
    static std::map<unsigned int, unsigned int> typederivated;
};


inline unsigned int Type::getKey(void) const
{
    return this->index;
}

inline bool Type::operator!=(const Type type) const
{
    return (this->getKey() != type.getKey());
}

inline void Type::operator=(const Type type)
{
    this->index = type.getKey();
}

inline bool Type::operator==(const Type type) const
{
    return (this->getKey() == type.getKey());
}

inline bool Type::operator<(const Type type) const
{
    return (this->getKey() < type.getKey());
}

inline bool Type::operator<=(const Type type) const
{
    return (this->getKey() <= type.getKey());
}

inline bool Type::operator>=(const Type type) const
{
    return (this->getKey() >= type.getKey());
}

inline bool Type::operator>(const Type type) const
{
    return (this->getKey() > type.getKey());
}

inline bool Type::isBad(void) const
{
    return (this->index == 0);
}



}  // namespace Base

#endif  // __FILETEMPLATE_H__