GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1071:b92faa6e4b21

Inits merge method of two items

Alexandre Leroux -

r1071:b92faa6e4b21

parent child

Context file:

r1071:b92faa6e4b21

Collapse all files

core/include/DataSource/DataSourceItemMergeHelper.h created 644 +15 0

@@ -0,0 +1,15
	1	#ifndef SCIQLOP_DATASOURCEITEMMERGEHELPER_H
	2	#define SCIQLOP_DATASOURCEITEMMERGEHELPER_H
	3
	4	class DataSourceItem;
	5
	6	/**
	7	* @brief The DataSourceItemMergeHelper struct is used to merge two data source items
	8	* @sa DataSourceItem::merge()
	9	*/
	10	struct DataSourceItemMergeHelper {
	11	/// Merges source item into dest item
	12	static void merge(const DataSourceItem &source, DataSourceItem &dest);
	13	};
	14
	15	#endif // SCIQLOP_DATASOURCEITEMMERGEHELPER_H

core/src/DataSource/DataSourceItemMergeHelper.cpp created 644 +8 0

@@ -0,0 +1,8
	1	#include "DataSource/DataSourceItemMergeHelper.h"
	2
	3	#include <DataSource/DataSourceItem.h>
	4
	5	void DataSourceItemMergeHelper::merge(const DataSourceItem &source, DataSourceItem &dest)
	6	{
	7	/// @todo ALX
	8	}

core/include/DataSource/DataSourceItem.h +40 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 = {});
                 /// @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/meson.build +1 0

             core_moc_headers = [
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/SpectrogramSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/Data/OptionalAxis.cpp',
               'src/Data/DataSeriesUtils.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
+              'src/DataSource/DataSourceItemMergeHelper.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

core/src/DataSource/DataSourceItem.cpp +6 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))}
             {
             }
             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);
             }

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