HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r99:46467fb43b8d

New data sources system switch complete...

jeandet -

r99:46467fb43b8d

parent child

Context file:

r99:46467fb43b8d

include/MimeTypes/MimeTypes.h created 644 +91 0

@@ -0,0 +1,91
	1	#ifndef SCIQLOP_MIMETYPESDEF_H
	2	#define SCIQLOP_MIMETYPESDEF_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QByteArray>
	7	#include <QDataStream>
	8	#include <QMimeData>
	9	#include <QString>
	10	#include <QVariant>
	11
	12	// ////////////////// //
	13	// SciQlop Mime Types //
	14	// ////////////////// //
	15
	16	namespace MIME
	17	{
	18	inline QString const MIME_TYPE_GRAPH =
	19	QStringLiteral("application/x.sciqlop.graph");
	20	inline QString const MIME_TYPE_ZONE =
	21	QStringLiteral("application/x.sciqlop.zone");
	22	inline QString const MIME_TYPE_VARIABLE_LIST =
	23	QStringLiteral("application/x.sciqlop.var-list");
	24	inline QString const MIME_TYPE_PRODUCT_LIST =
	25	QStringLiteral("application/x.sciqlop.product-list");
	26	inline QString const MIME_TYPE_TIME_RANGE =
	27	QStringLiteral("application/x.sciqlop.time-range");
	28	inline QString const MIME_TYPE_SELECTION_ZONE =
	29	QStringLiteral("application/x.sciqlop.selection-zone");
	30	inline QString const MIME_TYPE_EVENT_LIST =
	31	QStringLiteral("application/x.sciqlop.event-list");
	32	inline QString const MIME_TYPE_SOURCE_CATALOGUE_LIST =
	33	QStringLiteral("application/x.sciqlop.source-catalogue-list");
	34
	35	enum class IDS
	36	{
	37	GRAPH,
	38	ZONE,
	39	VARIABLE_LIST,
	40	PRODUCT_LIST,
	41	TIME_RANGE,
	42	SELECTION_ZONE,
	43	EVENT_LIST,
	44	SOURCE_CATALOGUE_LIST
	45	};
	46
	47	inline std::unordered_map<IDS, QString> const MIME_TYPES = {
	48	{IDS::GRAPH, MIME_TYPE_GRAPH},
	49	{IDS::ZONE, MIME_TYPE_ZONE},
	50	{IDS::VARIABLE_LIST, MIME_TYPE_VARIABLE_LIST},
	51	{IDS::PRODUCT_LIST, MIME_TYPE_PRODUCT_LIST},
	52	{IDS::TIME_RANGE, MIME_TYPE_TIME_RANGE},
	53	{IDS::SELECTION_ZONE, MIME_TYPE_SELECTION_ZONE},
	54	{IDS::EVENT_LIST, MIME_TYPE_EVENT_LIST},
	55	{IDS::SOURCE_CATALOGUE_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST}};
	56
	57	inline QVariantList decode(const QByteArray& mimeData)
	58	{
	59	QDataStream stream{mimeData};
	60	QVariantList productList;
	61	stream >> productList;
	62	return productList;
	63	}
	64
	65	inline QByteArray encode(const QVariantList& data)
	66	{
	67	QByteArray encodedData;
	68	QDataStream stream{&encodedData, QIODevice::WriteOnly};
	69	stream << data;
	70	return encodedData;
	71	}
	72
	73	inline QByteArray encode(const QString& data)
	74	{
	75	QByteArray encodedData;
	76	QDataStream stream{&encodedData, QIODevice::WriteOnly};
	77	stream << (QVariantList{} << QVariant{data});
	78	return encodedData;
	79	}
	80
	81	// override mimeData in corresponding object source code
	82	template<typename T> QMimeData* mimeData(const T& object) = delete;
	83
	84	template<IDS id> QVariantList fromMimeData(const QMimeData* mime)
	85	{
	86	return decode(mime->data(MIME_TYPES.at(id)));
	87	}
	88
	89	} // namespace MIME
	90
	91	#endif // SCIQLOP_MIMETYPESDEF_H

src/MimeTypes/MimeTypes.cpp created 644 +3 0

@@ -0,0 +1,3
	1	#include "MimeTypes/MimeTypes.h"
	2
	3

include/DataSource/DataSourceItem.h +21 -1

             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
+            #include <MimeTypes/MimeTypes.h>
+            #include <QMimeData>
             #include <QUuid>
             #include <QVariant>
             #include <QVector>
+            #include <algorithm>
             #include <iomanip>
             #include <iostream>
+            #include <iterator>
             #include <optional>
             #include <trees/algorithms.hpp>
               static const QString ID_DATA_KEY;
               // explicit DataSourceItem(DataSourceItemType type, const QString& name);
-              explicit DataSourceItem(DataSourceItemType type, const QString& name, QVariantHash data = {},
+              explicit DataSourceItem(DataSourceItemType type, const QString& name,
+                                      QVariantHash data               = {},
                                       std::optional<QUuid> sourceUUID = std::nullopt);
               std::unique_ptr<DataSourceItem> clone() const;
               QString name() const noexcept;
               QString icon() const noexcept;
               void setIcon(const QString& iconName);
+              QString path() const noexcept;
               /**
                * Get the item's parent
               spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
+            namespace MIME
+            {
+              inline QMimeData* mimeData(const std::vector<DataSourceItem*>& items)
+              {
+                QVariantList path_list;
+                std::transform(std::cbegin(items), std::cend(items),
+                               std::back_inserter(path_list),
+                               [](const auto& item) { return item->path(); });
+                QMimeData* m = new QMimeData;
+                m->setData(MIME::MIME_TYPE_PRODUCT_LIST, MIME::encode(path_list));
+                return m;
+              }
+            } // namespace MIME
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

include/DataSource/datasources.h +6 -4

             #include "DataSourceItem.h"
             #include <QAbstractItemModel>
-            #include <QObject>
             #include <QMimeData>
+            #include <QObject>
             class DataSources : public QAbstractItemModel
             {
               };
             public:
-              DataSources() : _root(new DataSourceItem(DataSourceItemType::NODE, "root")) {}
+              DataSources() : _root(new DataSourceItem(DataSourceItemType::NODE, "")) {}
               ~DataSources() { delete _root; }
               virtual QVariant data(const QModelIndex& index, int role) const final;
               void updateNodeMetaData(const QString& path,
                                       const QMap<QString, QString>& metaData) noexcept;
-              void createVariable(const DataSourceItem& item);
               void addIcon(const QString& name, QVariant icon)
               {
                 _icons[name] = std::move(icon);
               void setIcon(const QString& path, const QString& iconName);
+            public Q_SLOTS:
+              void createVariable(const DataSourceItem& item);
+              void createVariable(const QString& path);
             Q_SIGNALS:
               void createVariable(const QString& variableName,
                                   const QVariantHash& variableMetadata,

include/Variable/VariableModel2.h +1 -1

               }
             signals:
-              void createVariable(const QVariantHash& productData);
+              void createVariable(const QString& productPath);
               void asyncChangeRange(const std::shared_ptr<Variable2>& variable,
                                     const DateTimeRange& r);
             public slots:

meson.build +2 -6

             core_moc_headers = [
              './include/Common/spimpl.h',
              './include/Common/DateUtils.h',
-             './include/Common/MimeTypesDef.h',
              './include/Common/SignalWaiter.h',
              './include/Common/debug.h',
              './include/Common/MetaTypes.h',
              './include/Common/SortUtils.h',
+             './include/MimeTypes/MimeTypes.h',
              './include/Data/DateTimeRangeHelper.h',
              './include/Data/ScalarTimeSerie.h',
              './include/Data/DateTimeRange.h',
              './include/Network/Downloader.h',
              './include/Settings/SqpSettingsDefs.h',
              './include/Settings/ISqpSettingsBindable.h',
-             './include/DataSource/DataSourceController.h',
              './include/DataSource/datasources.h',
-             './include/DataSource/DataSourcesFilter.h',
              './include/DataSource/DataSourceItem.h',
              './include/DataSource/DataSourceItemAction.h',
              './include/DataSource/DataSourceItemMergeHelper.h',
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers, moc_sources: core_moc_sources)
-            core_sources = ['./src/Common/MimeTypesDef.cpp',
+            core_sources = ['./src/MimeTypes/MimeTypes.cpp',
              './src/Common/SignalWaiter.cpp',
              './src/Common/DateUtils.cpp',
              './src/Network/Downloader.cpp',
              './src/DataSource/DataSourceItemAction.cpp',
              './src/DataSource/DataSourceItemMergeHelper.cpp',
              './src/DataSource/DataSourceItem.cpp',
-             './src/DataSource/DataSourceController.cpp',
              './src/DataSource/datasources.cpp',
-             './src/DataSource/DataSourcesFilter.cpp',
              './src/Time/TimeController.cpp',
              './src/PluginManager/PluginManager.cpp',
              './src/Version.cpp',

src/DataSource/DataSourceItem.cpp +15 0

@@ -149,6 +149,21 void DataSourceItem::setIcon(const QString& iconName)
149	impl->setIcon(iconName);	149	impl->setIcon(iconName);
150	}	150	}
151		151
		152	QString DataSourceItem::path() const noexcept
		153	{
		154	std::vector<QString> path_list;
		155	path_list.push_back(name());
		156	auto node= parentItem();
		157	while( node!=nullptr)
		158	{
		159	path_list.push_back(node->name());
		160	node = node->parentItem();
		161	}
		162	QString path;
		163	std::for_each(path_list.crbegin(),path_list.crend(),[&path](const auto& name){path.append('/'); path.append(name);});
		164	return path;
		165	}
		166
152	DataSourceItem* DataSourceItem::parentItem() const noexcept	167	DataSourceItem* DataSourceItem::parentItem() const noexcept
153	{	168	{
154	return impl->m_Parent;	169	return impl->m_Parent;

src/DataSource/datasources.cpp +11 -15

             #include "DataSource/datasources.h"
-            #include "Common/MimeTypesDef.h"
             #include "DataSource/DataSourceItemAction.h"
+            #include "MimeTypes/MimeTypes.h"
             #include "containers/algorithms.hpp"
             #include <QDataStream>
               // Adds plugin name to product metadata
               // TODO re-consider adding a name attribute to DataSourceItem class
               result->setData(DataSourceItem::PLUGIN_DATA_KEY, DATA_SOURCE_NAME);
-              // result->setData(DataSourceItem::ID_DATA_KEY,
-              //                metaData.value(DataSourceItem::NAME_DATA_KEY));
               // Add action to load product from DataSources
               result->addAction(std::make_unique<DataSourceItemAction>(
             QMimeData* DataSources::mimeData(const QModelIndexList& indexes) const
             {
-              QVariantList productData;
+              std::vector<DataSourceItem*> items;
               std::for_each(std::cbegin(indexes), std::cend(indexes),
-                            [&productData](const auto& index) {
+                            [&items](const auto& index) {
                               if(index.isValid())
                               {
                                 DataSourceItem* item =
                                     static_cast<DataSourceItem*>(index.internalPointer());
-                                if(item->isProductOrComponent())
+                                if(item->isProductOrComponent()) { items.push_back(item); }
-                                { productData.append(item->data()); }
                               }
                             });
-              // TODO refactor this later
+              return MIME::mimeData(items);
-              // maybe just an encode function
-              QByteArray encodedData;
-              QDataStream stream{&encodedData, QIODevice::WriteOnly};
-              stream << productData;
-              auto mimeData = new QMimeData;
-              mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData);
-              return mimeData;
             }
             int DataSources::columnCount(const QModelIndex& parent) const
               }
             }
+            void DataSources::createVariable(const QString& path)
+            {
+              auto node = walk_tree(path, _root);
+              if(node != nullptr) { createVariable(*node); }
+            }
             void DataSources::setIcon(const QString& path, const QString& iconName)
             {
               auto node = walk_tree(path, _root);

src/Variable/VariableModel2.cpp +13 -17

             #include <Common/DateUtils.h>
-            #include <Common/MimeTypesDef.h>
+            #include <MimeTypes/MimeTypes.h>
             #include <cpp_utils_qt/cpp_utils_qt.hpp>
             #include <strings/algorithms.hpp>
             #include <containers/algorithms.hpp>
-            #include <DataSource/DataSourceController.h>
             #include <QMimeData>
             #include <QSize>
             #include <QTimer>
             QStringList VariableModel2::mimeTypes() const
             {
-              return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
+                return {MIME::MIME_TYPE_VARIABLE_LIST, MIME::MIME_TYPE_TIME_RANGE};
             }
             QMimeData* VariableModel2::mimeData(const QModelIndexList& indexes) const
               }
               auto variablesEncodedData = Variable2::mimeData(variables);
-              mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
+              mimeData->setData(MIME::MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
               if(variables.size() == 1)
               {
                 // No time range MIME data if multiple variables are dragged
                 auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
-                mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
+                mimeData->setData(MIME::MIME_TYPE_TIME_RANGE, timeEncodedData);
               }
               return mimeData;
             {
               Q_UNUSED(column);
               // drop of a product
-              return data->hasFormat(MIME_TYPE_PRODUCT_LIST) ||
+              return data->hasFormat(MIME::MIME_TYPE_PRODUCT_LIST) ||
-                     (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid() &&
+              (data->hasFormat(MIME::MIME_TYPE_TIME_RANGE) && parent.isValid() &&
-                      !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
+              !data->hasFormat(MIME::MIME_TYPE_VARIABLE_LIST));
             }
             bool VariableModel2::dropMimeData(const QMimeData* data, Qt::DropAction action,
             {
               auto dropDone = false;
-              if(data->hasFormat(MIME_TYPE_PRODUCT_LIST))
+              if(data->hasFormat(MIME::MIME_TYPE_PRODUCT_LIST))
               {
-                auto productList = DataSourceController::productsDataForMimeData(
+                auto productList = MIME::fromMimeData<MIME::IDS::PRODUCT_LIST>(data);
-                    data->data(MIME_TYPE_PRODUCT_LIST));
+                for(auto product : productList)
-                for(auto metaData : productList)
                 {
-                  emit createVariable(metaData.toHash());
+                  emit createVariable(product.toString());
                 }
                 dropDone = true;
               }
-              else if(data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid())
+              else if(data->hasFormat(MIME::MIME_TYPE_TIME_RANGE) && parent.isValid())
               {
                 auto variable = _variables[parent.row()];
                 auto range =
-                    TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
+                TimeController::timeRangeForMimeData(data->data(MIME::MIME_TYPE_TIME_RANGE));
                 emit asyncChangeRange(variable, range);

tests/DataSource/DataSourcesManualTest.cpp 0 -1

-            #include "DataSource/DataSourcesFilter.h"
             #include "DataSource/datasources.h"
             #include "TestProviders.h"

tests/meson.build 0 -8

                     'deps': [sciqlop_core, qt5test]
                 },
                 {
-                    'name':'TestDataSourceController',
-                    'sources': [
-                                'DataSource/TestDataSourceController.cpp',
-                                'DataSource/DataSourceItemBuilder.cpp'
-                               ],
-                    'deps': [sciqlop_core, qt5test]
-                },
                     'name':'TestDataSources',
                     'sources': [
                                 'DataSource/TestDataSources.cpp'

include/Common/MimeTypesDef.h removed 0 -22

NO CONTENT: file was removed

include/DataSource/DataSourceController.h removed 0 -112

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

include/DataSource/DataSourcesFilter.h removed 0 -55

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

src/Common/MimeTypesDef.cpp removed 0 -10

NO CONTENT: file was removed

src/DataSource/DataSourceController.cpp removed 0 -299

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

src/DataSource/DataSourcesFilter.cpp removed 0 -28

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

tests/DataSource/TestDataSourceController.cpp removed 0 -49

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

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