TAttributeMember.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/QCoreApplication>
 
// ICF includes
#include <iattr/TAttribute.h>
#include <icomp/ICompositeComponent.h>
#include <icomp/IComponentContext.h>
#include <icomp/IRealAttributeStaticInfo.h>
#include <icomp/CComponentContext.h>
 
 
namespace icomp
{
 
 
template <typename Attribute>
class TAttributeMember
{
public:
    typedef Attribute AttributeType;
    typedef typename Attribute::ValueType AttributeValueType;
    typedef void InterfaceType;
 
    TAttributeMember();
 
    void Init(const IComponent* ownerPtr, const IRealAttributeStaticInfo& staticInfo);
 
    bool IsValid() const;
 
    const Attribute* GetAttributePtr() const;
    const AttributeValueType& GetOriginalValue() const;
 
    const Attribute* operator->() const;
 
    bool operator==(const Attribute* ptr) const;
    bool operator!=(const Attribute* ptr) const;
    const AttributeValueType& operator*() const;
 
protected:
    void SetAttribute(const Attribute* attributePtr);
 
    bool InitInternal(  const IComponent* ownerPtr,
                const IRealAttributeStaticInfo& staticInfo,
                const IComponent** definitionComponentPtr);
 
private:
    const Attribute* m_attributePtr;
    bool m_isAssigned;
};
 
 
// public methods
 
template <typename Attribute>
TAttributeMember<Attribute>::TAttributeMember()
:   m_attributePtr(nullptr),
    m_isAssigned(false)
{
}
 
 
template <typename Attribute>
void TAttributeMember<Attribute>::Init(
            const IComponent* ownerPtr,
            const IRealAttributeStaticInfo& staticInfo)
{
    InitInternal(ownerPtr, staticInfo, nullptr);
}
 
template <typename Attribute>
bool TAttributeMember<Attribute>::IsValid() const
{
    Q_ASSERT_X(m_isAssigned, "Component initialization", "No I_ASSIGN used or attribute is used out of component context");
 
    return (m_attributePtr != nullptr);
}
 
 
template <typename Attribute>
const Attribute* TAttributeMember<Attribute>::GetAttributePtr() const
{
    Q_ASSERT_X(m_isAssigned, "Component initialization", "No I_ASSIGN used or attribute is used out of component context");
 
    return m_attributePtr;
}
 
 
template <typename Attribute>
const typename TAttributeMember<Attribute>::AttributeValueType& TAttributeMember<Attribute>::GetOriginalValue() const
{
    Q_ASSERT(m_attributePtr != nullptr);    // GetOriginalValue() was called for invalid object, or no IsValid() check was called.
 
    return m_attributePtr->GetValue();
}
 
 
template <typename Attribute>
const Attribute* TAttributeMember<Attribute>::operator->() const
{
    Q_ASSERT_X(m_isAssigned, "Component initialization", "No I_ASSIGN used or attribute is used out of component context");
 
    return m_attributePtr;
}
 
 
template <typename Attribute>
const typename TAttributeMember<Attribute>::AttributeValueType& TAttributeMember<Attribute>::operator*() const
{
    Q_ASSERT(m_attributePtr != nullptr);    // operator* was called for invalid object, or no IsValid() check was called.
 
    return m_attributePtr->GetValue();
}
 
 
template <typename Attribute>
bool TAttributeMember<Attribute>::operator==(const Attribute* ptr) const
{
    return m_attributePtr == ptr;
}
 
 
template <typename Attribute>
bool TAttributeMember<Attribute>::operator!=(const Attribute* ptr) const
{
    return m_attributePtr != ptr;
}
 
 
// protected methods
 
template <typename Attribute>
void TAttributeMember<Attribute>::SetAttribute(const Attribute* attributePtr)
{
    m_attributePtr = attributePtr;
}
 
 
template <typename Attribute>
bool TAttributeMember<Attribute>::InitInternal(
            const IComponent* ownerPtr,
            const IRealAttributeStaticInfo& staticInfo,
            const IComponent** definitionComponentPtr)
{
    Q_ASSERT(ownerPtr != nullptr);
 
    m_isAssigned = true;
 
    const QByteArray& attributeId = staticInfo.GetAttributeId();
    const IComponentContext* componentContextPtr = ownerPtr->GetComponentContext();
    if (componentContextPtr != nullptr){
        if (definitionComponentPtr != nullptr){
            int definitionLevel = -1;
            const iser::IObject* attributePtr = componentContextPtr->GetAttribute(attributeId, &definitionLevel);
            if (attributePtr != nullptr){
                m_attributePtr = dynamic_cast<const Attribute*>(attributePtr);
 
                if (m_attributePtr != nullptr){
                    Q_ASSERT(definitionLevel >= 0);
 
                    while (definitionLevel > 0){
                        ownerPtr = ownerPtr->GetParentComponent();
                        Q_ASSERT(ownerPtr != nullptr);
 
                        --definitionLevel;
                    }
 
                    *definitionComponentPtr = ownerPtr;
 
                    return true;
                }
                else{
                    qCritical(  "Component '%s': Attribute '%s' type inconsistence!",
                                CComponentContext::GetHierarchyAddress(componentContextPtr).constData(),
                                attributeId.constData());
                }
            }
        }
        else{
            const iser::IObject* attributePtr = componentContextPtr->GetAttribute(attributeId, nullptr);
            m_attributePtr = dynamic_cast<const Attribute*>(attributePtr);
 
            if (m_attributePtr == nullptr){
                if (attributePtr != nullptr){
                    qCritical(  "Component %s: Attribute %s exists in the component context but has a wrong type",
                                CComponentContext::GetHierarchyAddress(componentContextPtr).constData(),
                                attributeId.constData());
                }
            }
 
            return (m_attributePtr != nullptr);
        }
    }
    else{
        qCritical(  "Error during resolving of attribute: %s in component %s: Component context not set",
                    CComponentContext::GetHierarchyAddress(componentContextPtr).constData(),
                    attributeId.constData());
 
        m_attributePtr = nullptr;
    }
 
    return false;
}
 
 
// Translatable attribute
 
class CTextAttribute: public iattr::CStringAttribute
{
public:
    typedef iattr::CStringAttribute BaseClass;
 
    CTextAttribute()
    {
    }
 
    explicit CTextAttribute(const QString& value)
    :   BaseClass(value)
    {
    }
 
    enum DefaultAttributeFlags
    {
        DAF_OBLIGATORY = iattr::CStringAttribute::DAF_OBLIGATORY | IAttributeStaticInfo::AF_TRANSLATABLE,
        DAF_OPTIONAL = iattr::CStringAttribute::DAF_OPTIONAL | IAttributeStaticInfo::AF_TRANSLATABLE
    };
 
    static QByteArray GetTypeName()
    {
        return "Text";
    }
 
    // reimplemented (iser::IObject)
    virtual QByteArray GetFactoryId() const
    {
        return GetTypeName();
    }
};
 
 
class CTextAttributeMember: public TAttributeMember<CTextAttribute>
{
public:
    typedef TAttributeMember<CTextAttribute> BaseClass;
 
    QString operator*() const
    {
        return QCoreApplication::translate("Attribute", BaseClass::operator*().toUtf8());
    }
};
 
 
} // namespace icomp