TSubelementStaticInfo.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
 
 
// Qt includes
#include <QtCore/QByteArray>
#include <QtCore/QMap>
 
// ACF includes
#include <icomp/IElementStaticInfo.h>
#include <icomp/CBaseComponentStaticInfo.h>
 
 
namespace icomp
{
 
 
template <class ComponentType>
class TSubelementStaticInfo:
                     virtual public IElementStaticInfo,
                     virtual public IComponentInterfaceExtractor
{
public:
       typedef void* (*InterfaceExtractorPtr)(ComponentType& component);
 
       TSubelementStaticInfo(const QByteArray& name, CBaseComponentStaticInfo& owner);
 
       virtual void RegisterInterfaceExtractor(const QByteArray& interfaceName, InterfaceExtractorPtr extractorPtr);
 
       //     reimplemented (icomp::IElementStaticInfo)
       virtual Ids GetMetaIds(int metaGroupId) const override;
       virtual const IElementStaticInfo* GetSubelementInfo(const QByteArray& subcomponentId) const override;
 
       //     reimplemented (icomp::IComponentInterfaceExtractor)
       virtual void* GetComponentInterface(
                            const istd::CClassInfo& interfaceType,
                            IComponent& component,
                            const QByteArray& subId) const override;
 
private:
       typedef QMap<QByteArray, InterfaceExtractorPtr> InterfaceExtractors;
       InterfaceExtractors m_interfaceExtractors;
};
 
 
template <class InterfaceType, class ComponentType>
class SubElementInterfaceRegistrator
{
public:
       typedef void* (*InterfaceExtractorPtr)(ComponentType& component);
       typedef InterfaceType* (*ExtractorPtr)(ComponentType& component);
 
       SubElementInterfaceRegistrator(TSubelementStaticInfo<ComponentType>& staticInfo, ExtractorPtr extractorPtr)
       {
              istd::CClassInfo interfaceInfo = istd::CClassInfo::GetInfo<InterfaceType>();
 
              staticInfo.RegisterInterfaceExtractor(interfaceInfo.GetName(), reinterpret_cast<InterfaceExtractorPtr>(extractorPtr));
       }
};
 
 
// public methods
 
template <class ComponentType>
TSubelementStaticInfo<ComponentType>::TSubelementStaticInfo(const QByteArray& name, CBaseComponentStaticInfo& owner)
{
       owner.RegisterSubelementInfo(name, this);
}
 
 
template <class ComponentType>
void TSubelementStaticInfo<ComponentType>::RegisterInterfaceExtractor(const QByteArray& interfaceName, InterfaceExtractorPtr extractorPtr)
{
       m_interfaceExtractors[interfaceName] = extractorPtr;
}
 
 
//     reimplemented (icomp::IElementStaticInfo)
 
template <class ComponentType>
IElementStaticInfo::Ids TSubelementStaticInfo<ComponentType>::GetMetaIds(int metaGroupId) const
{
       Ids retVal;
 
       if (metaGroupId == MGI_INTERFACES){
              for (         typename InterfaceExtractors::const_iterator iter = m_interfaceExtractors.begin();
                                   iter != m_interfaceExtractors.end();
                                   ++iter){
                     retVal.insert(iter.key());
              }
       }
 
       return retVal;
}
 
 
template <class ComponentType>
const IElementStaticInfo* TSubelementStaticInfo<ComponentType>::GetSubelementInfo(const QByteArray& /*subcomponentId*/) const
{
       return nullptr;
}
 
 
//     reimplemented (icomp::IComponentInterfaceExtractor)
 
template <class ComponentType>
void* TSubelementStaticInfo<ComponentType>::GetComponentInterface(
                     const istd::CClassInfo& interfaceType,
                     IComponent& component,
                     const QByteArray& subId) const
{
       ComponentType* nativeTypePtr = dynamic_cast<ComponentType*>(&component);
       if ((nativeTypePtr != nullptr) && subId.isEmpty()){
              if (!interfaceType.IsValid() || interfaceType.IsVoid() || (interfaceType == CBaseComponentStaticInfo::s_compInterfaceType)){
                     return &component;
              }
 
              typename InterfaceExtractors::ConstIterator foundIter = m_interfaceExtractors.constFind(interfaceType.GetName());
              if (foundIter != m_interfaceExtractors.constEnd()){
                     InterfaceExtractorPtr extractorPtr = foundIter.value();
 
                     return extractorPtr(*nativeTypePtr);
              }
 
              if (interfaceType.IsConst()){
                     istd::CClassInfo nonConstType = interfaceType.GetConstCasted(false);
 
                     foundIter = m_interfaceExtractors.constFind(nonConstType.GetName());
                     if (foundIter != m_interfaceExtractors.constEnd()){
                            InterfaceExtractorPtr extractorPtr = foundIter.value();
 
                            return extractorPtr(*nativeTypePtr);
                     }
              }
       }
 
       return nullptr;
}
 
 
} // namespace icomp