CCollectionInfo.h

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ImtCore-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QVector>
#include <QtCore/QUuid>
 
// ACF includes
#include <iser/IArchive.h>
#include <iser/ISerializable.h>
 
// ImtCore includes
#include <imtbase/ICollectionInfo.h>
 
 
namespace imtbase
{
 
 
class CCollectionInfo:
                     virtual public ICollectionInfo,
                     virtual public iser::ISerializable
{
public:
       int GetItemIndex(const QByteArray& id) const;
 
       virtual QByteArray InsertItem(const QByteArray& id, const QString& name, const QString& description, int position = -1);
       virtual void RemoveItem(const QByteArray& id);
       virtual void SetItemName(const QByteArray& id, const QString& name);
       virtual void SetItemDescription(const QByteArray& id, const QString& description);
 
       // reimplemented (ICollectionInfo)
       virtual int GetElementsCount(
                            const iprm::IParamsSet* selectionParamPtr = nullptr,
                            ilog::IMessageConsumer* logPtr = nullptr) const override;
       virtual Ids GetElementIds(
                            int offset = 0,
                            int count = -1,
                            const iprm::IParamsSet* selectionParamsPtr = nullptr,
                            ilog::IMessageConsumer* logPtr = nullptr) const override;
       virtual bool GetSubsetInfo(
                            imtbase::ICollectionInfo& subsetInfo,
                            int offset = 0,
                            int count = -1,
                            const iprm::IParamsSet* selectionParamsPtr = nullptr,
                            ilog::IMessageConsumer* logPtr = nullptr) const override;
       virtual QVariant GetElementInfo(const QByteArray& elementId, int infoType, ilog::IMessageConsumer* logPtr = nullptr) const override;
       virtual idoc::MetaInfoPtr GetElementMetaInfo(const Id& elementId, ilog::IMessageConsumer* logPtr = nullptr) const override;
       virtual bool SetElementName(const Id& elementId, const QString& name, ilog::IMessageConsumer* logPtr = nullptr) override;
       virtual bool SetElementDescription(const Id& elementId, const QString& description, ilog::IMessageConsumer* logPtr = nullptr) override;
       virtual bool SetElementEnabled(const Id& elementId, bool isEnabled = true, ilog::IMessageConsumer* logPtr = nullptr) override;
 
       // reimplemented (istd::IChangeable)
       virtual int GetSupportedOperations() const override;
       virtual bool CopyFrom(const IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
       virtual bool IsEqual(const IChangeable& object) const override;
       virtual istd::IChangeableUniquePtr CloneMe(CompatibilityMode mode = CM_WITHOUT_REFS) const override;
       virtual bool ResetData(CompatibilityMode mode = CM_WITHOUT_REFS) override;
 
       // reimplemented (iser::ISerializable)
       virtual bool Serialize(iser::IArchive& archive) override;
 
protected:
       struct Item
       {
              Item(const QByteArray& id = QByteArray())
                     :isEnabled(true)
              {
                     if (id.isEmpty()){
                            this->id = QUuid::createUuid().toByteArray();
                     }
                     else{
                            this->id = id;
                     }
              }
 
              Item(const Item& object)
              {
                     this->id = object.id;
                     this->name = object.name;
                     this->isEnabled = object.isEnabled;
                     this->description = object.description;
              }
 
              bool isEnabled;
              QString name;
              QString description;
              QByteArray id;
 
              bool operator==(const Item &item) const
              {
                     return ((isEnabled == item.isEnabled)
                                   && (name == item.name)
                                   && (description == item.description)
                                   && (id == item.id));
              }
 
              bool operator!=(const Item &item) const
              {
                     return !(operator==(item));
              }
       };
 
       typedef QVector<Item> Items;
 
protected:
       Item* FindItemById(const Id& elementId) const;
 
protected:
       Items m_items;
};
 
 
} // namespace imtbase