Type.h

Go to the documentation of this file.

#pragma once
#include <map>
#include <set>
#include <string>
#include <vector>
 
 
namespace Base
{
struct TypeData;
 
 
class LX_BASE_EXPORT Type
{
public:
    Type(const Type& type);
    Type(void);
    virtual ~Type() = default;
 
    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;
 
    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