CComponentBase.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
 
 
// ACF includes
#include <istd/CClassInfo.h>
#include <iattr/TAttribute.h>
#include <iattr/TMultiAttribute.h>
#include <icomp/IComponent.h>
#include <icomp/ICompositeComponent.h>
#include <icomp/IRealComponentStaticInfo.h>
#include <icomp/TInterfaceRegistrator.h>
#include <icomp/TAttributeMember.h>
#include <icomp/TMultiAttributeMember.h>
#include <icomp/TReferenceMember.h>
#include <icomp/TMultiReferenceMember.h>
#include <icomp/TFactoryMember.h>
#include <icomp/TMultiFactoryMember.h>
#include <icomp/TAttributeStaticInfo.h>
#include <icomp/TComponentStaticInfo.h>
#include <icomp/TSubelementStaticInfo.h>
#include <icomp/CBaseComponentStaticInfo.h>
#include <icomp/CRelatedInfoRegistrator.h>
 
 
namespace icomp
{
 
 
class CComponentBase: virtual public IComponent
{
public:
       CComponentBase();
 
       // reimplemented (icomp::IComponent)
       virtual const icomp::IComponent* GetParentComponent(bool ownerOnly = false) const override;
       virtual void* GetInterface(const istd::CClassInfo& interfaceType, const QByteArray& subId = "") override;
       virtual IComponentContextSharedPtr GetComponentContext() const override;
       virtual void SetComponentContext(
                            const IComponentContextSharedPtr& contextPtr,
                            const icomp::IComponent* parentPtr,
                            bool isParentOwner) override;
 
protected:
       bool IsComponentActive() const;
 
       virtual void OnComponentCreated();
       virtual void OnComponentDestroyed();
 
       // abstract methods
       virtual const icomp::IRealComponentStaticInfo& GetComponentStaticInfo() const = 0;
 
       // static protected methods
       static const icomp::IRealComponentStaticInfo& InitStaticInfo(IComponent* componentPtr);
       static QByteArray GetComponentId(const icomp::IComponentContext* componentContextPtr, const QByteArray& contextId = QByteArray());
 
private:
       Q_DISABLE_COPY(CComponentBase)
 
       IComponentContextSharedPtr m_contextPtr;
       const icomp::IComponent* m_parentPtr;
 
       bool m_isParentOwner;
};
 
 
// inline protected methods
 
inline bool CComponentBase::IsComponentActive() const
{
       return (m_contextPtr != nullptr);
}
 
 
} // namespace icomp
 
 
#define I_BEGIN_COMPONENT(ComponentType)\
       typedef ComponentType CurrentComponentType;\
       static const icomp::IRealComponentStaticInfo& InitStaticInfo(ComponentType* componentPtr)\
       {\
              static icomp::TComponentStaticInfo<ComponentType> staticInfo(&BaseClass::InitStaticInfo(nullptr));\
              static bool isStaticInitialized = false;\
              if (isStaticInitialized && (componentPtr == nullptr)){\
                     return staticInfo;\
              }\
              isStaticInitialized = true;\
              BaseClass::InitStaticInfo(componentPtr);
 
#define I_BEGIN_BASE_COMPONENT(ComponentType)\
       typedef ComponentType CurrentComponentType;\
       static const icomp::IRealComponentStaticInfo& InitStaticInfo(ComponentType* componentPtr)\
       {\
              static icomp::CBaseComponentStaticInfo staticInfo(&BaseClass::InitStaticInfo(nullptr));\
              static bool isStaticInitialized = false;\
              if (isStaticInitialized && (componentPtr == nullptr)){\
                     return staticInfo;\
              }\
              isStaticInitialized = true;\
              BaseClass::InitStaticInfo(componentPtr);
 
#define I_END_COMPONENT\
              return staticInfo;\
       }\
       virtual const icomp::IRealComponentStaticInfo& GetComponentStaticInfo() const override\
       {\
              return InitStaticInfo(nullptr);\
       }
 
#define I_REGISTER_INTERFACE(InterfaceType)\
       {\
              static icomp::TInterfaceRegistrator<InterfaceType> staticRegistrator(staticInfo);\
              Q_UNUSED(staticRegistrator);\
       }
 
#define I_REGISTER_SUBELEMENT(ElementName)\
       static icomp::TSubelementStaticInfo<CurrentComponentType> subelementInfo_##ElementName(#ElementName, staticInfo);
 
#define I_REGISTER_SUBELEMENT_INTERFACE(ElementName, InterfaceType, extractorFunction)\
       {\
              static icomp::SubElementInterfaceRegistrator<InterfaceType, CurrentComponentType> staticRegistrator(\
                                   subelementInfo_##ElementName,\
                                   extractorFunction);\
              Q_UNUSED(staticRegistrator);\
       }
 
#define I_REGISTER_SUBELEMENT_INTERFACE_T(ElementName, InterfaceType, extractorFunction)\
       {\
              static icomp::SubElementInterfaceRegistrator<InterfaceType, CurrentComponentType> staticRegistrator(\
                                   subelementInfo_##ElementName,\
                                   extractorFunction<InterfaceType>);\
              Q_UNUSED(staticRegistrator);\
       }
 
#define I_USER_ATTR(attrType, member)\
       typedef icomp::TAttributeMember< attrType > member##_Type;\
       typedef icomp::TAttributeMember< attrType >::AttributeType member##_AttrType;\
       icomp::TAttributeMember< attrType > member
 
#define I_ATTR(attrType, member)\
       I_USER_ATTR(iattr::TAttribute< attrType >, member)
 
#define I_TEXTATTR(member)\
       typedef icomp::CTextAttributeMember member##_Type;\
       typedef icomp::CTextAttributeMember::AttributeType member##_AttrType;\
       icomp::CTextAttributeMember member
 
#define I_USER_MULTIATTR(attrType, member)\
       typedef icomp::TMultiAttributeMember< attrType > member##_Type;\
       typedef icomp::TMultiAttributeMember< attrType >::AttributeType member##_AttrType;\
       icomp::TMultiAttributeMember< attrType > member
 
#define I_MULTIATTR(attrType, member)\
       I_USER_MULTIATTR(iattr::TMultiAttribute< attrType >, member)
 
#define I_MULTITEXTATTR(member)\
       typedef icomp::CMultiTextAttributeMember member##_Type;\
       typedef icomp::CMultiTextAttributeMember::AttributeType member##_AttrType;\
       icomp::CMultiTextAttributeMember member
 
#define I_REF(interfaceType, member)\
       typedef icomp::TReferenceMember<interfaceType> member##_Type;\
       typedef icomp::TReferenceMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TReferenceMember<interfaceType> member
 
#define I_TREF(interfaceType, member)\
       typedef icomp::TReferenceMember<interfaceType> member##_Type;\
       typedef typename icomp::TReferenceMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TReferenceMember<interfaceType> member
 
#define I_TMULTIREF(interfaceType, member)\
       typedef icomp::TMultiReferenceMember<interfaceType> member##_Type;\
       typedef typename icomp::TMultiReferenceMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TMultiReferenceMember<interfaceType> member
 
 
#define I_MULTIREF(interfaceType, member)\
       typedef icomp::TMultiReferenceMember<interfaceType> member##_Type;\
       typedef icomp::TMultiReferenceMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TMultiReferenceMember<interfaceType> member
 
#define I_FACT(interfaceType, member)\
       typedef icomp::TFactoryMember<interfaceType> member##_Type;\
       typedef icomp::TFactoryMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TFactoryMember<interfaceType> member;
 
#define I_TFACT(interfaceType, member)\
       typedef icomp::TFactoryMember<interfaceType> member##_Type;\
       typedef typename icomp::TFactoryMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TFactoryMember<interfaceType> member
 
#define I_MULTIFACT(interfaceType, member)\
       typedef icomp::TMultiFactoryMember<interfaceType> member##_Type;\
       typedef icomp::TMultiFactoryMember<interfaceType>::AttributeType member##_AttrType;\
       icomp::TMultiFactoryMember<interfaceType> member
 
#define I_ASSIGN_BASE(member, id, description, isObligatory)\
       static icomp::TAttributeStaticInfo<member##_AttrType> member##_Info(staticInfo, id, description, &member##_Default, isObligatory? member##_AttrType::DAF_OBLIGATORY: member##_AttrType::DAF_OPTIONAL, istd::CClassInfo::GetInfo<typename member##_Type::InterfaceType>());\
       if (componentPtr != nullptr){\
              componentPtr->member.Init(componentPtr, member##_Info);\
       }
 
#define I_ASSIGN(member, id, description, isObligatory, defaultValue)\
       static member##_AttrType member##_Default(defaultValue);\
       I_ASSIGN_BASE(member, id, description, isObligatory)
 
#define I_ASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)\
       static member##_AttrType member##_Default(int(sizeof(member##_DefaultElements) / sizeof(member##_AttrType::ValueType)), member##_DefaultElements);\
       I_ASSIGN_BASE(member, id, description, isObligatory)
 
#define I_ASSIGN_MULTI_0(member, id, description, isObligatory)\
       static member##_AttrType member##_Default(0, nullptr);\
       I_ASSIGN_BASE(member, id, description, isObligatory)
 
#define I_ASSIGN_MULTI_1(member, id, description, isObligatory, defaultValue1)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1};\
       I_ASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_ASSIGN_MULTI_2(member, id, description, isObligatory, defaultValue1, defaultValue2)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1, defaultValue2};\
       I_ASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_ASSIGN_MULTI_3(member, id, description, isObligatory, defaultValue1, defaultValue2, defaultValue3)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1, defaultValue2, defaultValue3};\
       I_ASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_ASSIGN_MULTI_4(member, id, description, isObligatory, defaultValue1, defaultValue2, defaultValue3, defaultValue4)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1, defaultValue2, defaultValue3, defaultValue4};\
       I_ASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_ASSIGN_MULTI_5(member, id, description, isObligatory, defaultValue1, defaultValue2, defaultValue3, defaultValue4, defaultValue5)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1, defaultValue2, defaultValue3, defaultValue4, defaultValue5};\
       I_ASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_TASSIGN_BASE(member, id, description, isObligatory)\
       static icomp::TAttributeStaticInfo<member##_AttrType> member##_Info(staticInfo, id, description, &member##_Default, isObligatory? member##_AttrType::DAF_OBLIGATORY: member##_AttrType::DAF_OPTIONAL, istd::CClassInfo::GetInfo<typename member##_Type::InterfaceType>());\
       if (componentPtr != nullptr){\
              componentPtr->member.Init(componentPtr, member##_Info);\
       }
 
#define I_TASSIGN(member, id, description, isObligatory, defaultValue)\
       static member##_AttrType member##_Default(defaultValue);\
       I_TASSIGN_BASE(member, id, description, isObligatory)
 
#define I_TASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)\
       static member##_AttrType member##_Default(int(sizeof(member##_DefaultElements) / sizeof(member##_AttrType::ValueType)), member##_DefaultElements);\
       I_TASSIGN_BASE(member, id, description, isObligatory)
 
#define I_TASSIGN_MULTI_0(member, id, description, isObligatory)\
       static member##_AttrType member##_Default(0, nullptr);\
       I_TASSIGN_BASE(member, id, description, isObligatory)
 
#define I_TASSIGN_MULTI_1(member, id, description, isObligatory, defaultValue1)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1};\
       I_TASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_TASSIGN_MULTI_2(member, id, description, isObligatory, defaultValue1, defaultValue2)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1, defaultValue2};\
       I_TASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
#define I_TASSIGN_MULTI_3(member, id, description, isObligatory, defaultValue1, defaultValue2, defaultValue3)\
       static member##_AttrType::ValueType member##_DefaultElements[] = {defaultValue1, defaultValue2, defaultValue3};\
       I_TASSIGN_MULTI_BASE(member, id, description, isObligatory, defaultValue)
 
 
#define I_ASSIGN_TO(member, baseAttribute, isObligatory)\
       static icomp::CRelatedInfoRegistrator member##_Info(baseAttribute##_Info, icomp::IComponentStaticInfo::MGI_INTERFACES, istd::CClassInfo::GetInfo<member##_Type::InterfaceType>().GetName(), isObligatory? member##_AttrType::DAF_OBLIGATORY: member##_AttrType::DAF_OPTIONAL);\
       Q_UNUSED(member##_Info);\
       if (componentPtr != nullptr){\
              componentPtr->member.Init(componentPtr, baseAttribute##_Info);\
       }
 
#define I_TASSIGN_TO(member, baseAttribute, isObligatory)\
       static icomp::CRelatedInfoRegistrator member##_Info(baseAttribute##_Info, icomp::IComponentStaticInfo::MGI_INTERFACES, istd::CClassInfo::GetInfo<typename member##_Type::InterfaceType>().GetName(), isObligatory? member##_AttrType::DAF_OBLIGATORY: member##_AttrType::DAF_OPTIONAL);\
       Q_UNUSED(member##_Info);\
       if (componentPtr != nullptr){\
              componentPtr->member.Init(componentPtr, baseAttribute##_Info);\
       }
 
template <class Dest>
Dest* CompCastPtr(istd::IPolymorphic* objectPtr)
{
       const icomp::IComponent* componentPtr = dynamic_cast<const icomp::IComponent*>(objectPtr);
       if (componentPtr != nullptr){
              icomp::ICompositeComponent* parentComponentPtr = const_cast<icomp::ICompositeComponent*>(dynamic_cast<const icomp::ICompositeComponent*>(componentPtr->GetParentComponent(true)));
 
              if (parentComponentPtr != nullptr){
                     Dest* retVal = (Dest*)parentComponentPtr->GetInterface(istd::CClassInfo(typeid(Dest)));
 
                     if (retVal != nullptr){
                            return retVal;
                     }
              }
       }
 
       return dynamic_cast<Dest*>(objectPtr);
}
 
 
template <class Dest>
const Dest* CompCastPtr(const istd::IPolymorphic* objectPtr)
{
       const icomp::IComponent* componentPtr = dynamic_cast<const icomp::IComponent*>(objectPtr);
       if (componentPtr != nullptr){
              icomp::ICompositeComponent* parentComponentPtr = const_cast<icomp::ICompositeComponent*>(dynamic_cast<const icomp::ICompositeComponent*>(componentPtr->GetParentComponent(true)));
              if (parentComponentPtr != nullptr){
                     const Dest* retVal = (const Dest*)parentComponentPtr->GetInterface(istd::CClassInfo(typeid(Dest)));
 
                     if (retVal != nullptr){
                            return retVal;
                     }
              }
       }
 
       return dynamic_cast<const Dest*>(objectPtr);
}
 
 
template <class Dest>
Dest* QueryInterface(istd::IPolymorphic* objectPtr, const QByteArray& componentId = QByteArray())
{
       const icomp::IComponent* componentPtr = dynamic_cast<const icomp::IComponent*>(objectPtr);
       if (componentPtr != nullptr) {
              icomp::ICompositeComponent* parentComponentPtr = const_cast<icomp::ICompositeComponent*>(dynamic_cast<const icomp::ICompositeComponent*>(componentPtr->GetParentComponent(true)));
              if (parentComponentPtr != nullptr) {
                     Dest* retVal = (Dest*)parentComponentPtr->GetInterface(istd::CClassInfo(typeid(Dest)), componentId);
                     if (retVal != nullptr) {
                            return retVal;
                     }
 
                     return QueryInterface<Dest>(parentComponentPtr, componentId);
              }
       }
 
       return nullptr;
}