CSimComponentContextBase.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/QString>
#include <QtCore/QMap>
 
// ACF includes
#include <istd/TIFactory.h>
#include <istd/CIdManipBase.h>
#include <icomp/IAttributeStaticInfo.h>
#include <iattr/TAttribute.h>
#include <iattr/TMultiAttribute.h>
#include <icomp/IComponent.h>
#include <icomp/IComponentContext.h>
#include <icomp/IComponentStaticInfo.h>
#include <icomp/TAttributeMember.h>
#include <icomp/TMultiAttributeMember.h>
#include <icomp/CRegistryElement.h>
 
 
namespace icomp
{
 
 
class CSimComponentContextBase:
                     public IComponentContext,
                     protected istd::CIdManipBase
{
public:
       typedef istd::TIFactory<icomp::IComponent> ComponentsFactory;
 
       explicit CSimComponentContextBase(const IComponentStaticInfo* infoPtr);
 
       bool SetAttr(const QByteArray& attributeId, const iser::IObject* attributePtr);
 
       bool SetRef(const QByteArray& referenceId, IComponentSharedPtr componentPtr, const QByteArray& subelementId = "");
 
       bool InsertMultiRef(const QByteArray& referenceId, IComponentSharedPtr componentPtr, const QByteArray& subelementId = "");
 
       bool SetFactory(const QByteArray& factoryId, const ComponentsFactory* factoryPtr);
 
       bool InsertMultiFactory(const QByteArray& factoryId, const ComponentsFactory* factoryPtr);
 
       bool SetBoolAttr(const QByteArray& attributeId, bool value);
 
       bool SetIntAttr(const QByteArray& attributeId, int value);
 
       bool SetDoubleAttr(const QByteArray& attributeId, double value);
 
       bool SetStringAttr(const QByteArray& attributeId, const QString& value);
 
       bool SetIdAttr(const QByteArray& attributeId, const QByteArray& value);
 
       template <class Attribute>
       bool InsertMultiAttr(const QByteArray& attributeId, const Attribute& attribute)
       {
              Q_ASSERT(IsAttributeTypeCorrect<iattr::TMultiAttribute<Attribute> >(attributeId));
 
              iattr::TMultiAttribute<Attribute>* multiAttrPtr = NULL;
 
              const IRegistryElement::AttributeInfo* existingInfoPtr = m_registryElement.GetAttributeInfo(attributeId);
              if (existingInfoPtr != NULL){
                     multiAttrPtr = dynamic_cast<iattr::TMultiAttribute<Attribute>*>(existingInfoPtr->attributePtr.GetPtr());
              }
              else{
                     IRegistryElement::AttributeInfo* newInfoPtr = m_registryElement.InsertAttributeInfo(attributeId, istd::CClassInfo::GetName<iattr::TMultiAttribute<Attribute> >());
                     if (newInfoPtr != NULL){
                            IRegistryElement::AttributePtr& attributePtr = newInfoPtr->attributePtr;
                            if (!attributePtr.IsValid()){
                                   attributePtr.SetPtr(new iattr::TMultiAttribute<Attribute>);
                            }
 
                            multiAttrPtr = dynamic_cast<iattr::TMultiAttribute<Attribute>*>(attributePtr.GetPtr());
                     }
              }
 
              if (multiAttrPtr != NULL){
                     multiAttrPtr->InsertValue(attribute);
 
                     return true;
              }
 
              return false;
       }
 
       bool InsertMultiAttr(const QByteArray& attributeId, const QString& attribute);
 
       // reimplemeted (icomp::IComponentContext)
       virtual const IRegistryElement& GetRegistryElement() const override;
       virtual const IComponentStaticInfo& GetStaticInfo() const override;
       virtual const IComponentContext* GetParentContext() const override;
       virtual const iser::IObject* GetAttribute(const QByteArray& attributeId, int* definitionLevelPtr = NULL) const override;
 
protected:
       template <class AttrType>
       bool IsAttributeTypeCorrect(const QByteArray& attributeId);
 
       typedef QMap<QByteArray, IComponentSharedPtr> ComponentsMap;
       ComponentsMap m_componentsMap;
 
       typedef QMap< QByteArray, const ComponentsFactory* > FactoriesMap;
       FactoriesMap m_factoriesMap;
 
private:
       CRegistryElement m_registryElement;
       const IComponentStaticInfo& m_metaInfo;
};
 
 
// protected methods
 
template <class AttrType>
bool CSimComponentContextBase::IsAttributeTypeCorrect(const QByteArray& attributeId)
{
       const IAttributeStaticInfo* attributeInfoPtr = m_metaInfo.GetAttributeInfo(attributeId);
       if (attributeInfoPtr != NULL){
              QByteArray attributeType = attributeInfoPtr->GetAttributeTypeId();
 
              return attributeType == AttrType::GetTypeName();
       }
 
       return false;
}
 
 
} // namespace icomp