TFactoryMember.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 <istd/TIFactory.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::TIFactory<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;
 
    std::unique_ptr<IComponent> CreateComponent() const;
 
    static Interface* ExtractInterface(istd::IPolymorphic* instancePtr, const QByteArray& subId = "");
 
    // reimplemented (istd::TIFactory)
    virtual std::unique_ptr<Interface> CreateInstance(const QByteArray& keyId = "") const;
 
    // reimplemented (istd::IFactoryInfo)
    virtual KeyList GetFactoryKeys() const;
 
protected:
    TFactoryMember(const TFactoryMember& ptr);
 
private:
    const IComponent* m_definitionComponentPtr;
};
 
 
// public methods
 
template <class Interface>
TFactoryMember<Interface>::TFactoryMember()
:   m_definitionComponentPtr(nullptr)
{
}
 
 
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 != nullptr) && BaseClass::IsValid();
}
 
 
 
template <class Interface>
std::unique_ptr<IComponent> TFactoryMember<Interface>::CreateComponent() const
{
    if ((m_definitionComponentPtr != nullptr) && BaseClass::IsValid()){
        const ICompositeComponent* parentPtr = m_definitionComponentPtr->GetParentComponent();
        if (parentPtr != nullptr){
            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>
std::unique_ptr<Interface> TFactoryMember<Interface>::CreateInstance(const QByteArray& /*keyId*/) const
{
    auto newComponentPtr = CreateComponent();
    if (newComponentPtr != nullptr){
        Interface* retVal = BaseClass2::ExtractInterface<Interface>(newComponentPtr.get());
        if (retVal != nullptr){
            newComponentPtr.release();
 
            return std::unique_ptr<Interface>{retVal};
        }
    }
 
    return nullptr;
}
 
 
// 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 != nullptr){
        if (auto* componentPtr = dynamic_cast<IComponent*>(instancePtr)) {
            return BaseClass2::ExtractInterface<Interface>(componentPtr, subId);
        }
 
        Q_UNREACHABLE();    // Only objects returned by \b CreateComponent should be used as input, so this line cannot be run.
    }
 
    return nullptr;
}
 
 
// protected methods
 
template <class Interface>
TFactoryMember<Interface>::TFactoryMember(const TFactoryMember& ptr)
:   BaseClass(ptr),
    m_definitionComponentPtr(ptr.m_definitionComponentPtr)
{
}
 
 
} // namespace icomp