CClassInfo.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// STL includes
#include <typeinfo>
 
// Qt includes
#include <QtCore/QByteArray>
 
// ICF includes
#include <istd/IPolymorphic.h>
 
 
namespace istd
{
 
 
class CClassInfo: virtual public istd::IPolymorphic
{
public:
    CClassInfo();
    explicit CClassInfo(const std::type_info& info);
    explicit CClassInfo(const QByteArray& name);
    explicit CClassInfo(const istd::IPolymorphic& object);
 
    bool IsValid() const;
    const QByteArray& GetName() const;
 
    bool IsVoid() const;
 
    bool IsConst() const;
 
    CClassInfo GetConstCasted(bool enableConst = true) const;
 
    bool ConstCast(bool enableConst = true);
 
    bool IsTemplateClass() const;
    int GetTemplateParamsCount() const;
    CClassInfo GetTemplateParam(int paramIndex = 0) const;
 
    template <class C>
    bool IsType() const;
 
    CClassInfo& operator=(const std::type_info& info);
    CClassInfo& operator=(const CClassInfo& info);
    bool operator==(const CClassInfo& info) const;
    bool operator!=(const CClassInfo& info) const;
    bool operator<(const CClassInfo& info) const;
    bool operator>(const CClassInfo& info) const;
 
    // static methods
    template <class C>
    static CClassInfo GetInfo();
    template <class C>
    static QByteArray GetName();
    static QByteArray GetName(const std::type_info& info);
    static QByteArray GetName(const istd::IPolymorphic& object);
 
    static QByteArray GetUndecoratedName(const QByteArray& rawName);
 
private:
    QByteArray m_name;
};
 
 
// inline methods
 
inline CClassInfo::CClassInfo()
{
}
 
 
inline CClassInfo::CClassInfo(const std::type_info& info)
:   m_name(GetName(info))
{
}
 
 
inline CClassInfo::CClassInfo(const QByteArray& name)
:   m_name(GetUndecoratedName(name))
{
}
 
 
inline CClassInfo::CClassInfo(const istd::IPolymorphic& object)
:   m_name(GetUndecoratedName(typeid(object).name()))
{
}
 
 
inline bool CClassInfo::IsValid() const
{
    return !m_name.isEmpty();
}
 
 
inline const QByteArray& CClassInfo::GetName() const
{
    return m_name;
}
 
 
inline bool CClassInfo::IsVoid() const
{
    return *this == istd::CClassInfo::GetInfo<void>();
}
 
 
template <class C>
inline bool CClassInfo::IsType() const
{
    return m_name == GetName(typeid(C));
}
 
 
inline CClassInfo& CClassInfo::operator=(const std::type_info& info)
{
    m_name = GetName(info);
 
    return *this;
}
 
 
inline CClassInfo& CClassInfo::operator=(const CClassInfo& info)
{
    m_name = info.m_name;
 
    return *this;
}
 
 
inline bool CClassInfo::operator==(const CClassInfo& info) const
{
    return m_name == info.m_name;
}
 
 
inline bool CClassInfo::operator!=(const CClassInfo& info) const
{
    return m_name != info.m_name;
}
 
 
inline bool CClassInfo::operator<(const CClassInfo& info) const
{
    return m_name < info.m_name;
}
 
 
inline bool CClassInfo::operator>(const CClassInfo& info) const
{
    return m_name > info.m_name;
}
 
 
// public static methods
 
template <class C>
CClassInfo CClassInfo::GetInfo()
{
    CClassInfo retVal(typeid(C));
 
    return retVal;
}
 
 
template <class C>
QByteArray CClassInfo::GetName()
{
    return GetUndecoratedName(typeid(C).name());
}
 
 
} // namespace istd