TMultiAttributeMember.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 <iattr/TMultiAttribute.h>
#include <icomp/IComponentContext.h>
 
 
namespace icomp
{
 
 
template <typename Attribute>
class TMultiAttributeMember
{
public:
    typedef Attribute AttributeType;
    typedef typename Attribute::ValueType AttributeValueType;
    typedef void InterfaceType;
 
    TMultiAttributeMember();
 
    void Init(const IComponent* ownerPtr, const IRealAttributeStaticInfo& staticInfo);
 
    bool IsValid() const;
 
    int GetCount() const;
 
    const AttributeValueType& operator[](int index) const;
 
    int FindValue(const AttributeValueType& value) const;
 
protected:
    bool InitInternal(
                const IComponent* ownerPtr,
                const IRealAttributeStaticInfo& staticInfo,
                const IComponent** definitionComponentPtr);
 
 
private:
    const Attribute* m_attributePtr;
};
 
 
// public methods
 
template <typename Attribute>
TMultiAttributeMember<Attribute>::TMultiAttributeMember()
:   m_attributePtr(nullptr)
{
}
 
 
template <typename Attribute>
void TMultiAttributeMember<Attribute>::Init(
            const IComponent* ownerPtr,
            const IRealAttributeStaticInfo& staticInfo)
{
    InitInternal(ownerPtr, staticInfo, nullptr);
}
 
 
template <typename Attribute>
bool TMultiAttributeMember<Attribute>::IsValid() const
{
    return (m_attributePtr != nullptr);
}
 
 
template <typename Attribute>
int TMultiAttributeMember<Attribute>::GetCount() const
{
    if (m_attributePtr != nullptr){
        return m_attributePtr->GetValuesCount();
    }
    else{
        return 0;
    }
}
 
 
template <typename Attribute>
const typename TMultiAttributeMember<Attribute>::AttributeValueType& TMultiAttributeMember<Attribute>::operator[](int index) const
{
    Q_ASSERT(index >= 0);
    Q_ASSERT(index < GetCount());
    Q_ASSERT(m_attributePtr != nullptr);    // operator* was called for invalid object, or no IsValid() check was called.
    Q_ASSERT(m_attributePtr->GetValuesCount() == GetCount());
 
    return m_attributePtr->GetValueAt(index);
}
 
 
template <typename Attribute>
int TMultiAttributeMember<Attribute>::FindValue(const AttributeValueType& value) const
{
    if (m_attributePtr != nullptr){
        return m_attributePtr->FindValue(value);
    }
 
    return -1;
}
 
 
// protected methods
 
template <typename Attribute>
bool TMultiAttributeMember<Attribute>::InitInternal(
            const IComponent* ownerPtr,
            const IRealAttributeStaticInfo& staticInfo,
            const IComponent** definitionComponentPtr)
{
    Q_ASSERT(ownerPtr != nullptr);
 
    const QByteArray& attributeId = staticInfo.GetAttributeId();
    const IComponentContext* componentContextPtr = ownerPtr->GetComponentContext();
    if (componentContextPtr != nullptr){
        int definitionLevel = -1;
        const iser::IObject* attributePtr = componentContextPtr->GetAttribute(attributeId, &definitionLevel);
        m_attributePtr = dynamic_cast<const Attribute*>(attributePtr);
 
        if (m_attributePtr != nullptr){
            Q_ASSERT(definitionLevel >= 0);
 
            if (definitionComponentPtr != nullptr){
                while (definitionLevel > 0){
                    ownerPtr = ownerPtr->GetParentComponent();
                    Q_ASSERT(ownerPtr != nullptr);
 
                    --definitionLevel;
                }
 
                *definitionComponentPtr = ownerPtr;
            }
 
            return true;
        }
    }
    else{
        m_attributePtr = nullptr;
    }
 
    return false;
}
 
 
// Translatable attribute
 
class CMultiTextAttribute: public iattr::CStringListAttribute
{
public:
    typedef iattr::CStringListAttribute BaseClass;
 
    CMultiTextAttribute()
    {
    }
 
    explicit CMultiTextAttribute(int elementsCount, QString* valuesPtr)
    :   BaseClass(elementsCount, valuesPtr)
    {
    }
 
    enum DefaultAttributeFlags
    {
        DAF_OBLIGATORY = BaseClass::DAF_OBLIGATORY | IAttributeStaticInfo::AF_TRANSLATABLE,
        DAF_OPTIONAL = BaseClass::DAF_OPTIONAL | IAttributeStaticInfo::AF_TRANSLATABLE
    };
 
    static QByteArray GetTypeName()
    {
        return "Text[]";
    }
 
    // reimplemented (iser::IObject)
    virtual QByteArray GetFactoryId() const
    {
        return GetTypeName();
    }
};
 
 
class CMultiTextAttributeMember: public TMultiAttributeMember<CMultiTextAttribute>
{
public:
    typedef TMultiAttributeMember<CMultiTextAttribute> BaseClass;
 
    QString operator[](int index) const
    {
        return QCoreApplication::translate("Attribute", BaseClass::operator[](index).toLatin1());
    }
};
 
 
} // namespace icomp