##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge pull request 180 from SCIQLOP-Initialisation develop...
perrinel -
r384:be36d883265c merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,30
1 #ifndef SCIQLOP_NETWORKCONTROLLER_H
2 #define SCIQLOP_NETWORKCONTROLLER_H
3
4 #include <QLoggingCategory>
5 #include <QObject>
6
7 #include <Common/spimpl.h>
8
9 Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
10
11 /**
12 * @brief The NetworkController class aims to handle all network connection of SciQlop.
13 */
14 class NetworkController : public QObject {
15 Q_OBJECT
16 public:
17 explicit NetworkController(QObject *parent = 0);
18
19
20 void initialize();
21 void finalize();
22
23 private:
24 void waitForFinish();
25
26 class NetworkControllerPrivate;
27 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
28 };
29
30 #endif // SCIQLOP_NETWORKCONTROLLER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,33
1 #include "Network/NetworkController.h"
2
3 #include <QMutex>
4 #include <QThread>
5
6 Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
7
8 struct NetworkController::NetworkControllerPrivate {
9 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
10 QMutex m_WorkingMutex;
11 };
12
13 NetworkController::NetworkController(QObject *parent)
14 : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
15 {
16 }
17
18 void NetworkController::initialize()
19 {
20 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
21 impl->m_WorkingMutex.lock();
22 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
23 }
24
25 void NetworkController::finalize()
26 {
27 impl->m_WorkingMutex.unlock();
28 }
29
30 void NetworkController::waitForFinish()
31 {
32 QMutexLocker locker{&impl->m_WorkingMutex};
33 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,36
1 #ifndef SCIQLOP_AMDAPROVIDER_H
2 #define SCIQLOP_AMDAPROVIDER_H
3
4 #include "AmdaGlobal.h"
5
6 #include <Common/spimpl.h>
7
8 #include <Data/IDataProvider.h>
9
10 #include <QLoggingCategory>
11
12
13 Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
14
15 /**
16 * @brief The AmdaProvider class is an example of how a data provider can generate data
17 */
18 class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
19 public:
20 explicit AmdaProvider();
21
22 void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
23
24 private:
25 void retrieveData(QUuid token, const DataProviderParameters &parameters) const;
26
27 class AmdaProviderPrivate;
28 spimpl::unique_impl_ptr<AmdaProviderPrivate> impl;
29
30 private slots:
31 void httpFinished() noexcept;
32 void httpDownloadFinished() noexcept;
33 void httpDownloadReadyRead() noexcept;
34 };
35
36 #endif // SCIQLOP_AMDAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,19
1 #ifndef SCIQLOP_AMDARESULTPARSER_H
2 #define SCIQLOP_AMDARESULTPARSER_H
3
4 #include "AmdaGlobal.h"
5
6 #include <QLoggingCategory>
7
8 #include <memory>
9
10 class IDataSeries;
11
12 Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParser)
13
14 struct SCIQLOP_AMDA_EXPORT AmdaResultParser {
15
16 static std::shared_ptr<IDataSeries> readTxt(const QString &filePath) noexcept;
17 };
18
19 #endif // SCIQLOP_AMDARESULTPARSER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,134
1 #include "AmdaProvider.h"
2 #include "AmdaResultParser.h"
3
4 #include <Data/DataProviderParameters.h>
5
6 #include <QNetworkAccessManager>
7 #include <QNetworkReply>
8 #include <QTemporaryFile>
9
10 Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
11
12 namespace {
13
14 /// URL format for a request on AMDA server. The parameters are as follows:
15 /// - %1: start date
16 /// - %2: end date
17 /// - %3: parameter id
18 const auto AMDA_URL_FORMAT = QStringLiteral(
19 "http://amda.irap.omp.eu/php/rest/"
20 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&sampling=60&outputFormat=ASCII&"
21 "timeFormat=ISO8601&gzip=0");
22
23 /// Dates format passed in the URL (e.g 2013-09-23T09:00)
24 const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:ss");
25
26 /// Formats a time to a date that can be passed in URL
27 QString dateFormat(double sqpDateTime) noexcept
28 {
29 auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
30 return dateTime.toString(AMDA_TIME_FORMAT);
31 }
32
33 } // namespace
34
35 struct AmdaProvider::AmdaProviderPrivate {
36 DataProviderParameters m_Params{};
37 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
38 QNetworkReply *m_Reply{nullptr};
39 std::unique_ptr<QTemporaryFile> m_File{nullptr};
40 QUuid m_Token;
41 };
42
43 AmdaProvider::AmdaProvider() : impl{spimpl::make_unique_impl<AmdaProviderPrivate>()}
44 {
45 }
46
47 void AmdaProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
48 {
49 // NOTE: Try to use multithread if possible
50 for (const auto &dateTime : dateTimeList) {
51 retrieveData(token, DataProviderParameters{dateTime});
52 }
53 }
54
55 void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters) const
56 {
57 // /////////// //
58 // Creates URL //
59 // /////////// //
60
61 auto startDate = dateFormat(parameters.m_Time.m_TStart);
62 auto endDate = dateFormat(parameters.m_Time.m_TEnd);
63 auto productId = QStringLiteral("imf(0)");
64
65 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
66
67 // //////////////// //
68 // Executes request //
69 // //////////////// //
70
71 impl->m_Token = token;
72 impl->m_Params = parameters;
73 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
74 impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{url});
75 connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpFinished);
76 }
77
78 void AmdaProvider::httpFinished() noexcept
79 {
80 // ////////////////////// //
81 // Gets download file url //
82 // ////////////////////// //
83
84 auto downloadFileUrl = QUrl{QString{impl->m_Reply->readAll()}};
85
86 // ///////////////////////////////////// //
87 // Executes request for downloading file //
88 // ///////////////////////////////////// //
89
90 // Deletes old reply
91 impl->m_Reply->deleteLater();
92 impl->m_Reply = nullptr;
93
94 // Creates destination file
95 impl->m_File = std::make_unique<QTemporaryFile>();
96 if (impl->m_File->open()) {
97 qCDebug(LOG_AmdaProvider()) << "Temp file: " << impl->m_File->fileName();
98
99 // Executes request
100 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
101 impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{downloadFileUrl});
102 connect(impl->m_Reply, &QNetworkReply::finished, this,
103 &AmdaProvider::httpDownloadReadyRead);
104 connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpDownloadFinished);
105 }
106 }
107
108 void AmdaProvider::httpDownloadFinished() noexcept
109 {
110 if (impl->m_File) {
111 impl->m_File->close();
112
113 // Parse results file
114 if (auto dataSeries = AmdaResultParser::readTxt(impl->m_File->fileName())) {
115 emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
116 }
117 else {
118 /// @todo ALX : debug
119 }
120
121 impl->m_File = nullptr;
122 }
123
124 // Deletes reply
125 impl->m_Reply->deleteLater();
126 impl->m_Reply = nullptr;
127 }
128
129 void AmdaProvider::httpDownloadReadyRead() noexcept
130 {
131 if (impl->m_File) {
132 impl->m_File->write(impl->m_Reply->readAll());
133 }
134 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,70
1 #include "AmdaResultParser.h"
2
3 #include <Data/ScalarSeries.h>
4
5 #include <QDateTime>
6 #include <QFile>
7
8 Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
9
10 namespace {
11
12 /// Format for dates in result files
13 const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
14
15 /// @todo ALX
16 double doubleDate(const QString &stringDate) noexcept
17 {
18 auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
19 return dateTime.toMSecsSinceEpoch() / 1000.;
20 }
21
22 } // namespace
23
24 std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) noexcept
25 {
26 QFile file{filePath};
27
28 if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
29 qCCritical(LOG_AmdaResultParser())
30 << QObject::tr("Can't retrieve AMDA data from file %1: %2")
31 .arg(filePath, file.errorString());
32 return nullptr;
33 }
34
35 auto xData = QVector<double>{};
36 auto valuesData = QVector<double>{};
37
38 QTextStream stream{&file};
39
40 // Ignore comment lines (3 lines)
41 stream.readLine();
42 stream.readLine();
43 stream.readLine();
44
45 QString line{};
46 auto lineRegex = QRegExp{QStringLiteral("\\s+")};
47 while (stream.readLineInto(&line)) {
48 auto lineData = line.split(lineRegex, QString::SkipEmptyParts);
49 if (lineData.size() == 2) {
50 // X : the data is converted from date to double (in secs)
51 xData.push_back(doubleDate(lineData.at(0)));
52
53 // Value
54 valuesData.push_back(lineData.at(1).toDouble());
55 }
56 else {
57 /// @todo ALX : log
58 }
59 }
60
61 /// @todo ALX : handle units
62 auto scalarSeries = std::make_shared<ScalarSeries>(xData.size(), Unit{"nT", true}, Unit{});
63
64 const auto count = xData.size();
65 for (auto i = 0; i < count; ++i) {
66 scalarSeries->setData(i, xData.at(i), valuesData.at(i));
67 }
68
69 return scalarSeries;
70 }
Show file before | Show file after | Hide comments
@@ -1,164 +1,164
1 1 <?xml version="1.0" encoding="UTF-8"?>
2 2 <ui version="4.0">
3 3 <class>MainWindow</class>
4 4 <widget class="QMainWindow" name="MainWindow">
5 5 <property name="geometry">
6 6 <rect>
7 7 <x>0</x>
8 8 <y>0</y>
9 9 <width>800</width>
10 10 <height>600</height>
11 11 </rect>
12 12 </property>
13 13 <property name="windowTitle">
14 <string>QLop</string>
14 <string>SciQlop v0.0.1</string>
15 15 </property>
16 16 <property name="dockNestingEnabled">
17 17 <bool>true</bool>
18 18 </property>
19 19 <widget class="QWidget" name="centralWidget">
20 20 <property name="enabled">
21 21 <bool>true</bool>
22 22 </property>
23 23 <property name="sizePolicy">
24 24 <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
25 25 <horstretch>0</horstretch>
26 26 <verstretch>0</verstretch>
27 27 </sizepolicy>
28 28 </property>
29 29 <property name="maximumSize">
30 30 <size>
31 31 <width>16777215</width>
32 32 <height>16777215</height>
33 33 </size>
34 34 </property>
35 35 <layout class="QHBoxLayout" name="horizontalLayout">
36 36 <property name="spacing">
37 37 <number>0</number>
38 38 </property>
39 39 <property name="leftMargin">
40 40 <number>0</number>
41 41 </property>
42 42 <property name="topMargin">
43 43 <number>0</number>
44 44 </property>
45 45 <property name="rightMargin">
46 46 <number>0</number>
47 47 </property>
48 48 <property name="bottomMargin">
49 49 <number>0</number>
50 50 </property>
51 51 <item>
52 52 <widget class="QSplitter" name="splitter">
53 53 <property name="orientation">
54 54 <enum>Qt::Horizontal</enum>
55 55 </property>
56 56 <widget class="QWidget" name="leftMainInspectorWidget" native="true">
57 57 <layout class="QVBoxLayout" name="verticalLayout">
58 58 <property name="spacing">
59 59 <number>0</number>
60 60 </property>
61 61 <property name="leftMargin">
62 62 <number>0</number>
63 63 </property>
64 64 <property name="topMargin">
65 65 <number>0</number>
66 66 </property>
67 67 <property name="rightMargin">
68 68 <number>0</number>
69 69 </property>
70 70 <property name="bottomMargin">
71 71 <number>0</number>
72 72 </property>
73 73 <item>
74 74 <widget class="DataSourceWidget" name="dataSourceWidget" native="true"/>
75 75 </item>
76 76 <item>
77 77 <widget class="QWidget" name="dateTimeWidget" native="true"/>
78 78 </item>
79 79 <item>
80 80 <widget class="VariableInspectorWidget" name="variableInspectorWidget" native="true"/>
81 81 </item>
82 82 </layout>
83 83 </widget>
84 84 <widget class="SqpSidePane" name="leftInspectorSidePane" native="true"/>
85 85 <widget class="VisualizationWidget" name="view" native="true">
86 86 <property name="sizePolicy">
87 87 <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
88 88 <horstretch>0</horstretch>
89 89 <verstretch>0</verstretch>
90 90 </sizepolicy>
91 91 </property>
92 92 </widget>
93 93 <widget class="SqpSidePane" name="rightInspectorSidePane" native="true"/>
94 94 <widget class="QWidget" name="rightMainInspectorWidget" native="true">
95 95 <layout class="QVBoxLayout" name="verticalLayout_3">
96 96 <property name="spacing">
97 97 <number>0</number>
98 98 </property>
99 99 <property name="leftMargin">
100 100 <number>0</number>
101 101 </property>
102 102 <property name="topMargin">
103 103 <number>0</number>
104 104 </property>
105 105 <property name="rightMargin">
106 106 <number>0</number>
107 107 </property>
108 108 <property name="bottomMargin">
109 109 <number>0</number>
110 110 </property>
111 111 <item>
112 112 <widget class="QWidget" name="commonPropertyInspectorWidget" native="true"/>
113 113 </item>
114 114 <item>
115 115 <widget class="DataSourceWidget" name="catalogWidget" native="true"/>
116 116 </item>
117 117 </layout>
118 118 </widget>
119 119 </widget>
120 120 </item>
121 121 </layout>
122 122 </widget>
123 123 <widget class="QMenuBar" name="menuBar">
124 124 <property name="geometry">
125 125 <rect>
126 126 <x>0</x>
127 127 <y>0</y>
128 128 <width>800</width>
129 <height>26</height>
129 <height>28</height>
130 130 </rect>
131 131 </property>
132 132 </widget>
133 133 <widget class="QStatusBar" name="statusBar"/>
134 134 </widget>
135 135 <layoutdefault spacing="6" margin="11"/>
136 136 <customwidgets>
137 137 <customwidget>
138 138 <class>VisualizationWidget</class>
139 139 <extends>QWidget</extends>
140 140 <header location="global">Visualization/VisualizationWidget.h</header>
141 141 <container>1</container>
142 142 </customwidget>
143 143 <customwidget>
144 144 <class>SqpSidePane</class>
145 145 <extends>QWidget</extends>
146 146 <header location="global">SidePane/SqpSidePane.h</header>
147 147 <container>1</container>
148 148 </customwidget>
149 149 <customwidget>
150 150 <class>DataSourceWidget</class>
151 151 <extends>QWidget</extends>
152 152 <header location="global">DataSource/DataSourceWidget.h</header>
153 153 <container>1</container>
154 154 </customwidget>
155 155 <customwidget>
156 156 <class>VariableInspectorWidget</class>
157 157 <extends>QWidget</extends>
158 158 <header location="global">Variable/VariableInspectorWidget.h</header>
159 159 <container>1</container>
160 160 </customwidget>
161 161 </customwidgets>
162 162 <resources/>
163 163 <connections/>
164 164 </ui>
Show file before | Show file after | Hide comments
@@ -1,42 +1,40
1 1 #ifndef SCIQLOP_IDATAPROVIDER_H
2 2 #define SCIQLOP_IDATAPROVIDER_H
3 3
4 4 #include <memory>
5 5
6 6 #include <QObject>
7 #include <QUuid>
7 8
8 9 #include <Common/MetaTypes.h>
9 10
10 11 #include <Data/SqpDateTime.h>
11 12
12 13 class DataProviderParameters;
13 14 class IDataSeries;
14 15
15 16 /**
16 17 * @brief The IDataProvider interface aims to declare a data provider.
17 18 *
18 19 * A data provider is an entity that generates data and returns it according to various parameters
19 20 * (time interval, product to retrieve the data, etc.)
20 21 *
21 22 * @sa IDataSeries
22 23 */
23 24 class IDataProvider : public QObject {
24 25
25 26 Q_OBJECT
26 27 public:
27 28 virtual ~IDataProvider() noexcept = default;
28 29
29 virtual std::shared_ptr<IDataSeries>
30 retrieveData(const DataProviderParameters &parameters) const = 0;
31
32
33 virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
30 virtual void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) = 0;
34 31
35 32 signals:
36 void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
33 void dataProvided(QUuid token, std::shared_ptr<IDataSeries> dateSerie,
34 const SqpDateTime &dateTime);
37 35 };
38 36
39 37 // Required for using shared_ptr in signals/slots
40 38 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
41 39
42 40 #endif // SCIQLOP_IDATAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -1,211 +1,205
1 1 #include <Variable/Variable.h>
2 2 #include <Variable/VariableCacheController.h>
3 3 #include <Variable/VariableController.h>
4 4 #include <Variable/VariableModel.h>
5 5
6 6 #include <Data/DataProviderParameters.h>
7 7 #include <Data/IDataProvider.h>
8 8 #include <Data/IDataSeries.h>
9 9 #include <Time/TimeController.h>
10 10
11 11 #include <QDateTime>
12 12 #include <QMutex>
13 13 #include <QThread>
14 #include <QUuid>
14 15 #include <QtCore/QItemSelectionModel>
15 16
16 17 #include <unordered_map>
17 18
18 19 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
19 20
20 namespace {
21
22 /// @todo Generates default dataseries, according to the provider passed in parameter. This method
23 /// will be deleted when the timerange is recovered from SciQlop
24 std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
25 const SqpDateTime &dateTime) noexcept
26 {
27 auto parameters = DataProviderParameters{dateTime};
28
29 return provider.retrieveData(parameters);
30 }
31
32 } // namespace
33
34 21 struct VariableController::VariableControllerPrivate {
35 22 explicit VariableControllerPrivate(VariableController *parent)
36 23 : m_WorkingMutex{},
37 24 m_VariableModel{new VariableModel{parent}},
38 25 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
39 26 m_VariableCacheController{std::make_unique<VariableCacheController>()}
40 27 {
41 28 }
42 29
43 30 QMutex m_WorkingMutex;
44 31 /// Variable model. The VariableController has the ownership
45 32 VariableModel *m_VariableModel;
46 33 QItemSelectionModel *m_VariableSelectionModel;
47 34
48 35
49 36 TimeController *m_TimeController{nullptr};
50 37 std::unique_ptr<VariableCacheController> m_VariableCacheController;
51 38
52 39 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
53 40 m_VariableToProviderMap;
41 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToToken;
54 42 };
55 43
56 44 VariableController::VariableController(QObject *parent)
57 45 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
58 46 {
59 47 qCDebug(LOG_VariableController()) << tr("VariableController construction")
60 48 << QThread::currentThread();
61 49 }
62 50
63 51 VariableController::~VariableController()
64 52 {
65 53 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
66 54 << QThread::currentThread();
67 55 this->waitForFinish();
68 56 }
69 57
70 58 VariableModel *VariableController::variableModel() noexcept
71 59 {
72 60 return impl->m_VariableModel;
73 61 }
74 62
75 63 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
76 64 {
77 65 return impl->m_VariableSelectionModel;
78 66 }
79 67
80 68 void VariableController::setTimeController(TimeController *timeController) noexcept
81 69 {
82 70 impl->m_TimeController = timeController;
83 71 }
84 72
85 73 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
86 74 {
87 75 if (!variable) {
88 76 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
89 77 return;
90 78 }
91 79
92 80 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
93 81 // make some treatments before the deletion
94 82 emit variableAboutToBeDeleted(variable);
95 83
96 84 // Deletes provider
97 85 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
98 86 qCDebug(LOG_VariableController())
99 87 << tr("Number of providers deleted for variable %1: %2")
100 88 .arg(variable->name(), QString::number(nbProvidersDeleted));
101 89
102 90 // Clears cache
103 91 impl->m_VariableCacheController->clear(variable);
104 92
105 93 // Deletes from model
106 94 impl->m_VariableModel->deleteVariable(variable);
107 95 }
108 96
109 97 void VariableController::deleteVariables(
110 98 const QVector<std::shared_ptr<Variable> > &variables) noexcept
111 99 {
112 100 for (auto variable : qAsConst(variables)) {
113 101 deleteVariable(variable);
114 102 }
115 103 }
116 104
117 105 void VariableController::createVariable(const QString &name,
118 106 std::shared_ptr<IDataProvider> provider) noexcept
119 107 {
120 108
121 109 if (!impl->m_TimeController) {
122 110 qCCritical(LOG_VariableController())
123 111 << tr("Impossible to create variable: The time controller is null");
124 112 return;
125 113 }
126 114
127 115
128 116 /// @todo : for the moment :
129 117 /// - the provider is only used to retrieve data from the variable for its initialization, but
130 118 /// it will be retained later
131 119 /// - default data are generated for the variable, without taking into account the timerange set
132 120 /// in sciqlop
133 121 auto dateTime = impl->m_TimeController->dateTime();
134 122 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
123 auto token = QUuid::createUuid();
135 124
136 125 // store the provider
137 126 impl->m_VariableToProviderMap[newVariable] = provider;
127 impl->m_VariableToToken[newVariable] = token;
138 128
139 129 auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
140 auto dataSeriesAcquired, auto dateTimeToPutInCache)
130 QUuid token, auto dataSeriesAcquired, auto dateTimeToPutInCache)
141 131 {
142 132 if (auto variable = varW.lock()) {
143 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
144 variable->setDataSeries(dataSeriesAcquired);
133 auto varToken = impl->m_VariableToToken.at(variable);
134 if (varToken == token) {
135 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
136 variable->setDataSeries(dataSeriesAcquired);
137 }
145 138 }
146 139 };
147 140
148 141 connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
149 142 this->onRequestDataLoading(newVariable, dateTime);
150 143 }
151 144 }
152 145
153 146 void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
154 147 {
155 148 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
156 149 << QThread::currentThread()->objectName();
157 150 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
158 151
159 152 for (const auto &selectedRow : qAsConst(selectedRows)) {
160 153 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
161 154 selectedVariable->setDateTime(dateTime);
162 155 this->onRequestDataLoading(selectedVariable, dateTime);
163 156 }
164 157 }
165 158 }
166 159
167 160
168 161 void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
169 162 const SqpDateTime &dateTime)
170 163 {
171 164 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
172 165 << QThread::currentThread()->objectName();
173 166 // we want to load data of the variable for the dateTime.
174 167 // First we check if the cache contains some of them.
175 168 // For the other, we ask the provider to give them.
176 169 if (variable) {
177 170
178 171 auto dateTimeListNotInCache
179 172 = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
180 173
181 174 if (!dateTimeListNotInCache.empty()) {
182 175 // Ask the provider for each data on the dateTimeListNotInCache
176 auto token = impl->m_VariableToToken.at(variable);
183 177 impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
184 std::move(dateTimeListNotInCache));
178 token, std::move(dateTimeListNotInCache));
185 179 }
186 180 else {
187 181 emit variable->updated();
188 182 }
189 183 }
190 184 else {
191 185 qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
192 186 }
193 187 }
194 188
195 189
196 190 void VariableController::initialize()
197 191 {
198 192 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
199 193 impl->m_WorkingMutex.lock();
200 194 qCDebug(LOG_VariableController()) << tr("VariableController init END");
201 195 }
202 196
203 197 void VariableController::finalize()
204 198 {
205 199 impl->m_WorkingMutex.unlock();
206 200 }
207 201
208 202 void VariableController::waitForFinish()
209 203 {
210 204 QMutexLocker locker{&impl->m_WorkingMutex};
211 205 }
Show file before | Show file after | Hide comments
@@ -1,50 +1,52
1 1 #ifndef SCIQLOP_SQPAPPLICATION_H
2 2 #define SCIQLOP_SQPAPPLICATION_H
3 3
4 4 #include "SqpApplication.h"
5 5
6 6 #include <QApplication>
7 7 #include <QLoggingCategory>
8 8
9 9 #include <Common/spimpl.h>
10 10
11 11 Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
12 12
13 13 #if defined(sqpApp)
14 14 #undef sqpApp
15 15 #endif
16 16 #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
17 17
18 18 class DataSourceController;
19 class NetworkController;
19 20 class TimeController;
20 21 class VariableController;
21 22 class VisualizationController;
22 23
23 24 /**
24 25 * @brief The SqpApplication class aims to make the link between SciQlop
25 26 * and its plugins. This is the intermediate class that SciQlop has to use
26 27 * in the way to connect a data source. Please first use load method to initialize
27 28 * a plugin specified by its metadata name (JSON plugin source) then others specifics
28 29 * method will be able to access it.
29 30 * You can load a data source driver plugin then create a data source.
30 31 */
31 32
32 33 class SqpApplication : public QApplication {
33 34 Q_OBJECT
34 35 public:
35 36 explicit SqpApplication(int &argc, char **argv);
36 37 virtual ~SqpApplication();
37 38 void initialize();
38 39
39 40 /// Accessors for the differents sciqlop controllers
40 41 DataSourceController &dataSourceController() noexcept;
42 NetworkController &networkController() noexcept;
41 43 TimeController &timeController() noexcept;
42 44 VariableController &variableController() noexcept;
43 45 VisualizationController &visualizationController() noexcept;
44 46
45 47 private:
46 48 class SqpApplicationPrivate;
47 49 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
48 50 };
49 51
50 52 #endif // SCIQLOP_SQPAPPLICATION_H
Show file before | Show file after | Hide comments
@@ -1,124 +1,140
1 1 #include "SqpApplication.h"
2 2
3 3 #include <Data/IDataProvider.h>
4 4 #include <DataSource/DataSourceController.h>
5 #include <Network/NetworkController.h>
5 6 #include <QThread>
6 7 #include <Time/TimeController.h>
7 8 #include <Variable/Variable.h>
8 9 #include <Variable/VariableController.h>
9 10 #include <Visualization/VisualizationController.h>
10 11
11 12 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
12 13
13 14 class SqpApplication::SqpApplicationPrivate {
14 15 public:
15 16 SqpApplicationPrivate()
16 17 : m_DataSourceController{std::make_unique<DataSourceController>()},
18 m_NetworkController{std::make_unique<NetworkController>()},
17 19 m_TimeController{std::make_unique<TimeController>()},
18 20 m_VariableController{std::make_unique<VariableController>()},
19 21 m_VisualizationController{std::make_unique<VisualizationController>()}
20 22 {
21 QThread::currentThread()->setObjectName("MainThread");
22 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
23 m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
24 m_VariableController->moveToThread(&m_VariableControllerThread);
25 m_VariableControllerThread.setObjectName("VariableControllerThread");
26 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
27 m_VisualizationControllerThread.setObjectName("VisualizationControllerThread");
28
29 23 // /////////////////////////////// //
30 24 // Connections between controllers //
31 25 // /////////////////////////////// //
32 26
33 27 // VariableController <-> DataSourceController
34 28 connect(m_DataSourceController.get(),
35 29 SIGNAL(variableCreationRequested(const QString &, std::shared_ptr<IDataProvider>)),
36 30 m_VariableController.get(),
37 31 SLOT(createVariable(const QString &, std::shared_ptr<IDataProvider>)));
38 32
39 33 // VariableController <-> VisualizationController
40 34 connect(m_VariableController.get(),
41 35 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
42 36 m_VisualizationController.get(),
43 37 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
44 38
45 39
40 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
41 m_NetworkController->moveToThread(&m_NetworkControllerThread);
42 m_VariableController->moveToThread(&m_VariableControllerThread);
43 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
44
45
46 46 // Additionnal init
47 47 m_VariableController->setTimeController(m_TimeController.get());
48 48 }
49 49
50 50 virtual ~SqpApplicationPrivate()
51 51 {
52 52 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
53 53 m_DataSourceControllerThread.quit();
54 54 m_DataSourceControllerThread.wait();
55 55
56 m_NetworkControllerThread.quit();
57 m_NetworkControllerThread.wait();
58
56 59 m_VariableControllerThread.quit();
57 60 m_VariableControllerThread.wait();
58 61
59 62 m_VisualizationControllerThread.quit();
60 63 m_VisualizationControllerThread.wait();
61 64 }
62 65
63 66 std::unique_ptr<DataSourceController> m_DataSourceController;
64 67 std::unique_ptr<VariableController> m_VariableController;
65 68 std::unique_ptr<TimeController> m_TimeController;
69 std::unique_ptr<NetworkController> m_NetworkController;
66 70 std::unique_ptr<VisualizationController> m_VisualizationController;
67 71 QThread m_DataSourceControllerThread;
72 QThread m_NetworkControllerThread;
68 73 QThread m_VariableControllerThread;
69 74 QThread m_VisualizationControllerThread;
70 75 };
71 76
72 77
73 78 SqpApplication::SqpApplication(int &argc, char **argv)
74 79 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
75 80 {
76 81 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
77 82
78 83 connect(&impl->m_DataSourceControllerThread, &QThread::started,
79 84 impl->m_DataSourceController.get(), &DataSourceController::initialize);
80 85 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
81 86 impl->m_DataSourceController.get(), &DataSourceController::finalize);
82 87
88 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
89 &NetworkController::initialize);
90 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
91 &NetworkController::finalize);
92
83 93 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
84 94 &VariableController::initialize);
85 95 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
86 96 &VariableController::finalize);
87 97
88 98 connect(&impl->m_VisualizationControllerThread, &QThread::started,
89 99 impl->m_VisualizationController.get(), &VisualizationController::initialize);
90 100 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
91 101 impl->m_VisualizationController.get(), &VisualizationController::finalize);
92 102
93 103 impl->m_DataSourceControllerThread.start();
104 impl->m_NetworkControllerThread.start();
94 105 impl->m_VariableControllerThread.start();
95 106 impl->m_VisualizationControllerThread.start();
96 107 }
97 108
98 109 SqpApplication::~SqpApplication()
99 110 {
100 111 }
101 112
102 113 void SqpApplication::initialize()
103 114 {
104 115 }
105 116
106 117 DataSourceController &SqpApplication::dataSourceController() noexcept
107 118 {
108 119 return *impl->m_DataSourceController;
109 120 }
110 121
122 NetworkController &SqpApplication::networkController() noexcept
123 {
124 return *impl->m_NetworkController;
125 }
126
111 127 TimeController &SqpApplication::timeController() noexcept
112 128 {
113 129 return *impl->m_TimeController;
114 130 }
115 131
116 132 VariableController &SqpApplication::variableController() noexcept
117 133 {
118 134 return *impl->m_VariableController;
119 135 }
120 136
121 137 VisualizationController &SqpApplication::visualizationController() noexcept
122 138 {
123 139 return *impl->m_VisualizationController;
124 140 }
Show file before | Show file after | Hide comments
@@ -1,167 +1,167
1 1 ## amda - CMakeLists.txt
2 2 STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
3 3 SET(SQPAMDA_LIBRARY_NAME "${LIBRARY_PREFFIX}_amda${DEBUG_SUFFIX}")
4 4 SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
5 5 SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
6 6 SET(RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/resources")
7 7 SET(TESTS_RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests-resources")
8 8
9 9 # Include amda directory
10 10 INCLUDE_DIRECTORIES(${INCLUDES_DIR})
11 11 INCLUDE_DIRECTORIES(${RESOURCES_DIR})
12 12
13 13 #
14 14 # Find Qt modules
15 15 #
16 SCIQLOP_FIND_QT(Core Widgets)
16 SCIQLOP_FIND_QT(Core Widgets Network)
17 17
18 18 #
19 19 # Find dependent libraries
20 20 # ========================
21 21
22 22 # sciqlop plugin
23 23 find_package(sciqlop-plugin)
24 24 INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
25 25
26 26 # sciqlop core
27 27 find_package(sciqlop-core)
28 28 INCLUDE_DIRECTORIES(${SCIQLOP-CORE_INCLUDE_DIR})
29 29 list(APPEND LIBRARIES ${SCIQLOP-CORE_LIBRARIES})
30 30
31 31 # sciqlop gui
32 32 find_package(sciqlop-gui)
33 33 INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
34 34 list(APPEND LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
35 35
36 36 # Description file
37 37 FILE (GLOB_RECURSE PLUGIN_FILE ${RESOURCES_DIR}/amda.json)
38 38
39 39 # Resources files
40 40 FILE (GLOB_RECURSE PROJECT_RESOURCES ${RESOURCES_DIR}/*.qrc)
41 41
42 42 #
43 43 # Compile the library
44 44 #
45 45
46 46 ADD_DEFINITIONS(-DAMDA_LIB)
47 47
48 48 FILE (GLOB_RECURSE MODULE_SOURCES
49 49 ${INCLUDES_DIR}/*.h
50 50 ${SOURCES_DIR}/*.c
51 51 ${SOURCES_DIR}/*.cpp
52 52 ${SOURCES_DIR}/*.h
53 53 ${PLUGIN_FILE})
54 54
55 55 QT5_ADD_RESOURCES(RCC_AMDA
56 56 ${PROJECT_RESOURCES}
57 57 )
58 58
59 59 ADD_LIBRARY(${SQPAMDA_LIBRARY_NAME} ${MODULE_SOURCES} ${RCC_AMDA})
60 60 set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
61 61 set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
62 62
63 63 INSTALL(TARGETS ${SQPAMDA_LIBRARY_NAME}
64 64 RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
65 65 LIBRARY DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
66 66 ARCHIVE DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
67 67 )
68 68
69 69
70 70 TARGET_LINK_LIBRARIES(${SQPAMDA_LIBRARY_NAME} ${LIBRARIES})
71 qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets)
71 qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets Network)
72 72
73 73 add_dependencies(${SQPAMDA_LIBRARY_NAME} ${SQPPLUGIN_LIBRARY_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
74 74
75 75 # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
76 76 # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
77 77 # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
78 78 IF(BUILD_SHARED_LIBS)
79 79 SET_TARGET_PROPERTIES(${SQPAMDA_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
80 80 ELSE()
81 81 TARGET_COMPILE_DEFINITIONS(${SQPAMDA_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
82 82 ENDIF()
83 83
84 84 # Set the variable to parent scope so that the other projects can copy the
85 85 # dependent shared libraries
86 86 SCIQLOP_SET_TO_PARENT_SCOPE(SQPAMDA_LIBRARY_NAME)
87 87
88 88 # Copy extern shared libraries to the lib folder
89 89 SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPAMDA_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
90 90
91 91 # Add the files to the list of files to be analyzed
92 92 LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
93 93 SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
94 94 # Vera++ exclusion files
95 95 #LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
96 96 SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
97 97
98 98 #
99 99 # Compile the tests
100 100 #
101 101 IF(BUILD_TESTS)
102 102 INCLUDE_DIRECTORIES(${SOURCES_DIR})
103 103 FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
104 104 FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
105 105 SET( TEST_LIBRARIES ${SQPAMDA_LIBRARY_NAME})
106 106
107 107 FOREACH( testFile ${TESTS_SOURCES} )
108 108 GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
109 109 GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
110 110
111 111 # Add to the list of sources files all the sources in the same
112 112 # directory that aren't another test
113 113 FILE (GLOB currentTestSources
114 114 ${testDirectory}/*.c
115 115 ${testDirectory}/*.cpp
116 116 ${testDirectory}/*.h)
117 117 LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
118 118 # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
119 119
120 120 ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
121 121 set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
122 122 set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
123 123 TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
124 124 qt5_use_modules(${testName} Test)
125 125
126 126 ADD_TEST( NAME ${testName} COMMAND ${testName} )
127 127
128 128 SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
129 129 ENDFOREACH( testFile )
130 130
131 131 LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
132 132 LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
133 133 LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
134 134 SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
135 135
136 136 ADD_DEFINITIONS(-DAMDA_TESTS_RESOURCES_DIR="${TESTS_RESOURCES_DIR}")
137 137 ENDIF(BUILD_TESTS)
138 138
139 139 #
140 140 # Set the files that must be formatted by clang-format.
141 141 #
142 142 LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
143 143 SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
144 144
145 145 #
146 146 # Set the directories that doxygen must browse to generate the
147 147 # documentation.
148 148 #
149 149 # Source directories:
150 150 LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
151 151 LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
152 152 SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
153 153 # Source directories to exclude from the documentation generation
154 154 #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
155 155 SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
156 156
157 157 #
158 158 # Set the directories with the sources to analyze and propagate the
159 159 # modification to the parent scope
160 160 #
161 161 # Source directories to analyze:
162 162 LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
163 163 LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
164 164 SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
165 165 # Source directories to exclude from the analysis
166 166 #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
167 167 SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)
Show file before | Show file after | Hide comments
@@ -1,39 +1,68
1 1 #include "AmdaPlugin.h"
2 2 #include "AmdaParser.h"
3 #include "AmdaProvider.h"
3 4
4 5 #include <DataSource/DataSourceController.h>
5 6 #include <DataSource/DataSourceItem.h>
7 #include <DataSource/DataSourceItemAction.h>
6 8
7 9 #include <SqpApplication.h>
8 10
9 11 Q_LOGGING_CATEGORY(LOG_AmdaPlugin, "AmdaPlugin")
10 12
11 13 namespace {
12 14
13 15 /// Name of the data source
14 16 const auto DATA_SOURCE_NAME = QStringLiteral("AMDA");
15 17
16 18 /// Path of the file used to generate the data source item for AMDA
17 19 const auto JSON_FILE_PATH = QStringLiteral(":/samples/AmdaSample.json");
18 20
21 void associateActions(DataSourceItem &item, const QUuid &dataSourceUid)
22 {
23 if (item.type() == DataSourceItemType::PRODUCT) {
24 auto itemName = item.name();
25
26 item.addAction(std::make_unique<DataSourceItemAction>(
27 QObject::tr("Load %1 product").arg(itemName),
28 [itemName, dataSourceUid](DataSourceItem &item) {
29 if (auto app = sqpApp) {
30 app->dataSourceController().loadProductItem(dataSourceUid, item);
31 }
32 }));
33 }
34
35 auto count = item.childCount();
36 for (auto i = 0; i < count; ++i) {
37 if (auto child = item.child(i)) {
38 associateActions(*child, dataSourceUid);
39 }
40 }
41 }
42
19 43 } // namespace
20 44
21 45 void AmdaPlugin::initialize()
22 46 {
23 47 if (auto app = sqpApp) {
24 48 // Registers to the data source controller
25 49 auto &dataSourceController = app->dataSourceController();
26 50 auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
27 51
28 52 // Sets data source tree
29 53 if (auto dataSourceItem = AmdaParser::readJson(JSON_FILE_PATH)) {
54 associateActions(*dataSourceItem, dataSourceUid);
55
30 56 dataSourceController.setDataSourceItem(dataSourceUid, std::move(dataSourceItem));
31 57 }
32 58 else {
33 59 qCCritical(LOG_AmdaPlugin()) << tr("No data source item could be generated for AMDA");
34 60 }
61
62 // Sets data provider
63 dataSourceController.setDataProvider(dataSourceUid, std::make_unique<AmdaProvider>());
35 64 }
36 65 else {
37 66 qCWarning(LOG_AmdaPlugin()) << tr("Can't access to SciQlop application");
38 67 }
39 68 }
Show file before | Show file after | Hide comments
@@ -1,28 +1,26
1 1 #ifndef SCIQLOP_COSINUSPROVIDER_H
2 2 #define SCIQLOP_COSINUSPROVIDER_H
3 3
4 4 #include "MockPluginGlobal.h"
5 5
6 6 #include <Data/IDataProvider.h>
7 7
8 8 #include <QLoggingCategory>
9 9
10 10 Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
11 11
12 12 /**
13 13 * @brief The CosinusProvider class is an example of how a data provider can generate data
14 14 */
15 15 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
16 16 public:
17 /// @sa IDataProvider::retrieveData()
18 std::shared_ptr<IDataSeries>
19 retrieveData(const DataProviderParameters &parameters) const override;
20
21 void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;
17 void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
22 18
23 19
24 20 private:
21 /// @sa IDataProvider::retrieveData()
22 std::shared_ptr<IDataSeries> retrieveData(const DataProviderParameters &parameters) const;
25 23 std::shared_ptr<IDataSeries> retrieveDataSeries(const SqpDateTime &dateTime);
26 24 };
27 25
28 26 #endif // SCIQLOP_COSINUSPROVIDER_H
Show file before | Show file after | Hide comments
@@ -1,50 +1,50
1 1 #include "CosinusProvider.h"
2 2
3 3 #include <Data/DataProviderParameters.h>
4 4 #include <Data/ScalarSeries.h>
5 5
6 6 #include <cmath>
7 7
8 8 #include <QDateTime>
9 9 #include <QThread>
10 10
11 11 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
12 12
13 13 std::shared_ptr<IDataSeries>
14 14 CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
15 15 {
16 16 auto dateTime = parameters.m_Time;
17 17
18 18 auto dataIndex = 0;
19 19
20 20 // Gets the timerange from the parameters
21 21 double freq = 100.0;
22 22 double start = dateTime.m_TStart * freq; // 100 htz
23 23 double end = dateTime.m_TEnd * freq; // 100 htz
24 24
25 25 // We assure that timerange is valid
26 26 if (end < start) {
27 27 std::swap(start, end);
28 28 }
29 29
30 30 // Generates scalar series containing cosinus values (one value per second)
31 31 auto scalarSeries
32 32 = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
33 33
34 34 for (auto time = start; time < end; ++time, ++dataIndex) {
35 35 const auto timeOnFreq = time / freq;
36 36 scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
37 37 }
38 38 return scalarSeries;
39 39 }
40 40
41 void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
41 void CosinusProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
42 42 {
43 43 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
44 44 << QThread::currentThread()->objectName();
45 45 // NOTE: Try to use multithread if possible
46 46 for (const auto &dateTime : dateTimeList) {
47 47 auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});
48 emit dataProvided(scalarSeries, dateTime);
48 emit dataProvided(token, scalarSeries, dateTime);
49 49 }
50 50 }
General Comments 0
You need to be logged in to leave comments. Login now