##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Merge branch 'featureDownloadProgressMock' into develop
perrinel -
r430:de933c7a4f69 merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,142 +1,146
1 #include "SqpApplication.h"
1 #include "SqpApplication.h"
2
2
3 #include <Data/IDataProvider.h>
3 #include <Data/IDataProvider.h>
4 #include <DataSource/DataSourceController.h>
4 #include <DataSource/DataSourceController.h>
5 #include <Network/NetworkController.h>
5 #include <Network/NetworkController.h>
6 #include <QThread>
6 #include <QThread>
7 #include <Time/TimeController.h>
7 #include <Time/TimeController.h>
8 #include <Variable/Variable.h>
8 #include <Variable/Variable.h>
9 #include <Variable/VariableController.h>
9 #include <Variable/VariableController.h>
10 #include <Visualization/VisualizationController.h>
10 #include <Visualization/VisualizationController.h>
11
11
12 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
12 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
13
13
14 class SqpApplication::SqpApplicationPrivate {
14 class SqpApplication::SqpApplicationPrivate {
15 public:
15 public:
16 SqpApplicationPrivate()
16 SqpApplicationPrivate()
17 : m_DataSourceController{std::make_unique<DataSourceController>()},
17 : m_DataSourceController{std::make_unique<DataSourceController>()},
18 m_NetworkController{std::make_unique<NetworkController>()},
18 m_NetworkController{std::make_unique<NetworkController>()},
19 m_TimeController{std::make_unique<TimeController>()},
19 m_TimeController{std::make_unique<TimeController>()},
20 m_VariableController{std::make_unique<VariableController>()},
20 m_VariableController{std::make_unique<VariableController>()},
21 m_VisualizationController{std::make_unique<VisualizationController>()}
21 m_VisualizationController{std::make_unique<VisualizationController>()}
22 {
22 {
23 // /////////////////////////////// //
23 // /////////////////////////////// //
24 // Connections between controllers //
24 // Connections between controllers //
25 // /////////////////////////////// //
25 // /////////////////////////////// //
26
26
27 // VariableController <-> DataSourceController
27 // VariableController <-> DataSourceController
28 connect(m_DataSourceController.get(),
28 connect(m_DataSourceController.get(),
29 SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
29 SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
30 std::shared_ptr<IDataProvider>)),
30 std::shared_ptr<IDataProvider>)),
31 m_VariableController.get(),
31 m_VariableController.get(),
32 SLOT(createVariable(const QString &, const QVariantHash &,
32 SLOT(createVariable(const QString &, const QVariantHash &,
33 std::shared_ptr<IDataProvider>)));
33 std::shared_ptr<IDataProvider>)));
34
34
35 // VariableController <-> VisualizationController
35 // VariableController <-> VisualizationController
36 connect(m_VariableController.get(),
36 connect(m_VariableController.get(),
37 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
37 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
38 m_VisualizationController.get(),
38 m_VisualizationController.get(),
39 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
39 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
40
40
41
41
42 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
42 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
43 m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
43 m_NetworkController->moveToThread(&m_NetworkControllerThread);
44 m_NetworkController->moveToThread(&m_NetworkControllerThread);
45 m_NetworkControllerThread.setObjectName("NetworkControllerThread");
44 m_VariableController->moveToThread(&m_VariableControllerThread);
46 m_VariableController->moveToThread(&m_VariableControllerThread);
47 m_VariableControllerThread.setObjectName("VariableControllerThread");
45 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
48 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
49 m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
46
50
47
51
48 // Additionnal init
52 // Additionnal init
49 m_VariableController->setTimeController(m_TimeController.get());
53 m_VariableController->setTimeController(m_TimeController.get());
50 }
54 }
51
55
52 virtual ~SqpApplicationPrivate()
56 virtual ~SqpApplicationPrivate()
53 {
57 {
54 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
58 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
55 m_DataSourceControllerThread.quit();
59 m_DataSourceControllerThread.quit();
56 m_DataSourceControllerThread.wait();
60 m_DataSourceControllerThread.wait();
57
61
58 m_NetworkControllerThread.quit();
62 m_NetworkControllerThread.quit();
59 m_NetworkControllerThread.wait();
63 m_NetworkControllerThread.wait();
60
64
61 m_VariableControllerThread.quit();
65 m_VariableControllerThread.quit();
62 m_VariableControllerThread.wait();
66 m_VariableControllerThread.wait();
63
67
64 m_VisualizationControllerThread.quit();
68 m_VisualizationControllerThread.quit();
65 m_VisualizationControllerThread.wait();
69 m_VisualizationControllerThread.wait();
66 }
70 }
67
71
68 std::unique_ptr<DataSourceController> m_DataSourceController;
72 std::unique_ptr<DataSourceController> m_DataSourceController;
69 std::unique_ptr<VariableController> m_VariableController;
73 std::unique_ptr<VariableController> m_VariableController;
70 std::unique_ptr<TimeController> m_TimeController;
74 std::unique_ptr<TimeController> m_TimeController;
71 std::unique_ptr<NetworkController> m_NetworkController;
75 std::unique_ptr<NetworkController> m_NetworkController;
72 std::unique_ptr<VisualizationController> m_VisualizationController;
76 std::unique_ptr<VisualizationController> m_VisualizationController;
73 QThread m_DataSourceControllerThread;
77 QThread m_DataSourceControllerThread;
74 QThread m_NetworkControllerThread;
78 QThread m_NetworkControllerThread;
75 QThread m_VariableControllerThread;
79 QThread m_VariableControllerThread;
76 QThread m_VisualizationControllerThread;
80 QThread m_VisualizationControllerThread;
77 };
81 };
78
82
79
83
80 SqpApplication::SqpApplication(int &argc, char **argv)
84 SqpApplication::SqpApplication(int &argc, char **argv)
81 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
85 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
82 {
86 {
83 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
87 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
84
88
85 connect(&impl->m_DataSourceControllerThread, &QThread::started,
89 connect(&impl->m_DataSourceControllerThread, &QThread::started,
86 impl->m_DataSourceController.get(), &DataSourceController::initialize);
90 impl->m_DataSourceController.get(), &DataSourceController::initialize);
87 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
91 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
88 impl->m_DataSourceController.get(), &DataSourceController::finalize);
92 impl->m_DataSourceController.get(), &DataSourceController::finalize);
89
93
90 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
94 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
91 &NetworkController::initialize);
95 &NetworkController::initialize);
92 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
96 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
93 &NetworkController::finalize);
97 &NetworkController::finalize);
94
98
95 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
99 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
96 &VariableController::initialize);
100 &VariableController::initialize);
97 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
101 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
98 &VariableController::finalize);
102 &VariableController::finalize);
99
103
100 connect(&impl->m_VisualizationControllerThread, &QThread::started,
104 connect(&impl->m_VisualizationControllerThread, &QThread::started,
101 impl->m_VisualizationController.get(), &VisualizationController::initialize);
105 impl->m_VisualizationController.get(), &VisualizationController::initialize);
102 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
106 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
103 impl->m_VisualizationController.get(), &VisualizationController::finalize);
107 impl->m_VisualizationController.get(), &VisualizationController::finalize);
104
108
105 impl->m_DataSourceControllerThread.start();
109 impl->m_DataSourceControllerThread.start();
106 impl->m_NetworkControllerThread.start();
110 impl->m_NetworkControllerThread.start();
107 impl->m_VariableControllerThread.start();
111 impl->m_VariableControllerThread.start();
108 impl->m_VisualizationControllerThread.start();
112 impl->m_VisualizationControllerThread.start();
109 }
113 }
110
114
111 SqpApplication::~SqpApplication()
115 SqpApplication::~SqpApplication()
112 {
116 {
113 }
117 }
114
118
115 void SqpApplication::initialize()
119 void SqpApplication::initialize()
116 {
120 {
117 }
121 }
118
122
119 DataSourceController &SqpApplication::dataSourceController() noexcept
123 DataSourceController &SqpApplication::dataSourceController() noexcept
120 {
124 {
121 return *impl->m_DataSourceController;
125 return *impl->m_DataSourceController;
122 }
126 }
123
127
124 NetworkController &SqpApplication::networkController() noexcept
128 NetworkController &SqpApplication::networkController() noexcept
125 {
129 {
126 return *impl->m_NetworkController;
130 return *impl->m_NetworkController;
127 }
131 }
128
132
129 TimeController &SqpApplication::timeController() noexcept
133 TimeController &SqpApplication::timeController() noexcept
130 {
134 {
131 return *impl->m_TimeController;
135 return *impl->m_TimeController;
132 }
136 }
133
137
134 VariableController &SqpApplication::variableController() noexcept
138 VariableController &SqpApplication::variableController() noexcept
135 {
139 {
136 return *impl->m_VariableController;
140 return *impl->m_VariableController;
137 }
141 }
138
142
139 VisualizationController &SqpApplication::visualizationController() noexcept
143 VisualizationController &SqpApplication::visualizationController() noexcept
140 {
144 {
141 return *impl->m_VisualizationController;
145 return *impl->m_VisualizationController;
142 }
146 }
Show file before | Show file after | Hide comments
@@ -1,28 +1,33
1 #ifndef SCIQLOP_COSINUSPROVIDER_H
1 #ifndef SCIQLOP_COSINUSPROVIDER_H
2 #define SCIQLOP_COSINUSPROVIDER_H
2 #define SCIQLOP_COSINUSPROVIDER_H
3
3
4 #include "MockPluginGlobal.h"
4 #include "MockPluginGlobal.h"
5
5
6 #include <Data/IDataProvider.h>
6 #include <Data/IDataProvider.h>
7
7
8 #include <QLoggingCategory>
8 #include <QLoggingCategory>
9 #include <QUuid>
9
10
11 #include <QHash>
10 Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
12 Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
11
13
12 /**
14 /**
13 * @brief The CosinusProvider class is an example of how a data provider can generate data
15 * @brief The CosinusProvider class is an example of how a data provider can generate data
14 */
16 */
15 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
17 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
16 public:
18 public:
19 /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
17 void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
20 void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
18
21
19
22
23 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
20 void requestDataAborting(QUuid identifier) override;
24 void requestDataAborting(QUuid identifier) override;
21
25
22
26
23 private:
27 private:
24 /// @sa IDataProvider::retrieveData()
28 std::shared_ptr<IDataSeries> retrieveData(QUuid token, const SqpDateTime &dateTime);
25 std::shared_ptr<IDataSeries> retrieveData(const SqpDateTime &dateTime) const;
29
30 QHash<QUuid, bool> m_VariableToEnableProvider;
26 };
31 };
27
32
28 #endif // SCIQLOP_COSINUSPROVIDER_H
33 #endif // SCIQLOP_COSINUSPROVIDER_H
Show file before | Show file after | Hide comments
@@ -1,53 +1,95
1 #include "CosinusProvider.h"
1 #include "CosinusProvider.h"
2
2
3 #include <Data/DataProviderParameters.h>
3 #include <Data/DataProviderParameters.h>
4 #include <Data/ScalarSeries.h>
4 #include <Data/ScalarSeries.h>
5
5
6 #include <cmath>
6 #include <cmath>
7
7
8 #include <QDateTime>
8 #include <QDateTime>
9 #include <QFuture>
9 #include <QThread>
10 #include <QThread>
11 #include <QtConcurrent/QtConcurrent>
10
12
11 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
13 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
12
14
13 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(const SqpDateTime &dateTime) const
15 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid token, const SqpDateTime &dateTime)
14 {
16 {
17 // TODO: Add Mutex
15 auto dataIndex = 0;
18 auto dataIndex = 0;
16
19
17 // Gets the timerange from the parameters
20 // Gets the timerange from the parameters
18 double freq = 100.0;
21 double freq = 100.0;
19 double start = dateTime.m_TStart * freq; // 100 htz
22 double start = dateTime.m_TStart * freq; // 100 htz
20 double end = dateTime.m_TEnd * freq; // 100 htz
23 double end = dateTime.m_TEnd * freq; // 100 htz
21
24
22 // We assure that timerange is valid
25 // We assure that timerange is valid
23 if (end < start) {
26 if (end < start) {
24 std::swap(start, end);
27 std::swap(start, end);
25 }
28 }
26
29
27 // Generates scalar series containing cosinus values (one value per second)
30 // Generates scalar series containing cosinus values (one value per second)
28 auto scalarSeries
31 auto scalarSeries
29 = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
32 = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
30
33
34
35 int progress = 0;
36 auto progressEnd = end - start;
31 for (auto time = start; time < end; ++time, ++dataIndex) {
37 for (auto time = start; time < end; ++time, ++dataIndex) {
32 const auto timeOnFreq = time / freq;
38 auto it = m_VariableToEnableProvider.find(token);
33 scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
39 if (it != m_VariableToEnableProvider.end() && it.value()) {
40 const auto timeOnFreq = time / freq;
41 scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
42
43 // progression
44 int currentProgress = (time - start) * 100.0 / progressEnd;
45 if (currentProgress != progress) {
46 progress = currentProgress;
47
48 emit dataProvidedProgress(token, progress);
49 }
50 }
51 else {
52 if (!it.value()) {
53 qCDebug(LOG_CosinusProvider())
54 << "CosinusProvider::retrieveData: ARRET De l'acquisition detectΓ©"
55 << end - time;
56 }
57 }
34 }
58 }
59 emit dataProvidedProgress(token, 0.0);
60
61
35 return scalarSeries;
62 return scalarSeries;
36 }
63 }
37
64
38 void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
65 void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
39 {
66 {
67 // TODO: Add Mutex
68 m_VariableToEnableProvider[token] = true;
40 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
69 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
41 << QThread::currentThread()->objectName();
70 << QThread::currentThread()->objectName();
42 // NOTE: Try to use multithread if possible
71 // NOTE: Try to use multithread if possible
43 const auto times = parameters.m_Times;
72 const auto times = parameters.m_Times;
73
44 for (const auto &dateTime : qAsConst(times)) {
74 for (const auto &dateTime : qAsConst(times)) {
45 auto scalarSeries = this->retrieveData(dateTime);
75 if (m_VariableToEnableProvider[token]) {
46 emit dataProvided(token, scalarSeries, dateTime);
76 auto scalarSeries = this->retrieveData(token, dateTime);
77 emit dataProvided(token, scalarSeries, dateTime);
78 }
47 }
79 }
48 }
80 }
49
81
50 void CosinusProvider::requestDataAborting(QUuid identifier)
82 void CosinusProvider::requestDataAborting(QUuid identifier)
51 {
83 {
52 // TODO
84 // TODO: Add Mutex
85 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << identifier
86 << QThread::currentThread()->objectName();
87 auto it = m_VariableToEnableProvider.find(identifier);
88 if (it != m_VariableToEnableProvider.end()) {
89 it.value() = false;
90 }
91 else {
92 qCWarning(LOG_CosinusProvider())
93 << tr("Aborting progression of inexistant identifier detected !!!");
94 }
53 }
95 }
General Comments 0
You need to be logged in to leave comments. Login now