##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge branch 'feature/VariableModel3' into develop
Alexandre Leroux -
r160:030b888e93aa merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -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 }
Show file before | Show file after | Hide comments
@@ -3,6 +3,8
3 3
4 4 #include <memory>
5 5
6 #include <QObject>
7
6 8 class DataProviderParameters;
7 9 class IDataSeries;
8 10
@@ -22,4 +24,7 public:
22 24 retrieveData(const DataProviderParameters &parameters) const = 0;
23 25 };
24 26
27 // Required for using shared_ptr in signals/slots
28 Q_DECLARE_METATYPE(std::shared_ptr<IDataProvider>)
29
25 30 #endif // SCIQLOP_IDATAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -56,9 +56,11 public:
56 56
57 57 /**
58 58 * Loads an item (product) as a variable in SciQlop
59 * @param dataSourceUid the unique id of the data source containing the item. It is used to get
60 * the data provider associated to the data source, and pass it to for the variable creation
59 61 * @param productItem the item to load
60 62 */
61 void loadProductItem(const DataSourceItem &productItem) noexcept;
63 void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
62 64
63 65 public slots:
64 66 /// Manage init/end of the controller
@@ -69,6 +71,15 signals:
69 71 /// Signal emitted when a structure has been set for a data source
70 72 void dataSourceItemSet(DataSourceItem *dataSourceItem);
71 73
74 /**
75 * Signal emitted when a variable creation is asked for a product
76 * @param variableName the name of the variable
77 * @param variableProvider the provider that will be used to retrieve the data of the variable
78 * (can be null)
79 */
80 void variableCreationRequested(const QString &variableName,
81 std::shared_ptr<IDataProvider> variableProvider);
82
72 83 private:
73 84 void waitForFinish();
74 85
Show file before | Show file after | Hide comments
@@ -1,20 +1,32
1 1 #ifndef SCIQLOP_VARIABLE_H
2 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 {
10 explicit Variable(const QString &name, const QString &unit, const QString &mission)
11 : m_Name{name}, m_Unit{unit}, m_Mission{mission}
12 {
13 }
14
15 QString m_Name;
16 QString m_Unit;
17 QString m_Mission;
14 class Variable {
15 public:
16 explicit Variable(const QString &name, const QString &unit, const QString &mission);
17
18 QString name() const noexcept;
19 QString mission() const noexcept;
20 QString unit() const noexcept;
21
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 32 #endif // SCIQLOP_VARIABLE_H
Show file before | Show file after | Hide comments
@@ -6,6 +6,7
6 6
7 7 #include <Common/spimpl.h>
8 8
9 class IDataProvider;
9 10 class Variable;
10 11 class VariableModel;
11 12
@@ -20,16 +21,20 public:
20 21 explicit VariableController(QObject *parent = 0);
21 22 virtual ~VariableController();
22 23
24 VariableModel *variableModel() noexcept;
25
26 signals:
27 /// Signal emitted when a variable has been created
28 void variableCreated(std::shared_ptr<Variable> variable);
29
30 public slots:
23 31 /**
24 * Creates a new variable
32 * Creates a new variable and adds it to the model
25 33 * @param name the name of the new variable
26 * @return the variable if it was created successfully, nullptr otherwise
34 * @param provider the data provider for the new variable
27 35 */
28 Variable *createVariable(const QString &name) noexcept;
36 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
29 37
30 VariableModel *variableModel() noexcept;
31
32 public slots:
33 38 void initialize();
34 39 void finalize();
35 40
Show file before | Show file after | Hide comments
@@ -8,6 +8,7
8 8
9 9 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableModel)
10 10
11 class IDataSeries;
11 12 class Variable;
12 13
13 14 /**
@@ -20,9 +21,11 public:
20 21 /**
21 22 * Creates a new variable in the model
22 23 * @param name the name of the new variable
23 * @return the variable if it was created successfully, nullptr otherwise
24 * @param defaultDataSeries the default data of the new variable
25 * @return the pointer to the new variable
24 26 */
25 Variable *createVariable(const QString &name) noexcept;
27 std::shared_ptr<Variable>
28 createVariable(const QString &name, std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
26 29
27 30 // /////////////////////////// //
28 31 // QAbstractTableModel methods //
Show file before | Show file after | Hide comments
@@ -10,6 +10,7
10 10 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationController)
11 11
12 12 class DataSourceItem;
13 class Variable;
13 14
14 15 /**
15 16 * @brief The VisualizationController class aims to make the link between SciQlop and its plugins.
@@ -25,6 +26,9 public:
25 26 virtual ~VisualizationController();
26 27
27 28 public slots:
29 /// Slot called when a variable has been created in SciQlop
30 void onVariableCreated(std::shared_ptr<Variable> variable) noexcept;
31
28 32 /// Manage init/end of the controller
29 33 void initialize();
30 34 void finalize();
Show file before | Show file after | Hide comments
@@ -1,5 +1,5
1 #include <DataSource/DataSourceController.h>
2 #include <DataSource/DataSourceItem.h>
1 #include "DataSource/DataSourceController.h"
2 #include "DataSource/DataSourceItem.h"
3 3
4 4 #include <Data/IDataProvider.h>
5 5
@@ -19,7 +19,9 public:
19 19 /// Data sources structures
20 20 std::map<QUuid, std::unique_ptr<DataSourceItem> > m_DataSourceItems;
21 21 /// Data providers registered
22 std::map<QUuid, std::unique_ptr<IDataProvider> > m_DataProviders;
22 /// @remarks Data providers are stored as shared_ptr as they can be sent to a variable and
23 /// continue to live without necessarily the data source controller
24 std::map<QUuid, std::shared_ptr<IDataProvider> > m_DataProviders;
23 25 };
24 26
25 27 DataSourceController::DataSourceController(QObject *parent)
@@ -48,6 +50,7 void DataSourceController::setDataSourceItem(
48 50 const QUuid &dataSourceUid, std::unique_ptr<DataSourceItem> dataSourceItem) noexcept
49 51 {
50 52 if (impl->m_DataSources.contains(dataSourceUid)) {
53 // The data provider is implicitly converted to a shared_ptr
51 54 impl->m_DataSourceItems.insert(std::make_pair(dataSourceUid, std::move(dataSourceItem)));
52 55
53 56 // Retrieves the data source item to emit the signal with it
@@ -76,9 +79,20 void DataSourceController::setDataProvider(const QUuid &dataSourceUid,
76 79 }
77 80 }
78 81
79 void DataSourceController::loadProductItem(const DataSourceItem &productItem) noexcept
82 void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
83 const DataSourceItem &productItem) noexcept
80 84 {
81 /// @todo ALX
85 if (productItem.type() == DataSourceItemType::PRODUCT) {
86 /// Retrieves the data provider of the data source (if any)
87 auto it = impl->m_DataProviders.find(dataSourceUid);
88 auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
89
90 /// @todo retrieve timerange, and pass it to the signal
91 emit variableCreationRequested(productItem.name(), dataProvider);
92 }
93 else {
94 qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
95 }
82 96 }
83 97
84 98 void DataSourceController::initialize()
Show file before | Show file after | Hide comments
@@ -30,7 +30,7 DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
30 30
31 31 QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
32 32 {
33 QVector<DataSourceItemAction *> result{};
33 auto result = QVector<DataSourceItemAction *>{};
34 34
35 35 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
36 36 std::back_inserter(result), [](const auto &action) { return action.get(); });
Show file before | Show file after | Hide comments
@@ -1,11 +1,34
1 1 #include <Variable/VariableController.h>
2 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 9 #include <QMutex>
5 10 #include <QThread>
6 11
7 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 32 struct VariableController::VariableControllerPrivate {
10 33 explicit VariableControllerPrivate(VariableController *parent)
11 34 : m_WorkingMutex{}, m_VariableModel{new VariableModel{parent}}
@@ -31,14 +54,23 VariableController::~VariableController()
31 54 this->waitForFinish();
32 55 }
33 56
34 Variable *VariableController::createVariable(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 76 void VariableController::initialize()
Show file before | Show file after | Hide comments
@@ -1,6 +1,7
1 #include <Variable/Variable.h>
1 2 #include <Variable/VariableModel.h>
2 3
3 #include <Variable/Variable.h>
4 #include <Data/IDataSeries.h>
4 5
5 6 Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
6 7
@@ -16,7 +17,7 const auto NB_COLUMNS = 3;
16 17
17 18 struct VariableModel::VariableModelPrivate {
18 19 /// Variables created in SciQlop
19 std::vector<std::unique_ptr<Variable> > m_Variables;
20 std::vector<std::shared_ptr<Variable> > m_Variables;
20 21 };
21 22
22 23 VariableModel::VariableModel(QObject *parent)
@@ -24,19 +25,23 VariableModel::VariableModel(QObject *parent)
24 25 {
25 26 }
26 27
27 Variable *VariableModel::createVariable(const QString &name) noexcept
28 std::shared_ptr<Variable>
29 VariableModel::createVariable(const QString &name,
30 std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
28 31 {
29 32 auto insertIndex = rowCount();
30 33 beginInsertRows({}, insertIndex, insertIndex);
31 34
32 35 /// @todo For the moment, the other data of the variable is initialized with default values
33 36 auto variable
34 = std::make_unique<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
35 impl->m_Variables.push_back(std::move(variable));
37 = std::make_shared<Variable>(name, QStringLiteral("unit"), QStringLiteral("mission"));
38 variable->addDataSeries(std::move(defaultDataSeries));
39
40 impl->m_Variables.push_back(variable);
36 41
37 42 endInsertRows();
38 43
39 return impl->m_Variables.at(insertIndex).get();
44 return variable;
40 45 }
41 46
42 47 int VariableModel::columnCount(const QModelIndex &parent) const
@@ -67,11 +72,11 QVariant VariableModel::data(const QModelIndex &index, int role) const
67 72 if (auto variable = impl->m_Variables.at(index.row()).get()) {
68 73 switch (index.column()) {
69 74 case NAME_COLUMN:
70 return variable->m_Name;
75 return variable->name();
71 76 case UNIT_COLUMN:
72 return variable->m_Unit;
77 return variable->unit();
73 78 case MISSION_COLUMN:
74 return variable->m_Mission;
79 return variable->mission();
75 80 default:
76 81 // No action
77 82 break;
Show file before | Show file after | Hide comments
@@ -1,5 +1,7
1 1 #include <Visualization/VisualizationController.h>
2 2
3 #include <Variable/Variable.h>
4
3 5 #include <QMutex>
4 6 #include <QThread>
5 7
@@ -27,6 +29,12 VisualizationController::~VisualizationController()
27 29 this->waitForFinish();
28 30 }
29 31
32 void VisualizationController::onVariableCreated(std::shared_ptr<Variable> variable) noexcept
33 {
34 /// @todo ALX : make new graph for the variable
35 qCDebug(LOG_VisualizationController()) << "new variable to display";
36 }
37
30 38 void VisualizationController::initialize()
31 39 {
32 40 qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
Show file before | Show file after | Hide comments
@@ -11,3 +11,6 ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
11 11
12 12 # Ignore false positive relative to an alias
13 13 DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)
14
15 # Ignore false positive relative to unnamed namespace
16 VariableController\.cpp:\d+:.*IPSIS_F13.*
Show file before | Show file after | Hide comments
@@ -1,7 +1,9
1 1 #include "SqpApplication.h"
2 2
3 #include <Data/IDataProvider.h>
3 4 #include <DataSource/DataSourceController.h>
4 5 #include <QThread>
6 #include <Variable/Variable.h>
5 7 #include <Variable/VariableController.h>
6 8 #include <Visualization/VisualizationController.h>
7 9
@@ -14,6 +16,23 public:
14 16 m_VariableController{std::make_unique<VariableController>()},
15 17 m_VisualizationController{std::make_unique<VisualizationController>()}
16 18 {
19 // /////////////////////////////// //
20 // Connections between controllers //
21 // /////////////////////////////// //
22
23 // VariableController <-> DataSourceController
24 qRegisterMetaType<std::shared_ptr<IDataProvider> >();
25 connect(m_DataSourceController.get(),
26 SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
27 m_VariableController.get(),
28 SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
29
30 // VariableController <-> VisualizationController
31 qRegisterMetaType<std::shared_ptr<Variable> >();
32 connect(m_VariableController.get(), SIGNAL(variableCreated(std::shared_ptr<Variable>)),
33 m_VisualizationController.get(),
34 SLOT(onVariableCreated(std::shared_ptr<Variable>)));
35
17 36 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
18 37 m_VariableController->moveToThread(&m_VariableControllerThread);
19 38 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
@@ -61,7 +80,6 SqpApplication::SqpApplication(int &argc, char **argv)
61 80 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
62 81 impl->m_VisualizationController.get(), &VisualizationController::finalize);
63 82
64
65 83 impl->m_DataSourceControllerThread.start();
66 84 impl->m_VariableControllerThread.start();
67 85 impl->m_VisualizationControllerThread.start();
Show file before | Show file after | Hide comments
@@ -20,16 +20,18 std::unique_ptr<IDataProvider> createDataProvider() noexcept
20 20 return std::make_unique<CosinusProvider>();
21 21 }
22 22
23 std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
23 std::unique_ptr<DataSourceItem> createProductItem(const QString &productName,
24 const QUuid &dataSourceUid)
24 25 {
25 26 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
26 27 QVector<QVariant>{productName});
27 28
28 29 // Add action to load product from DataSourceController
29 30 result->addAction(std::make_unique<DataSourceItemAction>(
30 QObject::tr("Load %1 product").arg(productName), [productName](DataSourceItem &item) {
31 QObject::tr("Load %1 product").arg(productName),
32 [productName, dataSourceUid](DataSourceItem &item) {
31 33 if (auto app = sqpApp) {
32 app->dataSourceController().loadProductItem(item);
34 app->dataSourceController().loadProductItem(dataSourceUid, item);
33 35 }
34 36 }));
35 37
@@ -37,13 +39,13 std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
37 39 }
38 40
39 41 /// Creates the data source item relative to the plugin
40 std::unique_ptr<DataSourceItem> createDataSourceItem() noexcept
42 std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
41 43 {
42 44 // Magnetic field products
43 45 auto magneticFieldFolder = std::make_unique<DataSourceItem>(
44 46 DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
45 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM")));
46 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC")));
47 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM"), dataSourceUid));
48 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC"), dataSourceUid));
47 49
48 50 // Electric field products
49 51 auto electricFieldFolder = std::make_unique<DataSourceItem>(
@@ -68,7 +70,7 void MockPlugin::initialize()
68 70 auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
69 71
70 72 // Sets data source tree
71 dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem());
73 dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
72 74
73 75 // Sets data provider
74 76 dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
General Comments 0
You need to be logged in to leave comments. Login now