GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1073:243c12122366

Implements merge method (2)...

Alexandre Leroux -

r1073:243c12122366

parent child

Context file:

r1073:243c12122366

Collapse all files

core/include/DataSource/DataSourceItem.h +2 0

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class SCIQLOP_CORE_EXPORT DataSourceItem {
             public:
                 /// Key associated with the name of the item
                 static const QString NAME_DATA_KEY;
                 explicit DataSourceItem(DataSourceItemType type, const QString &name);
                 explicit DataSourceItem(DataSourceItemType type, QVariantHash data = {});
+                std::unique_ptr<DataSourceItem> clone() const;
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
                  * Get the data associated to a key
                  * @param key the key to search
                  * @return the data found if key is valid, default QVariant otherwise
                  */
                 QVariant data(const QString &key) const noexcept;
                 /// Gets all data
                 QVariantHash data() const noexcept;
                 /**
                  * Merge in the item the source item passed as parameter.
                  *
                  * The merge is done by adding as child of the item the complete tree represented by the source
                  * item. If a part of the tree already exists in the item (based on the name of the nodes), it
                  * is merged by completing the existing tree by items "leaves" (products, components or nodes
                  * with no child).
                  *
                  * For example, with item representing the tree:
                  * R (root node)
                  *   - N1 (node)
                  *     -- N11 (node)
                  *        --- P1 (product)
                  *        --- P2 (product)
                  *   - N2 (node)
                  *
                  * and the source item representing the tree:
                  * N1 (root node)
                  *   - N11 (node)
                  *     -- P3 (product)
                  *   - N12 (node)
                  *
                  * The leaves of the source item to merge into the item are N1/N11/P3 and N1/N12 => we therefore
                  * have the following merge result:
                  * R
                  *   - N1
                  *     -- N11
                  *        --- P1
                  *        --- P2
                  *        --- P3 (added leaf)
                  *     -- N12 (added leaf)
                  *
                  * @param item the source item
                  * @remarks No control is performed on products or components that are merged into the same tree
                  * part (two products or components may have the same name)
                  * @remarks the merge is made by copy (source item is not changed and still exists after the
                  * operation)
                  */
                 void merge(const DataSourceItem &item);
                 bool isRoot() const noexcept;
                 QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
                 /**
                  * Gets the item's root
                  * @return the top parent, the item itself if it's the root item
                  */
                 const DataSourceItem &rootItem() const noexcept;
                 /**
                  * Sets or appends a value to a key
                  * @param key the key
                  * @param value the value
                  * @param append if true, the value is added to the values already existing for the key,
                  * otherwise it replaces the existing values
                  */
                 void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
                 DataSourceItemType type() const noexcept;
                 /**
                  * @brief Searches the first child matching the specified data.
                  * @param data The data to search.
                  * @param recursive So the search recursively.
                  * @return the item matching the data or nullptr if it was not found.
                  */
                 DataSourceItem *findItem(const QVariantHash &data, bool recursive);
                 bool operator==(const DataSourceItem &other);
                 bool operator!=(const DataSourceItem &other);
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/include/DataSource/DataSourceItemAction.h +2 0

             #ifndef SCIQLOP_DATASOURCEITEMACTION_H
             #define SCIQLOP_DATASOURCEITEMACTION_H
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceItemAction)
             class DataSourceItem;
             /**
              * @brief The DataSourceItemAction class represents an action on a data source item.
              *
              * An action is a function that will be executed when the slot execute() is called.
              */
             class SCIQLOP_CORE_EXPORT DataSourceItemAction : public QObject {
                 Q_OBJECT
             public:
                 /// Signature of the function associated to the action
                 using ExecuteFunction = std::function<void(DataSourceItem &dataSourceItem)>;
                 /**
                  * Ctor
                  * @param name the name of the action
                  * @param fun the function that will be called when the action is executed
                  * @sa execute()
                  */
                 explicit DataSourceItemAction(const QString &name, ExecuteFunction fun);
+                std::unique_ptr<DataSourceItemAction> clone() const;
                 QString name() const noexcept;
                 /// Sets the data source item concerned by the action
                 void setDataSourceItem(DataSourceItem *dataSourceItem) noexcept;
             public slots:
                 /// Executes the action
                 void execute();
             private:
                 class DataSourceItemActionPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemActionPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMACTION_H

core/src/DataSource/DataSourceItem.cpp +17 0

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceItemMergeHelper.h>
             #include <QVector>
             const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QVariantHash data)
                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
                 QVariantHash m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)
                     : DataSourceItem{type, QVariantHash{{NAME_DATA_KEY, name}}}
             {
             }
             DataSourceItem::DataSourceItem(DataSourceItemType type, QVariantHash data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
+            std::unique_ptr<DataSourceItem> DataSourceItem::clone() const
+            {
+                auto result = std::make_unique<DataSourceItem>(impl->m_Type, impl->m_Data);
+                // Clones children
+                for (const auto &child : impl->m_Children) {
+                    result->appendChild(std::move(child->clone()));
+                }
+                // Clones actions
+                for (const auto &action : impl->m_Actions) {
+                    result->addAction(std::move(action->clone()));
+                }
+                return result;
+            }
             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
                 auto result = QVector<DataSourceItemAction *>{};
                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                                std::back_inserter(result), [](const auto &action) { return action.get(); });
                 return result;
             }
             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
             {
                 action->setDataSourceItem(this);
                 impl->m_Actions.push_back(std::move(action));
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
             QVariant DataSourceItem::data(const QString &key) const noexcept
             {
                 return impl->m_Data.value(key);
             }
             QVariantHash DataSourceItem::data() const noexcept
             {
                 return impl->m_Data;
             }
             void DataSourceItem::merge(const DataSourceItem &item)
             {
                 DataSourceItemMergeHelper::merge(item, *this);
             }
             bool DataSourceItem::isRoot() const noexcept
             {
                 return impl->m_Parent == nullptr;
             }
             QString DataSourceItem::name() const noexcept
             {
                 return data(NAME_DATA_KEY).toString();
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             const DataSourceItem &DataSourceItem::rootItem() const noexcept
             {
                 return isRoot() ? *this : parentItem()->rootItem();
             }
             void DataSourceItem::setData(const QString &key, const QVariant &value, bool append) noexcept
             {
                 auto it = impl->m_Data.constFind(key);
                 if (append && it != impl->m_Data.constEnd()) {
                     // Case of an existing value to which we want to add to the new value
                     if (it->canConvert<QVariantList>()) {
                         auto variantList = it->value<QVariantList>();
                         variantList.append(value);
                         impl->m_Data.insert(key, variantList);
                     }
                     else {
                         impl->m_Data.insert(key, QVariantList{*it, value});
                     }
                 }
                 else {
                     // Other cases :
                     // - new value in map OR
                     // - replacement of an existing value (not appending)
                     impl->m_Data.insert(key, value);
                 }
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }
             DataSourceItem *DataSourceItem::findItem(const QVariantHash &data, bool recursive)
             {
                 for (const auto &child : impl->m_Children) {
                     if (child->impl->m_Data == data) {
                         return child.get();
                     }
                     if (recursive) {
                         if (auto foundItem = child->findItem(data, true)) {
                             return foundItem;
                         }
                     }
                 }
                 return nullptr;
             }
             bool DataSourceItem::operator==(const DataSourceItem &other)
             {
                 // Compares items' attributes
                 if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
                     // Compares contents of items' children
                     return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
                                       std::cbegin(other.impl->m_Children),
                                       [](const auto &itemChild, const auto &otherChild) {
                                           return *itemChild == *otherChild;
                                       });
                 }
                 else {
                     return false;
                 }
             }
             bool DataSourceItem::operator!=(const DataSourceItem &other)
             {
                 return !(*this == other);
             }

core/src/DataSource/DataSourceItemAction.cpp +5 0

             #include <DataSource/DataSourceItemAction.h>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_DataSourceItemAction, "DataSourceItemAction")
             struct DataSourceItemAction::DataSourceItemActionPrivate {
                 explicit DataSourceItemActionPrivate(const QString &name,
                                                      DataSourceItemAction::ExecuteFunction fun)
                         : m_Name{name}, m_Fun{std::move(fun)}, m_DataSourceItem{nullptr}
                 {
                 }
                 QString m_Name;
                 DataSourceItemAction::ExecuteFunction m_Fun;
                 /// Item associated to the action (can be null, in which case the action will not be executed)
                 DataSourceItem *m_DataSourceItem;
             };
             DataSourceItemAction::DataSourceItemAction(const QString &name, ExecuteFunction fun)
                     : impl{spimpl::make_unique_impl<DataSourceItemActionPrivate>(name, std::move(fun))}
             {
             }
+            std::unique_ptr<DataSourceItemAction> DataSourceItemAction::clone() const
+            {
+                return std::make_unique<DataSourceItemAction>(impl->m_Name, impl->m_Fun);
+            }
             QString DataSourceItemAction::name() const noexcept
             {
                 return impl->m_Name;
             }
             void DataSourceItemAction::setDataSourceItem(DataSourceItem *dataSourceItem) noexcept
             {
                 impl->m_DataSourceItem = dataSourceItem;
             }
             void DataSourceItemAction::execute()
             {
                 if (impl->m_DataSourceItem) {
                     impl->m_Fun(*impl->m_DataSourceItem);
                 }
                 else {
                     qCDebug(LOG_DataSourceItemAction())
                         << tr("Can't execute action : no item has been associated");
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages