CCompositeComponent.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
 
 
// Qt includes
#include <QtCore/QByteArray>
#include <QtCore/QMap>
 
// ICF includes
#include <istd/CClassInfo.h>
 
#include <icomp/ICompositeComponent.h>
#include <icomp/IRegistry.h>
#include <icomp/CCompositeComponentContext.h>
#include <icomp/CInterfaceManipBase.h>
 
 
namespace icomp
{
 
 
class IMetaInfoManager;
 
 
class CCompositeComponent:
            public CInterfaceManipBase,
            virtual public ICompositeComponent
{
public:
    CCompositeComponent(bool manualAutoInit);
    virtual ~CCompositeComponent();
 
    template <class InterfaceType>
    InterfaceType* GetComponentInterface(const QByteArray& subId = "");
 
    bool EnsureAutoInitComponentsCreated() const;
 
    // reimplemented (icomp::ICompositeComponent)
    virtual IComponent* GetSubcomponent(const QByteArray& componentId) const;
    virtual const IComponentContext* GetSubcomponentContext(const QByteArray& componentId) const;
    virtual std::unique_ptr<IComponent> CreateSubcomponent(const QByteArray& componentId) const;
    virtual void OnSubcomponentDeleted(const IComponent* subcomponentPtr);
 
    // reimplemented (icomp::IComponent)
    virtual const ICompositeComponent* GetParentComponent(bool ownerOnly = false) const;
    virtual void* GetInterface(const istd::CClassInfo& interfaceType, const QByteArray& subId = "");
    virtual const IComponentContext* GetComponentContext() const;
    virtual void SetComponentContext(
                const IComponentContext* contextPtr,
                const ICompositeComponent* parentPtr,
                bool isParentOwner);
 
protected:
    typedef std::unique_ptr<IComponent> ComponentPtr;
    typedef std::unique_ptr<IComponentContext> ContextPtr;
 
    bool CreateSubcomponentInfo(
                const QByteArray& componentId,
                ContextPtr& subContextPtr,
                ComponentPtr* subComponentPtr,
                bool isOwned) const;
 
private:
    struct ComponentInfo
    {
        ComponentPtr componentPtr;
        bool isComponentInitialized = false;
        ContextPtr contextPtr;
        bool isContextInitialized = false;
    };
 
    typedef std::map< QByteArray, ComponentInfo> ComponentMap;
    mutable ComponentMap m_componentMap;
 
    const CCompositeComponentContext* m_contextPtr;
    const ICompositeComponent* m_parentPtr;
    bool m_isParentOwner;
 
    bool m_manualAutoInit;
 
    mutable bool m_autoInitialized;
    mutable IRegistry::Ids m_autoInitComponentIds;
};
 
 
// inline methods
 
template <class InterfaceType>
inline InterfaceType* CCompositeComponent::GetComponentInterface(const QByteArray& subId)
{
    static istd::CClassInfo info(typeid(InterfaceType));
 
    return static_cast<InterfaceType*>(GetInterface(info, subId));
}
 
 
} // namespace icomp