HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r173:030b888e93aa

Merge branch 'feature/VariableModel3' into develop

Alexandre Leroux -

r173:030b888e93aa

parent child

Context file:

r173:030b888e93aa

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	}

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

             #ifndef SCIQLOP_IDATAPROVIDER_H
             #define SCIQLOP_IDATAPROVIDER_H
             #include <memory>
+            #include <QObject>
             class DataProviderParameters;
             class IDataSeries;
             /**
              * @brief The IDataProvider interface aims to declare a data provider.
              *
              * A data provider is an entity that generates data and returns it according to various parameters
              * (time interval, product to retrieve the data, etc.)
              *
              * @sa IDataSeries
              */
             class IDataProvider {
             public:
                 virtual ~IDataProvider() noexcept = default;
                 virtual std::unique_ptr<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

             #ifndef SCIQLOP_DATASOURCECONTROLLER_H
             #define SCIQLOP_DATASOURCECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceController)
             class DataSourceItem;
             class IDataProvider;
             /**
              * @brief The DataSourceController class aims to make the link between SciQlop and its plugins. This
              * is the intermediate class that SciQlop has to use in the way to connect a data source. Please
              * first use register method to initialize a plugin specified by its metadata name (JSON plugin
              * source) then others specifics method will be able to access it. You can load a data source driver
              * plugin then create a data source.
              */
             class DataSourceController : public QObject {
                 Q_OBJECT
             public:
                 explicit DataSourceController(QObject *parent = 0);
                 virtual ~DataSourceController();
                 /**
                  * Registers a data source. The method delivers a unique id that can be used afterwards to
                  * access to the data source properties (structure, connection parameters, data provider, etc.)
                  * @param dataSourceName the name of the data source
                  * @return the unique id with which the data source has been registered
                  */
                 QUuid registerDataSource(const QString &dataSourceName) noexcept;
                 /**
                  * Sets the structure of a data source. The controller takes ownership of the structure.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataSourceItem the structure of the data source
                  * @sa registerDataSource()
                  */
                 void setDataSourceItem(const QUuid &dataSourceUid,
                                        std::unique_ptr<DataSourceItem> dataSourceItem) noexcept;
                 /**
                  * Sets the data provider used to retrieve data from of a data source. The controller takes
                  * ownership of the provider.
                  * @param dataSourceUid the unique id with which the data source has been registered into the
                  * controller. If it is invalid, the method has no effect.
                  * @param dataProvider the provider of the data source
                  * @sa registerDataSource()
                  */
                 void setDataProvider(const QUuid &dataSourceUid,
                                      std::unique_ptr<IDataProvider> dataProvider) noexcept;
                 /**
                  * 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
                 void initialize();
                 void finalize();
             signals:
                 /// 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();
                 class DataSourceControllerPrivate;
                 spimpl::unique_impl_ptr<DataSourceControllerPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCECONTROLLER_H

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

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
+            class IDataProvider;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 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();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

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

             #ifndef SCIQLOP_VARIABLEMODEL_H
             #define SCIQLOP_VARIABLEMODEL_H
             #include <Common/spimpl.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
+            class IDataSeries;
             class Variable;
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class VariableModel : public QAbstractTableModel {
             public:
                 explicit VariableModel(QObject *parent = nullptr);
                 /**
                  * 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 //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
             private:
                 class VariableModelPrivate;
                 spimpl::unique_impl_ptr<VariableModelPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLEMODEL_H

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

             #ifndef SCIQLOP_VISUALIZATIONCONTROLLER_H
             #define SCIQLOP_VISUALIZATIONCONTROLLER_H
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
             class DataSourceItem;
+            class Variable;
             /**
              * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
              * This is the intermediate class that SciQlop has to use in the way to connect a data source.
              * Please first use register method to initialize a plugin specified by its metadata name (JSON
              * plugin source) then others specifics method will be able to access it. You can load a data source
              * driver plugin then create a data source.
              */
             class VisualizationController : public QObject {
                 Q_OBJECT
             public:
                 explicit VisualizationController(QObject *parent = 0);
                 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();
             private:
                 void waitForFinish();
                 class VisualizationControllerPrivate;
                 spimpl::unique_impl_ptr<VisualizationControllerPrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONCONTROLLER_H

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>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_DataSourceController, "DataSourceController")
             class DataSourceController::DataSourceControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
                 /// Data sources registered
                 QHash<QUuid, QString> m_DataSources;
                 /// 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)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
                                                     << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
                                                     << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid DataSourceController::registerDataSource(const QString &dataSourceName) noexcept
             {
                 auto dataSourceUid = QUuid::createUuid();
                 impl->m_DataSources.insert(dataSourceUid, dataSourceName);
                 return dataSourceUid;
             }
             void DataSourceController::setDataSourceItem(
                 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
                     auto it = impl->m_DataSourceItems.find(dataSourceUid);
                     if (it != impl->m_DataSourceItems.end()) {
                         emit dataSourceItemSet(it->second.get());
                     }
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data source item for uid %1 : no "
                                                                 "data source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
             void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
                                                        std::unique_ptr<IDataProvider> dataProvider) noexcept
             {
                 if (impl->m_DataSources.contains(dataSourceUid)) {
                     impl->m_DataProviders.insert(std::make_pair(dataSourceUid, std::move(dataProvider)));
                 }
                 else {
                     qCWarning(LOG_DataSourceController()) << tr("Can't set data provider for uid %1 : no data "
                                                                 "source has been registered with the uid")
                                                                  .arg(dataSourceUid.toString());
                 }
             }
-            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()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
                                                     << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }
             void DataSourceController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void DataSourceController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
             namespace {
             /// Index of the 'name' value in the item
             const auto NAME_INDEX = 0;
             } // namespace
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> 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;
                 QVector<QVariant> m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             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(); });
                 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(int dataIndex) const noexcept
             {
                 return impl->m_Data.value(dataIndex);
             }
             QString DataSourceItem::name() const noexcept
             {
                 return data(NAME_INDEX).toString();
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }

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

             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
+            #include <Data/DataProviderParameters.h>
+            #include <Data/IDataProvider.h>
+            #include <Data/IDataSeries.h>
+            #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
+            namespace {
+            /// @todo Generates default dataseries, according to the provider passed in parameter. This method
+            /// will be deleted when the timerange is recovered from SciQlop
+            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider) noexcept
+            {
+                auto parameters = DataProviderParameters{
+                    // Remarks : we don't use toSecsSinceEpoch() here (method is for Qt 5.8 or above)
+                    static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 00}}.toMSecsSinceEpoch()
+                                        / 1000.),
+                    static_cast<double>(QDateTime{QDate{2017, 01, 01}, QTime{12, 01}}.toMSecsSinceEpoch())
+                        / 1000.};
+                return provider.retrieveData(parameters);
+            }
+            } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
-            Variable *VariableController::createVariable(const QString &name) noexcept
+            VariableModel *VariableController::variableModel() noexcept
             {
-                return impl->m_VariableModel->createVariable(name);
+                return impl->m_VariableModel;
             }
-            VariableModel *VariableController::variableModel() noexcept
+            void VariableController::createVariable(const QString &name,
+                                                    std::shared_ptr<IDataProvider> provider) noexcept
             {
-                return impl->m_VariableModel;
+                /// @todo : for the moment :
+                /// - the provider is only used to retrieve data from the variable for its initialization, but
+                /// it will be retained later
+                /// - default data are generated for the variable, without taking into account the timerange set
+                /// in sciqlop
+                if (auto newVariable
+                    = impl->m_VariableModel->createVariable(name, generateDefaultDataSeries(*provider))) {
+                    emit variableCreated(newVariable);
+                }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto UNIT_COLUMN = 1;
             const auto MISSION_COLUMN = 2;
             const auto NB_COLUMNS = 3;
             } // namespace
             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)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
-            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
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     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;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     switch (section) {
                         case NAME_COLUMN:
                             return tr("Name");
                         case UNIT_COLUMN:
                             return tr("Unit");
                         case MISSION_COLUMN:
                             return tr("Mission");
                         default:
                             // No action
                             break;
                     }
                     qWarning(LOG_VariableModel())
                         << tr("Can't get header data (unknown column %1)").arg(section);
                 }
                 return QVariant{};
             }

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

             #include <Visualization/VisualizationController.h>
+            #include <Variable/Variable.h>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_VisualizationController, "VisualizationController")
             class VisualizationController::VisualizationControllerPrivate {
             public:
                 QMutex m_WorkingMutex;
             };
             VisualizationController::VisualizationController(QObject *parent)
                     : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
             {
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
                                                        << QThread::currentThread();
             }
             VisualizationController::~VisualizationController()
             {
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
                                                        << QThread::currentThread();
                 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")
                                                        << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
             }
             void VisualizationController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VisualizationController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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

             # On ignore toutes les règles vera++ pour le fichier spimpl
             Common/spimpl\.h:\d+:.*
             # Ignore false positive relative to two class definitions in a same file
             DataSourceItem\.h:\d+:.*IPSIS_S01.*
             # Ignore false positive relative to a template class
             ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
             ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
             ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
             # 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>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           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);
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
                 QThread m_DataSourceControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }

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

             #include "MockPlugin.h"
             #include "CosinusProvider.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
             /// Creates the data provider relative to the plugin
             std::unique_ptr<IDataProvider> createDataProvider() noexcept
             {
                 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);
                         }
                     }));
                 return result;
             }
             /// 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>(
                     DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Electric field")});
                 // Root
                 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                              QVector<QVariant>{DATA_SOURCE_NAME});
                 root->appendChild(std::move(magneticFieldFolder));
                 root->appendChild(std::move(electricFieldFolder));
                 return root;
             }
             } // namespace
             void MockPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     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());
                 }
                 else {
                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

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