TFactoryMember.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/TInterfaceFactory.h>
#include <istd/TDelPtr.h>
 
#include <icomp/TAttributeMember.h>
#include <icomp/CInterfaceManipBase.h>
#include <icomp/CFactoryAttribute.h>
 
 
namespace icomp
{
 
 
template <class Interface>
class TFactoryMember:
                     public TAttributeMember<CFactoryAttribute>,
                     public CInterfaceManipBase,
                     virtual public istd::TInterfaceFactory<Interface>
{
public:
       typedef TAttributeMember<CFactoryAttribute> BaseClass;
       typedef CInterfaceManipBase BaseClass2;
       typedef Interface InterfaceType;
       typedef istd::IFactoryInfo::KeyList KeyList;
 
       TFactoryMember();
 
       void Init(const IComponent* ownerPtr, const IRealAttributeStaticInfo& staticInfo);
 
       bool IsValid() const;
 
       IComponentUniquePtr CreateComponent() const;
 
       static Interface* ExtractInterface(istd::IPolymorphic* instancePtr, const QByteArray& subId = "");
 
       // reimplemented (TInterfaceFactory)
       virtual istd::TUniqueInterfacePtr<Interface> CreateInstance(const QByteArray& typeId = QByteArray()) const override;
 
       // reimplemented (istd::IFactoryInfo)
       virtual KeyList GetFactoryKeys() const override;
 
protected:
       TFactoryMember(const TFactoryMember& ptr);
 
private:
       const IComponent* m_definitionComponentPtr;
};
 
 
// public methods
 
template <class Interface>
TFactoryMember<Interface>::TFactoryMember()
:      m_definitionComponentPtr(NULL)
{
}
 
 
template <class Interface>
void TFactoryMember<Interface>::Init(const IComponent* ownerPtr, const IRealAttributeStaticInfo& staticInfo)
{
       BaseClass::InitInternal(ownerPtr, staticInfo, &m_definitionComponentPtr);
}
 
 
template <class Interface>
bool TFactoryMember<Interface>::IsValid() const
{
       return (m_definitionComponentPtr != NULL) && BaseClass::IsValid();
}
 
 
 
template <class Interface>
IComponentUniquePtr TFactoryMember<Interface>::CreateComponent() const
{
       if ((m_definitionComponentPtr != NULL) && BaseClass::IsValid()){
              const ICompositeComponent* parentPtr = dynamic_cast<const ICompositeComponent*>(m_definitionComponentPtr->GetParentComponent());
              if (parentPtr != NULL){
                     const QByteArray& componentId = BaseClass::operator*();
 
                     QByteArray baseId;
                     QByteArray subId;
                     BaseClass2::SplitId(componentId, baseId, subId);
                     Q_ASSERT(subId.isEmpty());  // explicit subelement ID are not implemented correctly
 
                     return parentPtr->CreateSubcomponent(baseId);
              }
              else{
                     qCritical("Component %s is defined, but definition component has no parent", BaseClass::operator*().constData());
              }
       }
 
       return nullptr;
}
 
 
template <class Interface>
istd::TUniqueInterfacePtr<Interface> TFactoryMember<Interface>::CreateInstance(const QByteArray& /*typeId*/) const
{
       IComponentUniquePtr newComponentPtr = CreateComponent();
       if (newComponentPtr != nullptr){
              Interface* retVal = BaseClass2::ExtractInterface<Interface>(newComponentPtr.get());
              if (retVal != NULL) {
                     return istd::TUniqueInterfacePtr<Interface>(newComponentPtr.release(), retVal);
              }
       }
 
       return istd::TUniqueInterfacePtr<Interface>();
}
 
 
// reimplemented (istd::IFactoryInfo)
 
template <class Interface>
istd::IFactoryInfo::KeyList TFactoryMember<Interface>::GetFactoryKeys() const
{
       static KeyList defaultList;
       if (defaultList.isEmpty()){
              defaultList << "Component";
       }
 
       return defaultList;
}
 
 
// static methods
 
template <class Interface>
Interface* TFactoryMember<Interface>::ExtractInterface(istd::IPolymorphic* instancePtr, const QByteArray& subId)
{
       if (instancePtr != NULL){
              icomp::IComponent* componentPtr = dynamic_cast<icomp::IComponent*>(instancePtr);
              Q_ASSERT(componentPtr != NULL);    // Only objects returned by \b CreateComponent should be used as input
 
              if (componentPtr != NULL){
                     return BaseClass2::ExtractInterface<Interface>(componentPtr, subId);
              }
       }
 
       return NULL;
}
 
 
// protected methods
 
template <class Interface>
TFactoryMember<Interface>::TFactoryMember(const TFactoryMember& ptr)
:      BaseClass(ptr),
       m_definitionComponentPtr(ptr.m_definitionComponentPtr)
{
}
 
 
} // namespace icomp