TMultiAttributeMember.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF 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(NULL)
{
}
 
 
template <typename Attribute>
void TMultiAttributeMember<Attribute>::Init(
                     const IComponent* ownerPtr,
                     const IRealAttributeStaticInfo& staticInfo)
{
       InitInternal(ownerPtr, staticInfo, NULL);
}
 
 
template <typename Attribute>
bool TMultiAttributeMember<Attribute>::IsValid() const
{
       return (m_attributePtr != NULL);
}
 
 
template <typename Attribute>
int TMultiAttributeMember<Attribute>::GetCount() const
{
       if (m_attributePtr != NULL){
              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 != NULL);  // 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 != NULL){
              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 != NULL);
 
       const QByteArray& attributeId = staticInfo.GetAttributeId();
       IComponentContextSharedPtr componentContextPtr = ownerPtr->GetComponentContext();
       if (componentContextPtr.get()){
              int definitionLevel = -1;
              const iser::IObject* attributePtr = componentContextPtr->GetAttribute(attributeId, &definitionLevel);
              m_attributePtr = dynamic_cast<const Attribute*>(attributePtr);
 
              if (m_attributePtr != NULL){
                     Q_ASSERT(definitionLevel >= 0);
 
                     if (definitionComponentPtr != NULL){
                            while (definitionLevel > 0 && (ownerPtr != nullptr)){
                                   ownerPtr = ownerPtr->GetParentComponent();
//                                 Q_ASSERT(ownerPtr != NULL);
 
                                   --definitionLevel;
                            }
 
                            *definitionComponentPtr = ownerPtr;
                     }
 
                     return true;
              }
       }
       else{
              m_attributePtr = NULL;
       }
 
       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 override
       {
              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