TSimComponentWrap.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/CClassInfo.h>
#include <icomp/ICompositeComponent.h>
#include <icomp/TComponentWrap.h>
#include <icomp/CSimComponentContextBase.h>
 
 
namespace icomp
{
 
 
template <class Base>
class TSimComponentWrap:
            public TComponentWrap<Base>,
            public CSimComponentContextBase,
            virtual public ICompositeComponent
{
public:
    typedef TComponentWrap<Base> BaseClass;
    typedef CSimComponentContextBase BaseClass2;
 
    TSimComponentWrap();
 
    void InitComponent();
 
    // reimplemented (icomp::IComponentContext)
    virtual const QByteArray& GetContextId() 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;
};
 
 
// public methods
 
template <class Base>
TSimComponentWrap<Base>::TSimComponentWrap()
:   BaseClass(),
    BaseClass2(&BaseClass::GetComponentStaticInfo())
{
}
 
 
template <class Base>
void TSimComponentWrap<Base>::InitComponent()
{
    SetComponentContext(this, nullptr, false);
}
 
 
// reimplemented (icomp::IComponentContext)
 
template <class Base>
const QByteArray& TSimComponentWrap<Base>::GetContextId() const
{
    static QByteArray id = istd::CClassInfo::GetName<Base>();
 
    return id;
}
 
 
// reimplemented (icomp::ICompositeComponent)
 
template <class Base>
IComponent* TSimComponentWrap<Base>::GetSubcomponent(const QByteArray& componentId) const
{
    BaseClass2::ComponentsMap::const_iterator iter = BaseClass2::m_componentsMap.constFind(componentId);
 
    if (iter != BaseClass2::m_componentsMap.constEnd()){
        return iter.value();
    }
 
    return nullptr;
}
 
 
template <class Base>
const IComponentContext* TSimComponentWrap<Base>::GetSubcomponentContext(const QByteArray& /*componentId*/) const
{
    return nullptr;
}
 
 
template <class Base>
std::unique_ptr<IComponent> TSimComponentWrap<Base>::CreateSubcomponent(const QByteArray& componentId) const
{
    FactoriesMap::const_iterator iter = m_factoriesMap.constFind(componentId);
    if (iter != m_factoriesMap.constEnd()){
        Q_ASSERT(iter.value() != nullptr);
 
        return iter.value()->CreateInstance();
    }
 
    return nullptr;
}
 
 
template <class Base>
void TSimComponentWrap<Base>::OnSubcomponentDeleted(const IComponent* /*subcomponentPtr*/)
{
    qFatal("Simulated component cannot have sub-components");
}
 
 
// reimplemented (icomp::IComponent)
 
template <class Base>
const ICompositeComponent* TSimComponentWrap<Base>::GetParentComponent(bool ownerOnly) const
{
    if (ownerOnly){
        return nullptr;
    }
    else{
        return const_cast<TSimComponentWrap<Base>* >(this);
    }
}
 
 
} // namespace icomp