GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r172:5fabd31f0a85

Merge pull request from SCIQLOP-Initialisation feature/VariableModel3...

leroux -

r172:5fabd31f0a85

parent child

Context file:

r172:5fabd31f0a85

Collapse all files

core/src/Variable/Variable.cpp created 644 +43 0

@@ -0,0 +1,43
	1	#include "Variable/Variable.h"
	2
	3	#include <Data/IDataSeries.h>
	4
	5	struct Variable::VariablePrivate {
	6	explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission)
	7	: m_Name{name}, m_Unit{unit}, m_Mission{mission}, m_DataSeries{nullptr}
	8	{
	9	}
	10
	11	QString m_Name;
	12	QString m_Unit;
	13	QString m_Mission;
	14	std::unique_ptr<IDataSeries> m_DataSeries;
	15	};
	16
	17	Variable::Variable(const QString &name, const QString &unit, const QString &mission)
	18	: impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission)}
	19	{
	20	}
	21
	22	QString Variable::name() const noexcept
	23	{
	24	return impl->m_Name;
	25	}
	26
	27	QString Variable::mission() const noexcept
	28	{
	29	return impl->m_Mission;
	30	}
	31
	32	QString Variable::unit() const noexcept
	33	{
	34	return impl->m_Unit;
	35	}
	36
	37	void Variable::addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
	38	{
	39	if (!impl->m_DataSeries) {
	40	impl->m_DataSeries = std::move(dataSeries);
	41	}
	42	/// @todo : else, merge the two data series (if possible)
	43	}

cmake/sciqlop.cmake +1 -1

             #
             # Configure the compiler
             #
-            INCLUDE("cmake/compiler/compiler.cmake")
+            #INCLUDE("cmake/compiler/compiler.cmake")
             #
             # Find all necessary dependencies

cmake/sciqlop_package_qt.cmake +1 -1

             #ENDFOREACH()
             EXECUTE_PROCESS(
-            COMMAND windeployqt ${WINDEPLOYQT_ARGS} ${SCIQLOP_EXE_LOCATION}
+            COMMAND windeployqt ${WINDEPLOYQT_ARGS} -printsupport ${SCIQLOP_EXE_LOCATION}
             OUTPUT_VARIABLE QT_FILES
             )

core/include/Data/IDataProvider.h +5 0

             #include <memory>
+            #include <QObject>
             class DataProviderParameters;
             class IDataSeries;
                 retrieveData(const DataProviderParameters &parameters) const = 0;
             };
+            // Required for using shared_ptr in signals/slots
+            Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)
             #endif // SCIQLOP_IDATAPROVIDER_H

core/include/DataSource/DataSourceController.h +12 -1

                 /**
                  * Loads an item (product) as a variable in SciQlop
+                 * @param dataSourceUid the unique id of the data source containing the item. It is used to get
+                 * the data provider associated to the data source, and pass it to for the variable creation
                  * @param productItem the item to load
                  */
-                void loadProductItem(const DataSourceItem &productItem) noexcept;
+                void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
             public slots:
                 /// Manage init/end of the controller
                 /// Signal emitted when a structure has been set for a data source
                 void dataSourceItemSet(DataSourceItem *dataSourceItem);
+                /**
+                 * Signal emitted when a variable creation is asked for a product
+                 * @param variableName the name of the variable
+                 * @param variableProvider the provider that will be used to retrieve the data of the variable
+                 * (can be null)
+                 */
+                void variableCreationRequested(const QString &variableName,
+                                               std::shared_ptr<IDataProvider> variableProvider);
             private:
                 void waitForFinish();

core/include/Variable/Variable.h +23 -11

@@ -1,20 +1,32
1	#ifndef SCIQLOP_VARIABLE_H	1	#ifndef SCIQLOP_VARIABLE_H
2	#define SCIQLOP_VARIABLE_H	2	#define SCIQLOP_VARIABLE_H
3		3
4	#include <QString>	4	#include <Common/spimpl.h>
		5
		6	#include <QObject>
		7
		8	class IDataSeries;
		9	class QString;
5		10
6	/**	11	/**
7	* @brief The Variable ~~struct~~ represents a variable in SciQlop.	12	* @brief The Variable class represents a variable in SciQlop.
8	*/	13	*/
9	~~struct~~ Variable {	14	class Variable {
10	explicit Variable(const QString &name, const QString &unit, const QString &mission)	15	public:
11	: m_Name{name}, m_Unit{unit}, m_Mission{mission}	16	explicit Variable(const QString &name, const QString &unit, const QString &mission);
12	{	17
13	}	18	QString name() const noexcept;
14		19	QString mission() const noexcept;
15	QString m_Name;	20	QString unit() const noexcept;
16	QString m_Unit;	21
17	QString m_Mission;	22	void addDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
		23
		24	private:
		25	class VariablePrivate;
		26	spimpl::unique_impl_ptr<VariablePrivate> impl;
18	};	27	};
19		28
		29	// Required for using shared_ptr in signals/slots
		30	Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
		31
20	#endif // SCIQLOP_VARIABLE_H	32	#endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableController.h +11 -6

             #include <Common/spimpl.h>
+            class IDataProvider;
             class Variable;
             class VariableModel;
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
+                VariableModel *variableModel() noexcept;
+            signals:
+                /// Signal emitted when a variable has been created
+                void variableCreated(std::shared_ptr<Variable> variable);
+            public slots:
                 /**
-                 * Creates a new variable
+                 * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
-                 * @return the variable if it was created successfully, nullptr otherwise
+                 * @param provider the data provider for the new variable
                  */
-                Variable *createVariable(const QString &name) noexcept;
+                void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
-                VariableModel *variableModel() noexcept;
-            public slots:
                 void initialize();
                 void finalize();

core/include/Variable/VariableModel.h +5 -2

             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
+            class IDataSeries;
             class Variable;
             /**
                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
-                 * @return the variable if it was created successfully, nullptr otherwise
+                 * @param defaultDataSeries the default data of the new variable
+                 * @return the pointer to the new variable
                  */
-                Variable *createVariable(const QString &name) noexcept;
+                std::shared_ptr<Variable>
+                createVariable(const QString &name, std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
                 // /////////////////////////// //
                 // QAbstractTableModel methods //

core/include/Visualization/VisualizationController.h +4 0

             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
             class DataSourceItem;
+            class Variable;
             /**
              * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
                 virtual ~VisualizationController();
             public slots:
+                /// Slot called when a variable has been created in SciQlop
+                void onVariableCreated(std::shared_ptr<Variable> variable) noexcept;
                 /// Manage init/end of the controller
                 void initialize();
                 void finalize();

core/src/DataSource/DataSourceController.cpp +19 -5

-            #include <DataSource/DataSourceController.h>
+            #include "DataSource/DataSourceController.h"
-            #include <DataSource/DataSourceItem.h>
+            #include "DataSource/DataSourceItem.h"
             #include <Data/IDataProvider.h>
                 /// Data sources structures
                 std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
                 /// Data providers registered
-                std::map<QUuid, std::unique_ptr<IDataProvider> > m_DataProviders;
+                /// @remarks Data providers are stored as shared_ptr as they can be sent to a variable and
+                /// continue to live without necessarily the data source controller
+                std::map<QUuid, std::shared_ptr<IDataProvider> > m_DataProviders;
             };
             DataSourceController::DataSourceController(QObject *parent)
                 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
             {
                 if (impl->m_DataSources.contains(dataSourceUid)) {
+                    // The data provider is implicitly converted to a shared_ptr
                     impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
                     // Retrieves the data source item to emit the signal with it
                 }
             }
-            void DataSourceController::loadProductItem(const DataSourceItem &productItem) noexcept
+            void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
+                                                       const DataSourceItem &productItem) noexcept
             {
-                /// @todo ALX
+                if (productItem.type() == DataSourceItemType::PRODUCT) {
+                    /// Retrieves the data provider of the data source (if any)
+                    auto it = impl->m_DataProviders.find(dataSourceUid);
+                    auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
+                    /// @todo retrieve timerange, and pass it to the signal
+                    emit variableCreationRequested(productItem.name(), dataProvider);
+                }
+                else {
+                    qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
+                }
             }
             void DataSourceController::initialize()

core/src/DataSource/DataSourceItem.cpp +1 -1

             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
-                QVector<DataSourceItemAction *> result{};
+                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(); });

core/src/Variable/VariableController.cpp +36 -4

@@ -1,11 +1,34
1	#include <Variable/VariableController.h>	1	#include <Variable/VariableController.h>
2	#include <Variable/VariableModel.h>	2	#include <Variable/VariableModel.h>
3		3
		4	#include <Data/DataProviderParameters.h>
		5	#include <Data/IDataProvider.h>
		6	#include <Data/IDataSeries.h>
		7
		8	#include <QDateTime>
4	#include <QMutex>	9	#include <QMutex>
5	#include <QThread>	10	#include <QThread>
6		11
7	Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")	12	Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
8		13
		14	namespace {
		15
		16	/// @todo Generates default dataseries, according to the provider passed in parameter. This method
		17	/// will be deleted when the timerange is recovered from SciQlop
		18	std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider) noexcept
		19	{
		20	auto parameters = DataProviderParameters{
		21	// Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
		22	static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
		23	/ 1000.),
		24	static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
		25	/ 1000.};
		26
		27	return provider.retrieveData(parameters);
		28	}
		29
		30	} // namespace
		31
9	struct VariableController::VariableControllerPrivate {	32	struct VariableController::VariableControllerPrivate {
10	explicit VariableControllerPrivate(VariableController *parent)	33	explicit VariableControllerPrivate(VariableController *parent)
11	: m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}	34	: m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
@@ -31,14 +54,23 VariableController::~VariableController()
31	this->waitForFinish();	54	this->waitForFinish();
32	}	55	}
33		56
34	Variable *VariableController::~~createV~~ariable(~~const~~ ~~QString~~ &~~name~~) noexcept	57	VariableModel *VariableController::variableModel() noexcept
35	{	58	{
36	return impl->m_VariableModel->~~createVariable~~(~~name~~);	59	return impl->m_VariableModel;
37	}	60	}
38		61
39	VariableModel *VariableController::variableModel() noexcept	62	void VariableController::createVariable(const QString &name,
		63	std::shared_ptr<IDataProvider> provider) noexcept
40	{	64	{
41	return impl->m_VariableModel;	65	/// @todo : for the moment :
		66	/// - the provider is only used to retrieve data from the variable for its initialization, but
		67	/// it will be retained later
		68	/// - default data are generated for the variable, without taking into account the timerange set
		69	/// in sciqlop
		70	if (auto newVariable
		71	= impl->m_VariableModel->createVariable(name, generateDefaultDataSeries(*provider))) {
		72	emit variableCreated(newVariable);
		73	}
42	}	74	}
43		75
44	void VariableController::initialize()	76	void VariableController::initialize()

core/src/Variable/VariableModel.cpp +14 -9

+            #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
-            #include <Variable/Variable.h>
+            #include <Data/IDataSeries.h>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
-                std::vector<std::unique_ptr<Variable> > m_Variables;
+                std::vector<std::shared_ptr<Variable> > m_Variables;
             };
             VariableModel::VariableModel(QObject *parent)
             {
             }
-            Variable *VariableModel::createVariable(const QString &name) noexcept
+            std::shared_ptr<Variable>
+            VariableModel::createVariable(const QString &name,
+                                          std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 /// @todo For the moment, the other data of the variable is initialized with default values
                 auto variable
-                    = std::make_unique<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
+                    = std::make_shared<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
-                impl->m_Variables.push_back(std::move(variable));
+                variable->addDataSeries(std::move(defaultDataSeries));
+                impl->m_Variables.push_back(variable);
                 endInsertRows();
-                return impl->m_Variables.at(insertIndex).get();
+                return variable;
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
-                                return variable->m_Name;
+                                return variable->name();
                             case UNIT_COLUMN:
-                                return variable->m_Unit;
+                                return variable->unit();
                             case MISSION_COLUMN:
-                                return variable->m_Mission;
+                                return variable->mission();
                             default:
                                 // No action
                                 break;

core/src/Visualization/VisualizationController.cpp +8 0

             #include <Visualization/VisualizationController.h>
+            #include <Variable/Variable.h>
             #include <QMutex>
             #include <QThread>
                 this->waitForFinish();
             }
+            void VisualizationController::onVariableCreated(std::shared_ptr<Variable> variable) noexcept
+            {
+                /// @todo ALX : make new graph for the variable
+                qCDebug(LOG_VisualizationController()) << "new variable to display";
+            }
             void VisualizationController::initialize()
             {
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")

core/vera-exclusions/exclusions.txt +3 0

             # Ignore false positive relative to an alias
             DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)
+            # Ignore false positive relative to unnamed namespace
+            VariableController\.cpp:\d+:.*IPSIS_F13.*

gui/src/SqpApplication.cpp +19 -1

             #include "SqpApplication.h"
+            #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <QThread>
+            #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
+                    // /////////////////////////////// //
+                    // Connections between controllers //
+                    // /////////////////////////////// //
+                    // VariableController <-> DataSourceController
+                    qRegisterMetaType<std::shared_ptr<IDataProvider> >();
+                    connect(m_DataSourceController.get(),
+                            SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
+                            m_VariableController.get(),
+                            SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
+                    // VariableController <-> VisualizationController
+                    qRegisterMetaType<std::shared_ptr<Variable> >();
+                    connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
+                            m_VisualizationController.get(),
+                            SLOT(onVariableCreated(std::shared_ptr<Variable>)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();

plugins/mockplugin/src/MockPlugin.cpp +9 -7

                 return std::make_unique<CosinusProvider>();
             }
-            std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
+            std::unique_ptr<DataSourceItem> createProductItem(const QString &productName,
+                                                              const QUuid &dataSourceUid)
             {
                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
                                                                QVector<QVariant>{productName});
                 // Add action to load product from DataSourceController
                 result->addAction(std::make_unique<DataSourceItemAction>(
-                    QObject::tr("Load %1 product").arg(productName), [productName](DataSourceItem &item) {
+                    QObject::tr("Load %1 product").arg(productName),
+                    [productName, dataSourceUid](DataSourceItem &item) {
                         if (auto app = sqpApp) {
-                            app->dataSourceController().loadProductItem(item);
+                            app->dataSourceController().loadProductItem(dataSourceUid, item);
                         }
                     }));
             }
             /// Creates the data source item relative to the plugin
-            std::unique_ptr<DataSourceItem> createDataSourceItem() noexcept
+            std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
             {
                 // Magnetic field products
                 auto magneticFieldFolder = std::make_unique<DataSourceItem>(
                     DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
-                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM")));
+                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM"), dataSourceUid));
-                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC")));
+                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC"), dataSourceUid));
                 // Electric field products
                 auto electricFieldFolder = std::make_unique<DataSourceItem>(
                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
                     // Sets data source tree
-                    dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
+                    dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
                     // Sets data provider
                     dataSourceController.setDataProvider(dataSourceUid, createDataProvider());

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