TMultiFactoryMember.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// ICF includes
#include <icomp/TMultiAttributeMember.h>
#include <icomp/CInterfaceManipBase.h>
#include <icomp/CMultiFactoryAttribute.h>
 
 
namespace icomp
{
 
 
template <class Interface>
class TMultiFactoryMember: public TMultiAttributeMember<CMultiFactoryAttribute>, public CInterfaceManipBase
{
public:
    typedef TMultiAttributeMember<CMultiFactoryAttribute> BaseClass;
    typedef CInterfaceManipBase BaseClass2;
    typedef Interface InterfaceType;
 
    TMultiFactoryMember();
 
    void Init(const IComponent* ownerPtr, const IRealAttributeStaticInfo& staticInfo);
 
    bool IsValid() const;
 
    std::unique_ptr<IComponent> CreateComponent(int index) const;
 
    std::unique_ptr<Interface> CreateInstance(int index) const;
 
    static Interface* ExtractInterface(IComponent* componentPtr, const QByteArray& subId = "");
 
protected:
    TMultiFactoryMember(const TMultiFactoryMember& ptr);
 
private:
    const IComponent* m_definitionComponentPtr;
};
 
 
// public methods
 
template <class Interface>
TMultiFactoryMember<Interface>::TMultiFactoryMember()
:   m_definitionComponentPtr(nullptr)
{
}
 
 
template <class Interface>
void TMultiFactoryMember<Interface>::Init(const IComponent* ownerPtr, const IRealAttributeStaticInfo& staticInfo)
{
    BaseClass::InitInternal(ownerPtr, staticInfo, &m_definitionComponentPtr);
}
 
 
template <class Interface>
bool TMultiFactoryMember<Interface>::IsValid() const
{
    return (m_definitionComponentPtr != nullptr) && BaseClass::IsValid();
}
 
 
 
template <class Interface>
std::unique_ptr<IComponent> TMultiFactoryMember<Interface>::CreateComponent(int index) const
{
    if ((m_definitionComponentPtr != nullptr) && BaseClass::IsValid()){
        const ICompositeComponent* parentPtr = m_definitionComponentPtr->GetParentComponent();
        if (parentPtr != nullptr){
            const QByteArray& componentId = BaseClass::operator[](index);
 
            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[](index).constData());
        }
    }
 
    return nullptr;
}
 
 
template <class Interface>
std::unique_ptr<Interface> TMultiFactoryMember<Interface>::CreateInstance(int index) const
{
    auto newComponentPtr = CreateComponent(index);
    if (newComponentPtr != nullptr){
        Interface* retVal = BaseClass2::ExtractInterface<Interface>(newComponentPtr.get());
        if (retVal != nullptr){
            newComponentPtr.release();
 
            return std::unique_ptr<Interface>{retVal};
        }
    }
 
    return nullptr;
}
 
 
// static methods
 
template <class Interface>
Interface* TMultiFactoryMember<Interface>::ExtractInterface(IComponent* componentPtr, const QByteArray& subId)
{
    return BaseClass2::ExtractInterface<Interface>(componentPtr, subId);
}
 
 
// protected methods
 
template <class Interface>
TMultiFactoryMember<Interface>::TMultiFactoryMember(const TMultiFactoryMember& ptr)
:   BaseClass(ptr),
    m_definitionComponentPtr(ptr.m_definitionComponentPtr)
{
}
 
 
} // namespace icomp