CClassInfo.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <typeinfo>
 
// Qt includes
#include <QtCore/QByteArray>
 
// ACF 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);
    CClassInfo(CClassInfo const&) = default;
 
       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