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

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Fix bug when canceling acquisition
perrinel -
r1399:5f9a7b80e8f3
parent child
Show More
Side by Side Unified
Context file:
r1399:5f9a7b80e8f3 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,368 +1,369
1 #include "Variable/VariableAcquisitionWorker.h"
1 #include "Variable/VariableAcquisitionWorker.h"
2
2
3 #include "Variable/Variable.h"
3 #include "Variable/Variable.h"
4
4
5 #include <Data/AcquisitionRequest.h>
5 #include <Data/AcquisitionRequest.h>
6 #include <Data/SqpRange.h>
6 #include <Data/SqpRange.h>
7
7
8 #include <unordered_map>
8 #include <unordered_map>
9 #include <utility>
9 #include <utility>
10
10
11 #include <QMutex>
11 #include <QMutex>
12 #include <QReadWriteLock>
12 #include <QReadWriteLock>
13 #include <QThread>
13 #include <QThread>
14
14
15 #include <cmath>
15 #include <cmath>
16
16
17 Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
17 Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
18
18
19 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
19 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
20
20
21 explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
21 explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
22 : m_Lock{QReadWriteLock::Recursive}, q{parent}
22 : m_Lock{QReadWriteLock::Recursive}, q{parent}
23 {
23 {
24 }
24 }
25
25
26 void lockRead() { m_Lock.lockForRead(); }
26 void lockRead() { m_Lock.lockForRead(); }
27 void lockWrite() { m_Lock.lockForWrite(); }
27 void lockWrite() { m_Lock.lockForWrite(); }
28 void unlock() { m_Lock.unlock(); }
28 void unlock() { m_Lock.unlock(); }
29
29
30 void removeVariableRequest(QUuid vIdentifier);
30 void removeVariableRequest(QUuid vIdentifier);
31
31
32 /// Remove and/or abort all AcqRequest in link with varRequestId
32 /// Remove and/or abort all AcqRequest in link with varRequestId
33 void cancelVarRequest(QUuid varRequestId);
33 void cancelVarRequest(QUuid varRequestId);
34 void removeAcqRequest(QUuid acqRequestId);
34 void removeAcqRequest(QUuid acqRequestId);
35
35
36 QMutex m_WorkingMutex;
36 QMutex m_WorkingMutex;
37 QReadWriteLock m_Lock;
37 QReadWriteLock m_Lock;
38
38
39 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
39 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
40 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
40 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
41 std::map<QUuid, QUuid> m_VIdentifierToCurrrentAcqIdMap;
41 std::map<QUuid, QUuid> m_VIdentifierToCurrrentAcqIdMap;
42 VariableAcquisitionWorker *q;
42 VariableAcquisitionWorker *q;
43 };
43 };
44
44
45
45
46 VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
46 VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
47 : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
47 : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
48 {
48 {
49 }
49 }
50
50
51 VariableAcquisitionWorker::~VariableAcquisitionWorker()
51 VariableAcquisitionWorker::~VariableAcquisitionWorker()
52 {
52 {
53 qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
53 qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
54 << QThread::currentThread();
54 << QThread::currentThread();
55 this->waitForFinish();
55 this->waitForFinish();
56 }
56 }
57
57
58
58
59 QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
59 QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
60 DataProviderParameters parameters,
60 DataProviderParameters parameters,
61 std::shared_ptr<IDataProvider> provider)
61 std::shared_ptr<IDataProvider> provider)
62 {
62 {
63 qCDebug(LOG_VariableAcquisitionWorker())
63 qCDebug(LOG_VariableAcquisitionWorker())
64 << tr("TORM VariableAcquisitionWorker::pushVariableRequest varRequestId: ") << varRequestId
64 << tr("TORM VariableAcquisitionWorker::pushVariableRequest varRequestId: ") << varRequestId
65 << "vId: " << vIdentifier;
65 << "vId: " << vIdentifier;
66 auto varRequestIdCanceled = QUuid();
66 auto varRequestIdCanceled = QUuid();
67
67
68 // Request creation
68 // Request creation
69 auto acqRequest = AcquisitionRequest{};
69 auto acqRequest = AcquisitionRequest{};
70 acqRequest.m_VarRequestId = varRequestId;
70 acqRequest.m_VarRequestId = varRequestId;
71 acqRequest.m_vIdentifier = vIdentifier;
71 acqRequest.m_vIdentifier = vIdentifier;
72 acqRequest.m_DataProviderParameters = parameters;
72 acqRequest.m_DataProviderParameters = parameters;
73 acqRequest.m_Size = parameters.m_Times.size();
73 acqRequest.m_Size = parameters.m_Times.size();
74 acqRequest.m_Provider = provider;
74 acqRequest.m_Provider = provider;
75 qCInfo(LOG_VariableAcquisitionWorker()) << tr("Add acqRequest ") << acqRequest.m_AcqIdentifier
75 qCInfo(LOG_VariableAcquisitionWorker()) << tr("Add acqRequest ") << acqRequest.m_AcqIdentifier
76 << acqRequest.m_Size;
76 << acqRequest.m_Size;
77
77
78
78
79 // Register request
79 // Register request
80 impl->lockWrite();
80 impl->lockWrite();
81 impl->m_AcqIdentifierToAcqRequestMap.insert(
81 impl->m_AcqIdentifierToAcqRequestMap.insert(
82 std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
82 std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
83
83
84 auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
84 auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
85 if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
85 if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
86 // A current request already exists, we can cancel it
86 // A current request already exists, we can cancel it
87 // remove old acqIdentifier from the worker
87 // remove old acqIdentifier from the worker
88 auto oldAcqId = it->second;
88 auto oldAcqId = it->second;
89 auto acqIdentifierToAcqRequestMapIt = impl->m_AcqIdentifierToAcqRequestMap.find(oldAcqId);
89 auto acqIdentifierToAcqRequestMapIt = impl->m_AcqIdentifierToAcqRequestMap.find(oldAcqId);
90 if (acqIdentifierToAcqRequestMapIt != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
90 if (acqIdentifierToAcqRequestMapIt != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
91 auto oldAcqRequest = acqIdentifierToAcqRequestMapIt->second;
91 auto oldAcqRequest = acqIdentifierToAcqRequestMapIt->second;
92 varRequestIdCanceled = oldAcqRequest.m_VarRequestId;
92 varRequestIdCanceled = oldAcqRequest.m_VarRequestId;
93 }
93 }
94 impl->unlock();
94 impl->unlock();
95 impl->cancelVarRequest(varRequestIdCanceled);
95 impl->cancelVarRequest(varRequestIdCanceled);
96 }
96 }
97 else {
97 else {
98 impl->unlock();
98 impl->unlock();
99 }
99 }
100
100
101 // Request for the variable, it must be stored and executed
101 // Request for the variable, it must be stored and executed
102 impl->lockWrite();
102 impl->lockWrite();
103 impl->m_VIdentifierToCurrrentAcqIdMap.insert(
103 impl->m_VIdentifierToCurrrentAcqIdMap.insert(
104 std::make_pair(vIdentifier, acqRequest.m_AcqIdentifier));
104 std::make_pair(vIdentifier, acqRequest.m_AcqIdentifier));
105 impl->unlock();
105 impl->unlock();
106
106
107 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
107 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
108 Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
108 Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
109
109
110 return varRequestIdCanceled;
110 return varRequestIdCanceled;
111 }
111 }
112
112
113 void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
113 void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
114 {
114 {
115 impl->lockRead();
115 impl->lockRead();
116
116
117 auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
117 auto it = impl->m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
118 if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
118 if (it != impl->m_VIdentifierToCurrrentAcqIdMap.cend()) {
119 auto currentAcqId = it->second;
119 auto currentAcqId = it->second;
120
120
121 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
121 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
122 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
122 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
123 auto request = it->second;
123 auto request = it->second;
124 impl->unlock();
124 impl->unlock();
125
125
126 // notify the request aborting to the provider
126 // notify the request aborting to the provider
127 request.m_Provider->requestDataAborting(currentAcqId);
127 request.m_Provider->requestDataAborting(currentAcqId);
128 }
128 }
129 else {
129 else {
130 impl->unlock();
130 impl->unlock();
131 qCWarning(LOG_VariableAcquisitionWorker())
131 qCWarning(LOG_VariableAcquisitionWorker())
132 << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
132 << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
133 }
133 }
134 }
134 }
135 else {
135 else {
136 impl->unlock();
136 impl->unlock();
137 }
137 }
138 }
138 }
139
139
140 void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
140 void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
141 double progress)
141 double progress)
142 {
142 {
143 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
143 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
144 << QThread::currentThread()->objectName()
144 << QThread::currentThread()->objectName()
145 << acqIdentifier << progress;
145 << acqIdentifier << progress;
146 impl->lockRead();
146 impl->lockRead();
147 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
147 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
148 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
148 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
149 auto progressPartSize
149 auto progressPartSize
150 = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
150 = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
151
151
152 auto currentPartProgress
152 auto currentPartProgress
153 = std::isnan(progress) ? 0.0 : (progress * progressPartSize) / 100.0;
153 = std::isnan(progress) ? 0.0 : (progress * progressPartSize) / 100.0;
154
154
155 // We can only give an approximation of the currentProgression since its upgrade is async.
155 // We can only give an approximation of the currentProgression since its upgrade is async.
156 auto currentProgression = aIdToARit->second.m_Progression;
156 auto currentProgression = aIdToARit->second.m_Progression;
157 if (currentProgression == aIdToARit->second.m_Size) {
157 if (currentProgression == aIdToARit->second.m_Size) {
158 currentProgression = aIdToARit->second.m_Size - 1;
158 currentProgression = aIdToARit->second.m_Size - 1;
159 }
159 }
160
160
161 auto currentAlreadyProgress = progressPartSize * currentProgression;
161 auto currentAlreadyProgress = progressPartSize * currentProgression;
162
162
163
163
164 auto finalProgression = currentAlreadyProgress + currentPartProgress;
164 auto finalProgression = currentAlreadyProgress + currentPartProgress;
165 emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
165 emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
166
166
167 if (finalProgression == 100.0) {
167 if (finalProgression == 100.0) {
168 emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
168 emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
169 }
169 }
170 }
170 }
171 impl->unlock();
171 impl->unlock();
172 }
172 }
173
173
174 void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
174 void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
175 {
175 {
176 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
176 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
177 << QThread::currentThread();
177 << QThread::currentThread();
178 impl->lockRead();
178 impl->lockRead();
179 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
179 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
180 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
180 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
181 auto request = it->second;
181 auto request = it->second;
182 impl->unlock();
182 impl->unlock();
183 emit variableCanceledRequested(request.m_vIdentifier);
183 emit variableCanceledRequested(request.m_vIdentifier);
184 }
184 }
185 else {
185 else {
186 impl->unlock();
186 impl->unlock();
187 }
187 }
188 }
188 }
189
189
190 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
190 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
191 std::shared_ptr<IDataSeries> dataSeries,
191 std::shared_ptr<IDataSeries> dataSeries,
192 SqpRange dataRangeAcquired)
192 SqpRange dataRangeAcquired)
193 {
193 {
194 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
194 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
195 << acqIdentifier << dataRangeAcquired;
195 << acqIdentifier << dataRangeAcquired;
196 impl->lockWrite();
196 impl->lockWrite();
197 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
197 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
198 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
198 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
199 // Store the result
199 // Store the result
200 auto dataPacket = AcquisitionDataPacket{};
200 auto dataPacket = AcquisitionDataPacket{};
201 dataPacket.m_Range = dataRangeAcquired;
201 dataPacket.m_Range = dataRangeAcquired;
202 dataPacket.m_DateSeries = dataSeries;
202 dataPacket.m_DateSeries = dataSeries;
203
203
204 auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
204 auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
205 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
205 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
206 // A current request result already exists, we can update it
206 // A current request result already exists, we can update it
207 aIdToADPVit->second.push_back(dataPacket);
207 aIdToADPVit->second.push_back(dataPacket);
208 }
208 }
209 else {
209 else {
210 // First request result for the variable, it must be stored
210 // First request result for the variable, it must be stored
211 impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
211 impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
212 std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
212 std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
213 }
213 }
214
214
215
215
216 // Decrement the counter of the request
216 // Decrement the counter of the request
217 auto &acqRequest = aIdToARit->second;
217 auto &acqRequest = aIdToARit->second;
218 acqRequest.m_Progression = acqRequest.m_Progression + 1;
218 acqRequest.m_Progression = acqRequest.m_Progression + 1;
219
219
220 // if the counter is 0, we can return data then run the next request if it exists and
220 // if the counter is 0, we can return data then run the next request if it exists and
221 // removed the finished request
221 // removed the finished request
222 if (acqRequest.m_Size == acqRequest.m_Progression) {
222 if (acqRequest.m_Size == acqRequest.m_Progression) {
223 auto varId = acqRequest.m_vIdentifier;
223 auto varId = acqRequest.m_vIdentifier;
224 // Return the data
224 // Return the data
225 aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
225 aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
226 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
226 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
227 emit dataProvided(varId, aIdToADPVit->second);
227 emit dataProvided(varId, aIdToADPVit->second);
228 }
228 }
229 impl->unlock();
229 impl->unlock();
230 }
230 }
231 else {
231 else {
232 impl->unlock();
232 impl->unlock();
233 }
233 }
234 }
234 }
235 else {
235 else {
236 impl->unlock();
236 impl->unlock();
237 qCWarning(LOG_VariableAcquisitionWorker())
237 qCWarning(LOG_VariableAcquisitionWorker())
238 << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
238 << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
239 }
239 }
240 }
240 }
241
241
242 void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
242 void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
243 {
243 {
244 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
244 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
245 impl->lockRead();
245 impl->lockRead();
246 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
246 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
247 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
247 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
248 auto request = it->second;
248 auto request = it->second;
249 impl->unlock();
249 impl->unlock();
250 emit variableRequestInProgress(request.m_vIdentifier, 0.1);
250 emit variableRequestInProgress(request.m_vIdentifier, 0.1);
251 qCDebug(LOG_VariableAcquisitionWorker()) << tr("Start request 10%") << acqIdentifier
251 qCDebug(LOG_VariableAcquisitionWorker()) << tr("Start request 10%") << acqIdentifier
252 << QThread::currentThread();
252 << QThread::currentThread();
253 request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
253 request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
254 }
254 }
255 else {
255 else {
256 impl->unlock();
256 impl->unlock();
257 // TODO log no acqIdentifier recognized
257 // TODO log no acqIdentifier recognized
258 }
258 }
259 }
259 }
260
260
261 void VariableAcquisitionWorker::initialize()
261 void VariableAcquisitionWorker::initialize()
262 {
262 {
263 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
263 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
264 << QThread::currentThread();
264 << QThread::currentThread();
265 impl->m_WorkingMutex.lock();
265 impl->m_WorkingMutex.lock();
266 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
266 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
267 }
267 }
268
268
269 void VariableAcquisitionWorker::finalize()
269 void VariableAcquisitionWorker::finalize()
270 {
270 {
271 impl->m_WorkingMutex.unlock();
271 impl->m_WorkingMutex.unlock();
272 }
272 }
273
273
274 void VariableAcquisitionWorker::waitForFinish()
274 void VariableAcquisitionWorker::waitForFinish()
275 {
275 {
276 QMutexLocker locker{&impl->m_WorkingMutex};
276 QMutexLocker locker{&impl->m_WorkingMutex};
277 }
277 }
278
278
279 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
279 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
280 QUuid vIdentifier)
280 QUuid vIdentifier)
281 {
281 {
282 lockWrite();
282 lockWrite();
283 auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
283 auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
284
284
285 if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
285 if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
286 // A current request already exists, we can replace the next one
286 // A current request already exists, we can replace the next one
287
287
288 qCDebug(LOG_VariableAcquisitionWorker())
288 qCDebug(LOG_VariableAcquisitionWorker())
289 << "VariableAcquisitionWorkerPrivate::removeVariableRequest "
289 << "VariableAcquisitionWorkerPrivate::removeVariableRequest "
290 << QThread::currentThread()->objectName() << it->second;
290 << QThread::currentThread()->objectName() << it->second;
291 m_AcqIdentifierToAcqRequestMap.erase(it->second);
291 m_AcqIdentifierToAcqRequestMap.erase(it->second);
292 m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second);
292 m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second);
293 }
293 }
294
294
295 // stop any progression
295 // stop any progression
296 emit q->variableRequestInProgress(vIdentifier, 0.0);
296 emit q->variableRequestInProgress(vIdentifier, 0.0);
297
297
298 m_VIdentifierToCurrrentAcqIdMap.erase(vIdentifier);
298 m_VIdentifierToCurrrentAcqIdMap.erase(vIdentifier);
299 unlock();
299 unlock();
300 }
300 }
301
301
302 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::cancelVarRequest(
302 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::cancelVarRequest(
303 QUuid varRequestId)
303 QUuid varRequestId)
304 {
304 {
305 qCDebug(LOG_VariableAcquisitionWorker())
305 qCDebug(LOG_VariableAcquisitionWorker())
306 << "VariableAcquisitionWorkerPrivate::cancelVarRequest start";
306 << "VariableAcquisitionWorkerPrivate::cancelVarRequest start";
307 lockRead();
307 lockRead();
308 // get all AcqIdentifier in link with varRequestId
308 // get all AcqIdentifier in link with varRequestId
309 QVector<QUuid> acqIdsToRm;
309 QVector<QUuid> acqIdsToRm;
310 auto cend = m_AcqIdentifierToAcqRequestMap.cend();
310 auto cend = m_AcqIdentifierToAcqRequestMap.cend();
311 for (auto it = m_AcqIdentifierToAcqRequestMap.cbegin(); it != cend; ++it) {
311 for (auto it = m_AcqIdentifierToAcqRequestMap.cbegin(); it != cend; ++it) {
312 if (it->second.m_VarRequestId == varRequestId) {
312 if (it->second.m_VarRequestId == varRequestId) {
313 acqIdsToRm << it->first;
313 acqIdsToRm << it->first;
314 }
314 }
315 }
315 }
316 unlock();
316 unlock();
317 // run aborting or removing of acqIdsToRm
317 // run aborting or removing of acqIdsToRm
318
318
319 for (auto acqId : acqIdsToRm) {
319 for (auto acqId : acqIdsToRm) {
320 removeAcqRequest(acqId);
320 removeAcqRequest(acqId);
321 }
321 }
322 qCDebug(LOG_VariableAcquisitionWorker())
322 qCDebug(LOG_VariableAcquisitionWorker())
323 << "VariableAcquisitionWorkerPrivate::cancelVarRequest end";
323 << "VariableAcquisitionWorkerPrivate::cancelVarRequest end";
324 }
324 }
325
325
326 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeAcqRequest(
326 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeAcqRequest(
327 QUuid acqRequestId)
327 QUuid acqRequestId)
328 {
328 {
329 qCDebug(LOG_VariableAcquisitionWorker())
329 qCDebug(LOG_VariableAcquisitionWorker())
330 << "VariableAcquisitionWorkerPrivate::removeAcqRequest";
330 << "VariableAcquisitionWorkerPrivate::removeAcqRequest";
331 QUuid vIdentifier;
331 QUuid vIdentifier;
332 std::shared_ptr<IDataProvider> provider;
332 std::shared_ptr<IDataProvider> provider;
333 lockRead();
333 lockRead();
334 auto acqIt = m_AcqIdentifierToAcqRequestMap.find(acqRequestId);
334 auto acqIt = m_AcqIdentifierToAcqRequestMap.find(acqRequestId);
335 if (acqIt != m_AcqIdentifierToAcqRequestMap.cend()) {
335 if (acqIt != m_AcqIdentifierToAcqRequestMap.cend()) {
336 vIdentifier = acqIt->second.m_vIdentifier;
336 vIdentifier = acqIt->second.m_vIdentifier;
337 provider = acqIt->second.m_Provider;
337 provider = acqIt->second.m_Provider;
338
338
339 auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
339 auto it = m_VIdentifierToCurrrentAcqIdMap.find(vIdentifier);
340 if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
340 if (it != m_VIdentifierToCurrrentAcqIdMap.cend()) {
341 if (it->second == acqRequestId) {
341 if (it->second == acqRequestId) {
342 // acqRequest is currently running -> let's aborting it
342 // acqRequest is currently running -> let's aborting it
343 unlock();
343 unlock();
344
344
345 // notify the request aborting to the provider
345 // notify the request aborting to the provider
346 provider->requestDataAborting(acqRequestId);
346 provider->requestDataAborting(acqRequestId);
347 }
347 }
348 else {
348 else {
349 unlock();
349 unlock();
350 }
350 }
351 }
351 }
352 else {
352 else {
353 unlock();
353 unlock();
354 }
354 }
355 }
355 }
356 else {
356 else {
357 unlock();
357 unlock();
358 }
358 }
359
359
360 lockWrite();
360 lockWrite();
361
361
362 m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqRequestId);
362 m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqRequestId);
363 m_AcqIdentifierToAcqRequestMap.erase(acqRequestId);
363 m_AcqIdentifierToAcqRequestMap.erase(acqRequestId);
364 m_VIdentifierToCurrrentAcqIdMap.erase(vIdentifier);
364
365
365 unlock();
366 unlock();
366 qCDebug(LOG_VariableAcquisitionWorker())
367 qCDebug(LOG_VariableAcquisitionWorker())
367 << "VariableAcquisitionWorkerPrivate::removeAcqRequest END";
368 << "VariableAcquisitionWorkerPrivate::removeAcqRequest END";
368 }
369 }
Show file before | Show file after | Hide comments
@@ -1,1092 +1,1101
1 #include <Variable/Variable.h>
1 #include <Variable/Variable.h>
2 #include <Variable/VariableAcquisitionWorker.h>
2 #include <Variable/VariableAcquisitionWorker.h>
3 #include <Variable/VariableCacheStrategy.h>
3 #include <Variable/VariableCacheStrategy.h>
4 #include <Variable/VariableCacheStrategyFactory.h>
4 #include <Variable/VariableCacheStrategyFactory.h>
5 #include <Variable/VariableController.h>
5 #include <Variable/VariableController.h>
6 #include <Variable/VariableModel.h>
6 #include <Variable/VariableModel.h>
7 #include <Variable/VariableSynchronizationGroup.h>
7 #include <Variable/VariableSynchronizationGroup.h>
8
8
9 #include <Data/DataProviderParameters.h>
9 #include <Data/DataProviderParameters.h>
10 #include <Data/IDataProvider.h>
10 #include <Data/IDataProvider.h>
11 #include <Data/IDataSeries.h>
11 #include <Data/IDataSeries.h>
12 #include <Data/VariableRequest.h>
12 #include <Data/VariableRequest.h>
13 #include <Time/TimeController.h>
13 #include <Time/TimeController.h>
14
14
15 #include <QDataStream>
15 #include <QDataStream>
16 #include <QMutex>
16 #include <QMutex>
17 #include <QThread>
17 #include <QThread>
18 #include <QUuid>
18 #include <QUuid>
19 #include <QtCore/QItemSelectionModel>
19 #include <QtCore/QItemSelectionModel>
20
20
21 #include <deque>
21 #include <deque>
22 #include <set>
22 #include <set>
23 #include <unordered_map>
23 #include <unordered_map>
24
24
25 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
25 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
26
26
27 namespace {
27 namespace {
28
28
29 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
29 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
30 const SqpRange &oldGraphRange)
30 const SqpRange &oldGraphRange)
31 {
31 {
32 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
32 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
33
33
34 auto varRangeRequested = varRange;
34 auto varRangeRequested = varRange;
35 switch (zoomType) {
35 switch (zoomType) {
36 case AcquisitionZoomType::ZoomIn: {
36 case AcquisitionZoomType::ZoomIn: {
37 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
37 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
38 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
38 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
39 varRangeRequested.m_TStart += deltaLeft;
39 varRangeRequested.m_TStart += deltaLeft;
40 varRangeRequested.m_TEnd -= deltaRight;
40 varRangeRequested.m_TEnd -= deltaRight;
41 break;
41 break;
42 }
42 }
43
43
44 case AcquisitionZoomType::ZoomOut: {
44 case AcquisitionZoomType::ZoomOut: {
45 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
45 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
46 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
46 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
47 varRangeRequested.m_TStart -= deltaLeft;
47 varRangeRequested.m_TStart -= deltaLeft;
48 varRangeRequested.m_TEnd += deltaRight;
48 varRangeRequested.m_TEnd += deltaRight;
49 break;
49 break;
50 }
50 }
51 case AcquisitionZoomType::PanRight: {
51 case AcquisitionZoomType::PanRight: {
52 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
52 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
53 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
53 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
54 varRangeRequested.m_TStart += deltaLeft;
54 varRangeRequested.m_TStart += deltaLeft;
55 varRangeRequested.m_TEnd += deltaRight;
55 varRangeRequested.m_TEnd += deltaRight;
56 break;
56 break;
57 }
57 }
58 case AcquisitionZoomType::PanLeft: {
58 case AcquisitionZoomType::PanLeft: {
59 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
59 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
60 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
60 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
61 varRangeRequested.m_TStart -= deltaLeft;
61 varRangeRequested.m_TStart -= deltaLeft;
62 varRangeRequested.m_TEnd -= deltaRight;
62 varRangeRequested.m_TEnd -= deltaRight;
63 break;
63 break;
64 }
64 }
65 case AcquisitionZoomType::Unknown: {
65 case AcquisitionZoomType::Unknown: {
66 qCCritical(LOG_VariableController())
66 qCCritical(LOG_VariableController())
67 << VariableController::tr("Impossible to synchronize: zoom type unknown");
67 << VariableController::tr("Impossible to synchronize: zoom type unknown");
68 break;
68 break;
69 }
69 }
70 default:
70 default:
71 qCCritical(LOG_VariableController()) << VariableController::tr(
71 qCCritical(LOG_VariableController()) << VariableController::tr(
72 "Impossible to synchronize: zoom type not take into account");
72 "Impossible to synchronize: zoom type not take into account");
73 // No action
73 // No action
74 break;
74 break;
75 }
75 }
76
76
77 return varRangeRequested;
77 return varRangeRequested;
78 }
78 }
79 }
79 }
80
80
81 enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
81 enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
82
82
83 struct VariableRequestHandler {
83 struct VariableRequestHandler {
84
84
85 VariableRequestHandler()
85 VariableRequestHandler()
86 {
86 {
87 m_CanUpdate = false;
87 m_CanUpdate = false;
88 m_State = VariableRequestHandlerState::OFF;
88 m_State = VariableRequestHandlerState::OFF;
89 }
89 }
90
90
91 QUuid m_VarId;
91 QUuid m_VarId;
92 VariableRequest m_RunningVarRequest;
92 VariableRequest m_RunningVarRequest;
93 VariableRequest m_PendingVarRequest;
93 VariableRequest m_PendingVarRequest;
94 VariableRequestHandlerState m_State;
94 VariableRequestHandlerState m_State;
95 bool m_CanUpdate;
95 bool m_CanUpdate;
96 };
96 };
97
97
98 struct VariableController::VariableControllerPrivate {
98 struct VariableController::VariableControllerPrivate {
99 explicit VariableControllerPrivate(VariableController *parent)
99 explicit VariableControllerPrivate(VariableController *parent)
100 : m_WorkingMutex{},
100 : m_WorkingMutex{},
101 m_VariableModel{new VariableModel{parent}},
101 m_VariableModel{new VariableModel{parent}},
102 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
102 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
103 // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
103 // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
104 m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
104 m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
105 CacheStrategy::SingleThreshold)},
105 CacheStrategy::SingleThreshold)},
106 m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
106 m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
107 q{parent}
107 q{parent}
108 {
108 {
109
109
110 m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
110 m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
111 m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
111 m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
112 }
112 }
113
113
114
114
115 virtual ~VariableControllerPrivate()
115 virtual ~VariableControllerPrivate()
116 {
116 {
117 qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
117 qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
118 m_VariableAcquisitionWorkerThread.quit();
118 m_VariableAcquisitionWorkerThread.quit();
119 m_VariableAcquisitionWorkerThread.wait();
119 m_VariableAcquisitionWorkerThread.wait();
120 }
120 }
121
121
122
122
123 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
123 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
124 QUuid varRequestId);
124 QUuid varRequestId);
125
125
126 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
126 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
127 std::shared_ptr<IDataSeries>
127 std::shared_ptr<IDataSeries>
128 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
128 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
129
129
130 void registerProvider(std::shared_ptr<IDataProvider> provider);
130 void registerProvider(std::shared_ptr<IDataProvider> provider);
131
131
132 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
132 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
133 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
133 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
134 void updateVariables(QUuid varRequestId);
134 void updateVariables(QUuid varRequestId);
135 void updateVariableRequest(QUuid varRequestId);
135 void updateVariableRequest(QUuid varRequestId);
136 void cancelVariableRequest(QUuid varRequestId);
136 void cancelVariableRequest(QUuid varRequestId);
137 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
137 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
138
138
139 template <typename VariableIterator>
139 template <typename VariableIterator>
140 void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
140 void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
141
141
142 QMutex m_WorkingMutex;
142 QMutex m_WorkingMutex;
143 /// Variable model. The VariableController has the ownership
143 /// Variable model. The VariableController has the ownership
144 VariableModel *m_VariableModel;
144 VariableModel *m_VariableModel;
145 QItemSelectionModel *m_VariableSelectionModel;
145 QItemSelectionModel *m_VariableSelectionModel;
146
146
147
147
148 TimeController *m_TimeController{nullptr};
148 TimeController *m_TimeController{nullptr};
149 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
149 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
150 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
150 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
151 QThread m_VariableAcquisitionWorkerThread;
151 QThread m_VariableAcquisitionWorkerThread;
152
152
153 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
153 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
154 m_VariableToProviderMap;
154 m_VariableToProviderMap;
155 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
155 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
156 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
156 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
157 m_GroupIdToVariableSynchronizationGroupMap;
157 m_GroupIdToVariableSynchronizationGroupMap;
158 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
158 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
159 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
159 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
160
160
161 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
161 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
162 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
162 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
163
163
164 VariableController *q;
164 VariableController *q;
165 };
165 };
166
166
167
167
168 VariableController::VariableController(QObject *parent)
168 VariableController::VariableController(QObject *parent)
169 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
169 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
170 {
170 {
171 qCDebug(LOG_VariableController()) << tr("VariableController construction")
171 qCDebug(LOG_VariableController()) << tr("VariableController construction")
172 << QThread::currentThread();
172 << QThread::currentThread();
173
173
174 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
174 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
175 &VariableController::onAbortProgressRequested);
175 &VariableController::onAbortProgressRequested);
176
176
177 connect(impl->m_VariableAcquisitionWorker.get(),
177 connect(impl->m_VariableAcquisitionWorker.get(),
178 &VariableAcquisitionWorker::variableCanceledRequested, this,
178 &VariableAcquisitionWorker::variableCanceledRequested, this,
179 &VariableController::onAbortAcquisitionRequested);
179 &VariableController::onAbortAcquisitionRequested);
180
180
181 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
181 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
182 &VariableController::onDataProvided);
182 &VariableController::onDataProvided);
183 connect(impl->m_VariableAcquisitionWorker.get(),
183 connect(impl->m_VariableAcquisitionWorker.get(),
184 &VariableAcquisitionWorker::variableRequestInProgress, this,
184 &VariableAcquisitionWorker::variableRequestInProgress, this,
185 &VariableController::onVariableRetrieveDataInProgress);
185 &VariableController::onVariableRetrieveDataInProgress);
186
186
187
187
188 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
188 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
189 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
189 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
190 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
190 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
191 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
191 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
192
192
193 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
193 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
194 &VariableController::onUpdateDateTime);
194 &VariableController::onUpdateDateTime);
195
195
196 impl->m_VariableAcquisitionWorkerThread.start();
196 impl->m_VariableAcquisitionWorkerThread.start();
197 }
197 }
198
198
199 VariableController::~VariableController()
199 VariableController::~VariableController()
200 {
200 {
201 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
201 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
202 << QThread::currentThread();
202 << QThread::currentThread();
203 this->waitForFinish();
203 this->waitForFinish();
204 }
204 }
205
205
206 VariableModel *VariableController::variableModel() noexcept
206 VariableModel *VariableController::variableModel() noexcept
207 {
207 {
208 return impl->m_VariableModel;
208 return impl->m_VariableModel;
209 }
209 }
210
210
211 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
211 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
212 {
212 {
213 return impl->m_VariableSelectionModel;
213 return impl->m_VariableSelectionModel;
214 }
214 }
215
215
216 void VariableController::setTimeController(TimeController *timeController) noexcept
216 void VariableController::setTimeController(TimeController *timeController) noexcept
217 {
217 {
218 impl->m_TimeController = timeController;
218 impl->m_TimeController = timeController;
219 }
219 }
220
220
221 std::shared_ptr<Variable>
221 std::shared_ptr<Variable>
222 VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
222 VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
223 {
223 {
224 if (impl->m_VariableModel->containsVariable(variable)) {
224 if (impl->m_VariableModel->containsVariable(variable)) {
225 // Clones variable
225 // Clones variable
226 auto duplicate = variable->clone();
226 auto duplicate = variable->clone();
227
227
228 // Adds clone to model
228 // Adds clone to model
229 impl->m_VariableModel->addVariable(duplicate);
229 impl->m_VariableModel->addVariable(duplicate);
230
230
231 // Generates clone identifier
231 // Generates clone identifier
232 impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
232 impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
233
233
234 // Registers provider
234 // Registers provider
235 auto variableProvider = impl->m_VariableToProviderMap.at(variable);
235 auto variableProvider = impl->m_VariableToProviderMap.at(variable);
236 auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
236 auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
237
237
238 impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
238 impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
239 if (duplicateProvider) {
239 if (duplicateProvider) {
240 impl->registerProvider(duplicateProvider);
240 impl->registerProvider(duplicateProvider);
241 }
241 }
242
242
243 return duplicate;
243 return duplicate;
244 }
244 }
245 else {
245 else {
246 qCCritical(LOG_VariableController())
246 qCCritical(LOG_VariableController())
247 << tr("Can't create duplicate of variable %1: variable not registered in the model")
247 << tr("Can't create duplicate of variable %1: variable not registered in the model")
248 .arg(variable->name());
248 .arg(variable->name());
249 return nullptr;
249 return nullptr;
250 }
250 }
251 }
251 }
252
252
253 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
253 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
254 {
254 {
255 if (!variable) {
255 if (!variable) {
256 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
256 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
257 return;
257 return;
258 }
258 }
259
259
260 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
260 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
261 // make some treatments before the deletion
261 // make some treatments before the deletion
262 emit variableAboutToBeDeleted(variable);
262 emit variableAboutToBeDeleted(variable);
263
263
264 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
264 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
265 Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
265 Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
266
266
267 auto variableId = variableIt->second;
267 auto variableId = variableIt->second;
268
268
269 // Removes variable's handler
269 // Removes variable's handler
270 impl->m_VarIdToVarRequestHandler.erase(variableId);
270 impl->m_VarIdToVarRequestHandler.erase(variableId);
271
271
272 // Desynchronizes variable (if the variable is in a sync group)
272 // Desynchronizes variable (if the variable is in a sync group)
273 auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
273 auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
274 if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
274 if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
275 impl->desynchronize(variableIt, syncGroupIt->second);
275 impl->desynchronize(variableIt, syncGroupIt->second);
276 }
276 }
277
277
278 // Deletes identifier
278 // Deletes identifier
279 impl->m_VariableToIdentifierMap.erase(variableIt);
279 impl->m_VariableToIdentifierMap.erase(variableIt);
280
280
281 // Deletes provider
281 // Deletes provider
282 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
282 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
283 qCDebug(LOG_VariableController())
283 qCDebug(LOG_VariableController())
284 << tr("Number of providers deleted for variable %1: %2")
284 << tr("Number of providers deleted for variable %1: %2")
285 .arg(variable->name(), QString::number(nbProvidersDeleted));
285 .arg(variable->name(), QString::number(nbProvidersDeleted));
286
286
287
287
288 // Deletes from model
288 // Deletes from model
289 impl->m_VariableModel->deleteVariable(variable);
289 impl->m_VariableModel->deleteVariable(variable);
290 }
290 }
291
291
292 void VariableController::deleteVariables(
292 void VariableController::deleteVariables(
293 const QVector<std::shared_ptr<Variable> > &variables) noexcept
293 const QVector<std::shared_ptr<Variable> > &variables) noexcept
294 {
294 {
295 for (auto variable : qAsConst(variables)) {
295 for (auto variable : qAsConst(variables)) {
296 deleteVariable(variable);
296 deleteVariable(variable);
297 }
297 }
298 }
298 }
299
299
300 QByteArray
300 QByteArray
301 VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
301 VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
302 {
302 {
303 auto encodedData = QByteArray{};
303 auto encodedData = QByteArray{};
304
304
305 QVariantList ids;
305 QVariantList ids;
306 for (auto &var : variables) {
306 for (auto &var : variables) {
307 auto itVar = impl->m_VariableToIdentifierMap.find(var);
307 auto itVar = impl->m_VariableToIdentifierMap.find(var);
308 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
308 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
309 qCCritical(LOG_VariableController())
309 qCCritical(LOG_VariableController())
310 << tr("Impossible to find the data for an unknown variable.");
310 << tr("Impossible to find the data for an unknown variable.");
311 }
311 }
312
312
313 ids << itVar->second.toByteArray();
313 ids << itVar->second.toByteArray();
314 }
314 }
315
315
316 QDataStream stream{&encodedData, QIODevice::WriteOnly};
316 QDataStream stream{&encodedData, QIODevice::WriteOnly};
317 stream << ids;
317 stream << ids;
318
318
319 return encodedData;
319 return encodedData;
320 }
320 }
321
321
322 QList<std::shared_ptr<Variable> >
322 QList<std::shared_ptr<Variable> >
323 VariableController::variablesForMimeData(const QByteArray &mimeData) const
323 VariableController::variablesForMimeData(const QByteArray &mimeData) const
324 {
324 {
325 auto variables = QList<std::shared_ptr<Variable> >{};
325 auto variables = QList<std::shared_ptr<Variable> >{};
326 QDataStream stream{mimeData};
326 QDataStream stream{mimeData};
327
327
328 QVariantList ids;
328 QVariantList ids;
329 stream >> ids;
329 stream >> ids;
330
330
331 for (auto id : ids) {
331 for (auto id : ids) {
332 auto uuid = QUuid{id.toByteArray()};
332 auto uuid = QUuid{id.toByteArray()};
333 auto var = impl->findVariable(uuid);
333 auto var = impl->findVariable(uuid);
334 variables << var;
334 variables << var;
335 }
335 }
336
336
337 return variables;
337 return variables;
338 }
338 }
339
339
340 std::shared_ptr<Variable>
340 std::shared_ptr<Variable>
341 VariableController::createVariable(const QString &name, const QVariantHash &metadata,
341 VariableController::createVariable(const QString &name, const QVariantHash &metadata,
342 std::shared_ptr<IDataProvider> provider) noexcept
342 std::shared_ptr<IDataProvider> provider) noexcept
343 {
343 {
344 if (!impl->m_TimeController) {
344 if (!impl->m_TimeController) {
345 qCCritical(LOG_VariableController())
345 qCCritical(LOG_VariableController())
346 << tr("Impossible to create variable: The time controller is null");
346 << tr("Impossible to create variable: The time controller is null");
347 return nullptr;
347 return nullptr;
348 }
348 }
349
349
350 auto range = impl->m_TimeController->dateTime();
350 auto range = impl->m_TimeController->dateTime();
351
351
352 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
352 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
353 auto varId = QUuid::createUuid();
353 auto varId = QUuid::createUuid();
354
354
355 // Create the handler
355 // Create the handler
356 auto varRequestHandler = std::make_unique<VariableRequestHandler>();
356 auto varRequestHandler = std::make_unique<VariableRequestHandler>();
357 varRequestHandler->m_VarId = varId;
357 varRequestHandler->m_VarId = varId;
358
358
359 impl->m_VarIdToVarRequestHandler.insert(
359 impl->m_VarIdToVarRequestHandler.insert(
360 std::make_pair(varId, std::move(varRequestHandler)));
360 std::make_pair(varId, std::move(varRequestHandler)));
361
361
362 // store the provider
362 // store the provider
363 impl->registerProvider(provider);
363 impl->registerProvider(provider);
364
364
365 // Associate the provider
365 // Associate the provider
366 impl->m_VariableToProviderMap[newVariable] = provider;
366 impl->m_VariableToProviderMap[newVariable] = provider;
367 impl->m_VariableToIdentifierMap[newVariable] = varId;
367 impl->m_VariableToIdentifierMap[newVariable] = varId;
368
368
369 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
369 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
370
370
371 emit variableAdded(newVariable);
371 emit variableAdded(newVariable);
372
372
373 return newVariable;
373 return newVariable;
374 }
374 }
375
375
376 qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
376 qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
377 return nullptr;
377 return nullptr;
378 }
378 }
379
379
380 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
380 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
381 {
381 {
382 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
382 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
383 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
383 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
384 << QThread::currentThread()->objectName();
384 << QThread::currentThread()->objectName();
385 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
385 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
386
386
387 // NOTE we only permit the time modification for one variable
387 // NOTE we only permit the time modification for one variable
388 if (selectedRows.size() == 1) {
388 if (selectedRows.size() == 1) {
389
389
390 if (auto selectedVariable
390 if (auto selectedVariable
391 = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
391 = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
392
392
393 onUpdateDateTime(selectedVariable, dateTime);
393 onUpdateDateTime(selectedVariable, dateTime);
394 }
394 }
395 }
395 }
396 else if (selectedRows.size() > 1) {
396 else if (selectedRows.size() > 1) {
397 qCCritical(LOG_VariableController())
397 qCCritical(LOG_VariableController())
398 << tr("Impossible to set time for more than 1 variable in the same time");
398 << tr("Impossible to set time for more than 1 variable in the same time");
399 }
399 }
400 else {
400 else {
401 qCWarning(LOG_VariableController())
401 qCWarning(LOG_VariableController())
402 << tr("There is no variable selected to set the time one");
402 << tr("There is no variable selected to set the time one");
403 }
403 }
404 }
404 }
405
405
406 void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
406 void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
407 const SqpRange &dateTime)
407 const SqpRange &dateTime)
408 {
408 {
409 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
409 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
410 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
410 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
411 qCCritical(LOG_VariableController())
411 qCCritical(LOG_VariableController())
412 << tr("Impossible to onDateTimeOnSelection request for unknown variable");
412 << tr("Impossible to onDateTimeOnSelection request for unknown variable");
413 return;
413 return;
414 }
414 }
415
415
416 // notify that rescale operation has to be done
416 // notify that rescale operation has to be done
417 emit rangeChanged(variable, dateTime);
417 emit rangeChanged(variable, dateTime);
418
418
419 auto synchro
419 auto synchro
420 = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
420 = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
421
421
422 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
422 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
423 }
423 }
424
424
425 void VariableController::onDataProvided(QUuid vIdentifier,
425 void VariableController::onDataProvided(QUuid vIdentifier,
426 QVector<AcquisitionDataPacket> dataAcquired)
426 QVector<AcquisitionDataPacket> dataAcquired)
427 {
427 {
428 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
428 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
429 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
429 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
430 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
430 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
431 if (!varRequestId.isNull()) {
431 if (!varRequestId.isNull()) {
432 impl->updateVariables(varRequestId);
432 impl->updateVariables(varRequestId);
433 }
433 }
434 }
434 }
435
435
436 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
436 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
437 {
437 {
438 qCDebug(LOG_VariableController())
438 qCDebug(LOG_VariableController())
439 << "TORM: variableController::onVariableRetrieveDataInProgress"
439 << "TORM: variableController::onVariableRetrieveDataInProgress"
440 << QThread::currentThread()->objectName() << progress;
440 << QThread::currentThread()->objectName() << progress;
441 if (auto var = impl->findVariable(identifier)) {
441 if (auto var = impl->findVariable(identifier)) {
442 qCDebug(LOG_VariableController())
442 qCDebug(LOG_VariableController())
443 << "TORM: variableController::onVariableRetrieveDataInProgress FOUND";
443 << "TORM: variableController::onVariableRetrieveDataInProgress FOUND";
444 impl->m_VariableModel->setDataProgress(var, progress);
444 impl->m_VariableModel->setDataProgress(var, progress);
445 }
445 }
446 else {
446 else {
447 qCCritical(LOG_VariableController())
447 qCCritical(LOG_VariableController())
448 << tr("Impossible to notify progression of a null variable");
448 << tr("Impossible to notify progression of a null variable");
449 }
449 }
450 }
450 }
451
451
452 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
452 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
453 {
453 {
454 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
454 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
455 << QThread::currentThread()->objectName() << variable->name();
455 << QThread::currentThread()->objectName() << variable->name();
456
456
457 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
457 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
458 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
458 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
459 qCCritical(LOG_VariableController())
459 qCCritical(LOG_VariableController())
460 << tr("Impossible to onAbortProgressRequested request for unknown variable");
460 << tr("Impossible to onAbortProgressRequested request for unknown variable");
461 return;
461 return;
462 }
462 }
463
463
464 auto varId = itVar->second;
464 auto varId = itVar->second;
465
465
466 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
466 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
467 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
467 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
468 qCCritical(LOG_VariableController())
468 qCCritical(LOG_VariableController())
469 << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
469 << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
470 return;
470 return;
471 }
471 }
472
472
473 auto varHandler = itVarHandler->second.get();
473 auto varHandler = itVarHandler->second.get();
474
474
475 // case where a variable has a running request
475 // case where a variable has a running request
476 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
476 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
477 impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
477 impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
478 }
478 }
479 }
479 }
480
480
481 void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
481 void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
482 {
482 {
483 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
483 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
484 << QThread::currentThread()->objectName() << vIdentifier;
484 << QThread::currentThread()->objectName() << vIdentifier;
485
485
486 if (auto var = impl->findVariable(vIdentifier)) {
486 if (auto var = impl->findVariable(vIdentifier)) {
487 this->onAbortProgressRequested(var);
487 this->onAbortProgressRequested(var);
488 }
488 }
489 else {
489 else {
490 qCCritical(LOG_VariableController())
490 qCCritical(LOG_VariableController())
491 << tr("Impossible to abort Acquisition Requestof a null variable");
491 << tr("Impossible to abort Acquisition Requestof a null variable");
492 }
492 }
493 }
493 }
494
494
495 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
495 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
496 {
496 {
497 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
497 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
498 << QThread::currentThread()->objectName()
498 << QThread::currentThread()->objectName()
499 << synchronizationGroupId;
499 << synchronizationGroupId;
500 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
500 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
501 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
501 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
502 std::make_pair(synchronizationGroupId, vSynchroGroup));
502 std::make_pair(synchronizationGroupId, vSynchroGroup));
503 }
503 }
504
504
505 void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
505 void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
506 {
506 {
507 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
507 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
508 }
508 }
509
509
510 void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
510 void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
511 QUuid synchronizationGroupId)
511 QUuid synchronizationGroupId)
512
512
513 {
513 {
514 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
514 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
515 << synchronizationGroupId;
515 << synchronizationGroupId;
516 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
516 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
517 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
517 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
518 auto groupIdToVSGIt
518 auto groupIdToVSGIt
519 = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
519 = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
520 if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
520 if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
521 impl->m_VariableIdGroupIdMap.insert(
521 impl->m_VariableIdGroupIdMap.insert(
522 std::make_pair(varToVarIdIt->second, synchronizationGroupId));
522 std::make_pair(varToVarIdIt->second, synchronizationGroupId));
523 groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
523 groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
524 }
524 }
525 else {
525 else {
526 qCCritical(LOG_VariableController())
526 qCCritical(LOG_VariableController())
527 << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
527 << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
528 << variable->name();
528 << variable->name();
529 }
529 }
530 }
530 }
531 else {
531 else {
532 qCCritical(LOG_VariableController())
532 qCCritical(LOG_VariableController())
533 << tr("Impossible to synchronize a variable with no identifier") << variable->name();
533 << tr("Impossible to synchronize a variable with no identifier") << variable->name();
534 }
534 }
535 }
535 }
536
536
537 void VariableController::desynchronize(std::shared_ptr<Variable> variable,
537 void VariableController::desynchronize(std::shared_ptr<Variable> variable,
538 QUuid synchronizationGroupId)
538 QUuid synchronizationGroupId)
539 {
539 {
540 // Gets variable id
540 // Gets variable id
541 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
541 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
542 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
542 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
543 qCCritical(LOG_VariableController())
543 qCCritical(LOG_VariableController())
544 << tr("Can't desynchronize variable %1: variable identifier not found")
544 << tr("Can't desynchronize variable %1: variable identifier not found")
545 .arg(variable->name());
545 .arg(variable->name());
546 return;
546 return;
547 }
547 }
548
548
549 impl->desynchronize(variableIt, synchronizationGroupId);
549 impl->desynchronize(variableIt, synchronizationGroupId);
550 }
550 }
551
551
552 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
552 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
553 const SqpRange &range, bool synchronise)
553 const SqpRange &range, bool synchronise)
554 {
554 {
555 // variables is assumed synchronized
555 // variables is assumed synchronized
556 // TODO: Asser variables synchronization
556 // TODO: Asser variables synchronization
557 // we want to load data of the variable for the dateTime.
557 // we want to load data of the variable for the dateTime.
558 if (variables.isEmpty()) {
558 if (variables.isEmpty()) {
559 return;
559 return;
560 }
560 }
561
561
562 auto varRequestId = QUuid::createUuid();
562 auto varRequestId = QUuid::createUuid();
563 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
563 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
564 << QThread::currentThread()->objectName() << varRequestId
564 << QThread::currentThread()->objectName() << varRequestId
565 << range << synchronise;
565 << range << synchronise;
566
566
567 if (!synchronise) {
567 if (!synchronise) {
568 auto varIds = std::list<QUuid>{};
568 auto varIds = std::list<QUuid>{};
569 for (const auto &var : variables) {
569 for (const auto &var : variables) {
570 auto vId = impl->m_VariableToIdentifierMap.at(var);
570 auto vId = impl->m_VariableToIdentifierMap.at(var);
571 varIds.push_back(vId);
571 varIds.push_back(vId);
572 }
572 }
573 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
573 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
574 for (const auto &var : variables) {
574 for (const auto &var : variables) {
575 qCDebug(LOG_VariableController()) << "onRequestDataLoading: for" << varRequestId
575 qCDebug(LOG_VariableController()) << "onRequestDataLoading: for" << varRequestId
576 << varIds.size();
576 << varIds.size();
577 impl->processRequest(var, range, varRequestId);
577 impl->processRequest(var, range, varRequestId);
578 }
578 }
579 }
579 }
580 else {
580 else {
581 auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
581 auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
582 auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
582 auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
583 if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
583 if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
584 auto groupId = varIdToGroupIdIt->second;
584 auto groupId = varIdToGroupIdIt->second;
585
585
586 auto vSynchronizationGroup
586 auto vSynchronizationGroup
587 = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
587 = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
588 auto vSyncIds = vSynchronizationGroup->getIds();
588 auto vSyncIds = vSynchronizationGroup->getIds();
589
589
590 auto varIds = std::list<QUuid>{};
590 auto varIds = std::list<QUuid>{};
591 for (auto vId : vSyncIds) {
591 for (auto vId : vSyncIds) {
592 varIds.push_back(vId);
592 varIds.push_back(vId);
593 }
593 }
594 qCDebug(LOG_VariableController()) << "onRequestDataLoading sync: for" << varRequestId
594 qCDebug(LOG_VariableController()) << "onRequestDataLoading sync: for" << varRequestId
595 << varIds.size();
595 << varIds.size();
596 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
596 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
597
597
598 for (auto vId : vSyncIds) {
598 for (auto vId : vSyncIds) {
599 auto var = impl->findVariable(vId);
599 auto var = impl->findVariable(vId);
600
600
601 // Don't process already processed var
601 // Don't process already processed var
602 if (var != nullptr) {
602 if (var != nullptr) {
603 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
603 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
604 << varRequestId;
604 << varRequestId;
605 auto vSyncRangeRequested
605 auto vSyncRangeRequested
606 = variables.contains(var)
606 = variables.contains(var)
607 ? range
607 ? range
608 : computeSynchroRangeRequested(var->range(), range,
608 : computeSynchroRangeRequested(var->range(), range,
609 variables.first()->range());
609 variables.first()->range());
610 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
610 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
611 impl->processRequest(var, vSyncRangeRequested, varRequestId);
611 impl->processRequest(var, vSyncRangeRequested, varRequestId);
612 }
612 }
613 else {
613 else {
614 qCCritical(LOG_VariableController())
614 qCCritical(LOG_VariableController())
615
615
616 << tr("Impossible to synchronize a null variable");
616 << tr("Impossible to synchronize a null variable");
617 }
617 }
618 }
618 }
619 }
619 }
620 }
620 }
621
621
622 impl->updateVariables(varRequestId);
622 impl->updateVariables(varRequestId);
623 }
623 }
624
624
625
625
626 void VariableController::initialize()
626 void VariableController::initialize()
627 {
627 {
628 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
628 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
629 impl->m_WorkingMutex.lock();
629 impl->m_WorkingMutex.lock();
630 qCDebug(LOG_VariableController()) << tr("VariableController init END");
630 qCDebug(LOG_VariableController()) << tr("VariableController init END");
631 }
631 }
632
632
633 void VariableController::finalize()
633 void VariableController::finalize()
634 {
634 {
635 impl->m_WorkingMutex.unlock();
635 impl->m_WorkingMutex.unlock();
636 }
636 }
637
637
638 void VariableController::waitForFinish()
638 void VariableController::waitForFinish()
639 {
639 {
640 QMutexLocker locker{&impl->m_WorkingMutex};
640 QMutexLocker locker{&impl->m_WorkingMutex};
641 }
641 }
642
642
643 AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
643 AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
644 {
644 {
645 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
645 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
646 auto zoomType = AcquisitionZoomType::Unknown;
646 auto zoomType = AcquisitionZoomType::Unknown;
647 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
647 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
648 qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
648 qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
649 zoomType = AcquisitionZoomType::ZoomOut;
649 zoomType = AcquisitionZoomType::ZoomOut;
650 }
650 }
651 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
651 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
652 qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
652 qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
653 zoomType = AcquisitionZoomType::PanRight;
653 zoomType = AcquisitionZoomType::PanRight;
654 }
654 }
655 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
655 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
656 qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
656 qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
657 zoomType = AcquisitionZoomType::PanLeft;
657 zoomType = AcquisitionZoomType::PanLeft;
658 }
658 }
659 else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
659 else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
660 qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
660 qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
661 zoomType = AcquisitionZoomType::ZoomIn;
661 zoomType = AcquisitionZoomType::ZoomIn;
662 }
662 }
663 else {
663 else {
664 qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
664 qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
665 }
665 }
666 return zoomType;
666 return zoomType;
667 }
667 }
668
668
669 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
669 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
670 const SqpRange &rangeRequested,
670 const SqpRange &rangeRequested,
671 QUuid varRequestId)
671 QUuid varRequestId)
672 {
672 {
673 auto itVar = m_VariableToIdentifierMap.find(var);
673 auto itVar = m_VariableToIdentifierMap.find(var);
674 if (itVar == m_VariableToIdentifierMap.cend()) {
674 if (itVar == m_VariableToIdentifierMap.cend()) {
675 qCCritical(LOG_VariableController())
675 qCCritical(LOG_VariableController())
676 << tr("Impossible to process request for unknown variable");
676 << tr("Impossible to process request for unknown variable");
677 return;
677 return;
678 }
678 }
679
679
680 auto varId = itVar->second;
680 auto varId = itVar->second;
681
681
682 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
682 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
683 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
683 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
684 qCCritical(LOG_VariableController())
684 qCCritical(LOG_VariableController())
685 << tr("Impossible to process request for variable with unknown handler");
685 << tr("Impossible to process request for variable with unknown handler");
686 return;
686 return;
687 }
687 }
688
688
689 auto oldRange = var->range();
689 auto oldRange = var->range();
690
690
691 auto varHandler = itVarHandler->second.get();
691 auto varHandler = itVarHandler->second.get();
692
692
693 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
693 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
694 oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
694 oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
695 }
695 }
696
696
697 auto varRequest = VariableRequest{};
697 auto varRequest = VariableRequest{};
698 varRequest.m_VariableGroupId = varRequestId;
698 varRequest.m_VariableGroupId = varRequestId;
699 auto varStrategyRangesRequested
699 auto varStrategyRangesRequested
700 = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
700 = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
701 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
701 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
702 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
702 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
703
703
704 switch (varHandler->m_State) {
704 switch (varHandler->m_State) {
705 case VariableRequestHandlerState::OFF: {
705 case VariableRequestHandlerState::OFF: {
706 qCDebug(LOG_VariableController()) << tr("Process Request OFF")
706 qCDebug(LOG_VariableController()) << tr("Process Request OFF")
707 << varRequest.m_RangeRequested
707 << varRequest.m_RangeRequested
708 << varRequest.m_CacheRangeRequested;
708 << varRequest.m_CacheRangeRequested;
709 varHandler->m_RunningVarRequest = varRequest;
709 varHandler->m_RunningVarRequest = varRequest;
710 varHandler->m_State = VariableRequestHandlerState::RUNNING;
710 varHandler->m_State = VariableRequestHandlerState::RUNNING;
711 executeVarRequest(var, varRequest);
711 executeVarRequest(var, varRequest);
712 break;
712 break;
713 }
713 }
714 case VariableRequestHandlerState::RUNNING: {
714 case VariableRequestHandlerState::RUNNING: {
715 qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
715 qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
716 << varRequest.m_RangeRequested
716 << varRequest.m_RangeRequested
717 << varRequest.m_CacheRangeRequested;
717 << varRequest.m_CacheRangeRequested;
718 varHandler->m_State = VariableRequestHandlerState::PENDING;
718 varHandler->m_State = VariableRequestHandlerState::PENDING;
719 varHandler->m_PendingVarRequest = varRequest;
719 varHandler->m_PendingVarRequest = varRequest;
720 break;
720 break;
721 }
721 }
722 case VariableRequestHandlerState::PENDING: {
722 case VariableRequestHandlerState::PENDING: {
723 qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
723 qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
724 << varRequest.m_RangeRequested
724 << varRequest.m_RangeRequested
725 << varRequest.m_CacheRangeRequested;
725 << varRequest.m_CacheRangeRequested;
726 auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
726 auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
727 cancelVariableRequest(variableGroupIdToCancel);
727 cancelVariableRequest(variableGroupIdToCancel);
728 // Cancel variable can make state downgrade
728 // Cancel variable can make state downgrade
729 varHandler->m_State = VariableRequestHandlerState::PENDING;
729 varHandler->m_State = VariableRequestHandlerState::PENDING;
730 varHandler->m_PendingVarRequest = varRequest;
730 varHandler->m_PendingVarRequest = varRequest;
731
731
732 break;
732 break;
733 }
733 }
734 default:
734 default:
735 qCCritical(LOG_VariableController())
735 qCCritical(LOG_VariableController())
736 << QObject::tr("Unknown VariableRequestHandlerState");
736 << QObject::tr("Unknown VariableRequestHandlerState");
737 }
737 }
738 }
738 }
739
739
740 std::shared_ptr<Variable>
740 std::shared_ptr<Variable>
741 VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
741 VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
742 {
742 {
743 std::shared_ptr<Variable> var;
743 std::shared_ptr<Variable> var;
744 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
744 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
745
745
746 auto end = m_VariableToIdentifierMap.cend();
746 auto end = m_VariableToIdentifierMap.cend();
747 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
747 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
748 if (it != end) {
748 if (it != end) {
749 var = it->first;
749 var = it->first;
750 }
750 }
751 else {
751 else {
752 qCCritical(LOG_VariableController())
752 qCCritical(LOG_VariableController())
753 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
753 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
754 }
754 }
755
755
756 return var;
756 return var;
757 }
757 }
758
758
759 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
759 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
760 const QVector<AcquisitionDataPacket> acqDataPacketVector)
760 const QVector<AcquisitionDataPacket> acqDataPacketVector)
761 {
761 {
762 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
762 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
763 << acqDataPacketVector.size();
763 << acqDataPacketVector.size();
764 std::shared_ptr<IDataSeries> dataSeries;
764 std::shared_ptr<IDataSeries> dataSeries;
765 if (!acqDataPacketVector.isEmpty()) {
765 if (!acqDataPacketVector.isEmpty()) {
766 dataSeries = acqDataPacketVector[0].m_DateSeries;
766 dataSeries = acqDataPacketVector[0].m_DateSeries;
767 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
767 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
768 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
768 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
769 }
769 }
770 }
770 }
771 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
771 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
772 << acqDataPacketVector.size();
772 << acqDataPacketVector.size();
773 return dataSeries;
773 return dataSeries;
774 }
774 }
775
775
776 void VariableController::VariableControllerPrivate::registerProvider(
776 void VariableController::VariableControllerPrivate::registerProvider(
777 std::shared_ptr<IDataProvider> provider)
777 std::shared_ptr<IDataProvider> provider)
778 {
778 {
779 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
779 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
780 qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
780 qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
781 << provider->objectName();
781 << provider->objectName();
782 m_ProviderSet.insert(provider);
782 m_ProviderSet.insert(provider);
783 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
783 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
784 &VariableAcquisitionWorker::onVariableDataAcquired);
784 &VariableAcquisitionWorker::onVariableDataAcquired);
785 connect(provider.get(), &IDataProvider::dataProvidedProgress,
785 connect(provider.get(), &IDataProvider::dataProvidedProgress,
786 m_VariableAcquisitionWorker.get(),
786 m_VariableAcquisitionWorker.get(),
787 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
787 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
788 connect(provider.get(), &IDataProvider::dataProvidedFailed,
788 connect(provider.get(), &IDataProvider::dataProvidedFailed,
789 m_VariableAcquisitionWorker.get(),
789 m_VariableAcquisitionWorker.get(),
790 &VariableAcquisitionWorker::onVariableAcquisitionFailed);
790 &VariableAcquisitionWorker::onVariableAcquisitionFailed);
791 }
791 }
792 else {
792 else {
793 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
793 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
794 }
794 }
795 }
795 }
796
796
797 QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
797 QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
798 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
798 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
799 {
799 {
800 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
800 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
801 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
801 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
802 return QUuid();
802 return QUuid();
803 }
803 }
804
804
805 auto varHandler = itVarHandler->second.get();
805 auto varHandler = itVarHandler->second.get();
806 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
806 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
807 qCCritical(LOG_VariableController())
807 qCCritical(LOG_VariableController())
808 << tr("acceptVariableRequest impossible on a variable with OFF state");
808 << tr("acceptVariableRequest impossible on a variable with OFF state");
809 }
809 }
810
810
811 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
811 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
812 varHandler->m_CanUpdate = true;
812 varHandler->m_CanUpdate = true;
813
813
814 // Element traitΓ©, on a dΓ©jΓ  toutes les donnΓ©es necessaires
814 // Element traitΓ©, on a dΓ©jΓ  toutes les donnΓ©es necessaires
815 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
815 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
816 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
816 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
817 << m_VarGroupIdToVarIds.size();
817 << m_VarGroupIdToVarIds.size();
818
818
819 return varHandler->m_RunningVarRequest.m_VariableGroupId;
819 return varHandler->m_RunningVarRequest.m_VariableGroupId;
820 }
820 }
821
821
822 void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
822 void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
823 {
823 {
824 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
824 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
825 << QThread::currentThread()->objectName() << varRequestId;
825 << QThread::currentThread()->objectName() << varRequestId;
826
826
827 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
827 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
828 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
828 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
829 qCWarning(LOG_VariableController())
829 qCWarning(LOG_VariableController())
830 << tr("Impossible to updateVariables of unknown variables") << varRequestId;
830 << tr("Impossible to updateVariables of unknown variables") << varRequestId;
831 return;
831 return;
832 }
832 }
833
833
834 auto &varIds = varGroupIdToVarIdsIt->second;
834 auto &varIds = varGroupIdToVarIdsIt->second;
835 auto varIdsEnd = varIds.end();
835 auto varIdsEnd = varIds.end();
836 bool processVariableUpdate = true;
836 bool processVariableUpdate = true;
837 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
837 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
838 ++varIdsIt) {
838 ++varIdsIt) {
839 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
839 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
840 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
840 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
841 processVariableUpdate &= itVarHandler->second->m_CanUpdate;
841 processVariableUpdate &= itVarHandler->second->m_CanUpdate;
842 }
842 }
843 }
843 }
844
844
845 if (processVariableUpdate) {
845 if (processVariableUpdate) {
846 for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
846 for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
847 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
847 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
848 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
848 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
849 if (auto var = findVariable(*varIdsIt)) {
849 if (auto var = findVariable(*varIdsIt)) {
850 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
850 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
851 var->setRange(varRequest.m_RangeRequested);
851 var->setRange(varRequest.m_RangeRequested);
852 var->setCacheRange(varRequest.m_CacheRangeRequested);
852 var->setCacheRange(varRequest.m_CacheRangeRequested);
853 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
853 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
854 << varRequest.m_RangeRequested
854 << varRequest.m_RangeRequested
855 << varRequest.m_CacheRangeRequested;
855 << varRequest.m_CacheRangeRequested;
856 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
856 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
857 << var->nbPoints()
857 << var->nbPoints()
858 << varRequest.m_DataSeries->nbPoints();
858 << varRequest.m_DataSeries->nbPoints();
859 var->mergeDataSeries(varRequest.m_DataSeries);
859 var->mergeDataSeries(varRequest.m_DataSeries);
860 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
860 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
861 << var->nbPoints();
861 << var->nbPoints();
862
862
863 emit var->updated();
863 emit var->updated();
864 }
864 }
865 else {
865 else {
866 qCCritical(LOG_VariableController())
866 qCCritical(LOG_VariableController())
867 << tr("Impossible to update data to a null variable");
867 << tr("Impossible to update data to a null variable");
868 }
868 }
869 }
869 }
870 }
870 }
871 updateVariableRequest(varRequestId);
871 updateVariableRequest(varRequestId);
872
872
873 // cleaning varRequestId
873 // cleaning varRequestId
874 qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
874 qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
875 m_VarGroupIdToVarIds.erase(varRequestId);
875 m_VarGroupIdToVarIds.erase(varRequestId);
876 if (m_VarGroupIdToVarIds.empty()) {
876 if (m_VarGroupIdToVarIds.empty()) {
877 emit q->acquisitionFinished();
877 emit q->acquisitionFinished();
878 }
878 }
879 }
879 }
880 }
880 }
881
881
882
882
883 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
883 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
884 {
884 {
885 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
885 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
886 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
886 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
887 qCCritical(LOG_VariableController()) << QObject::tr(
887 qCCritical(LOG_VariableController()) << QObject::tr(
888 "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
888 "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
889
889
890 return;
890 return;
891 }
891 }
892
892
893 auto &varIds = varGroupIdToVarIdsIt->second;
893 auto &varIds = varGroupIdToVarIdsIt->second;
894 auto varIdsEnd = varIds.end();
894 auto varIdsEnd = varIds.end();
895
895
896 // First pass all canUpdate of handler to false
896 // First pass all canUpdate of handler to false
897 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
897 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
898 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
898 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
899 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
899 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
900
900
901 auto varHandler = itVarHandler->second.get();
901 auto varHandler = itVarHandler->second.get();
902 varHandler->m_CanUpdate = false;
902 varHandler->m_CanUpdate = false;
903 }
903 }
904 }
904 }
905 // Second update requests of handler
905 // Second update requests of handler
906 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
906 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
907 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
907 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
908 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
908 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
909
909
910 auto varHandler = itVarHandler->second.get();
910 auto varHandler = itVarHandler->second.get();
911
911
912 switch (varHandler->m_State) {
912 switch (varHandler->m_State) {
913 case VariableRequestHandlerState::OFF: {
913 case VariableRequestHandlerState::OFF: {
914 qCCritical(LOG_VariableController())
914 qCCritical(LOG_VariableController())
915 << QObject::tr("Impossible to update a variable with handler in OFF state");
915 << QObject::tr("Impossible to update a variable with handler in OFF state");
916 } break;
916 } break;
917 case VariableRequestHandlerState::RUNNING: {
917 case VariableRequestHandlerState::RUNNING: {
918 varHandler->m_State = VariableRequestHandlerState::OFF;
918 varHandler->m_State = VariableRequestHandlerState::OFF;
919 varHandler->m_RunningVarRequest = VariableRequest{};
919 varHandler->m_RunningVarRequest = VariableRequest{};
920 break;
920 break;
921 }
921 }
922 case VariableRequestHandlerState::PENDING: {
922 case VariableRequestHandlerState::PENDING: {
923 varHandler->m_State = VariableRequestHandlerState::RUNNING;
923 varHandler->m_State = VariableRequestHandlerState::RUNNING;
924 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
924 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
925 varHandler->m_PendingVarRequest = VariableRequest{};
925 varHandler->m_PendingVarRequest = VariableRequest{};
926 auto var = findVariable(itVarHandler->first);
926 auto var = findVariable(itVarHandler->first);
927 executeVarRequest(var, varHandler->m_RunningVarRequest);
927 executeVarRequest(var, varHandler->m_RunningVarRequest);
928 updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
928 updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
929 break;
929 break;
930 }
930 }
931 default:
931 default:
932 qCCritical(LOG_VariableController())
932 qCCritical(LOG_VariableController())
933 << QObject::tr("Unknown VariableRequestHandlerState");
933 << QObject::tr("Unknown VariableRequestHandlerState");
934 }
934 }
935 }
935 }
936 }
936 }
937 }
937 }
938
938
939
939
940 void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
940 void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
941 {
941 {
942 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
942 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
943
943
944 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
944 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
945 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
945 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
946 qCCritical(LOG_VariableController())
946 qCCritical(LOG_VariableController())
947 << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
947 << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
948 return;
948 return;
949 }
949 }
950
950
951 auto &varIds = varGroupIdToVarIdsIt->second;
951 auto &varIds = varGroupIdToVarIdsIt->second;
952 auto varIdsEnd = varIds.end();
952 auto varIdsEnd = varIds.end();
953
954 // First pass all canUpdate of handler to false
955 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
956 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
957 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
958
959 auto varHandler = itVarHandler->second.get();
960 varHandler->m_CanUpdate = false;
961 }
962 }
963
953 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
964 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
954 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
965 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
955 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
966 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
956
967
957 auto varHandler = itVarHandler->second.get();
968 auto varHandler = itVarHandler->second.get();
958 varHandler->m_VarId = QUuid{};
969 varHandler->m_VarId = QUuid{};
959 switch (varHandler->m_State) {
970 switch (varHandler->m_State) {
960 case VariableRequestHandlerState::OFF: {
971 case VariableRequestHandlerState::OFF: {
961 qCWarning(LOG_VariableController())
972 qCWarning(LOG_VariableController())
962 << QObject::tr("Impossible to cancel a variable with no running request");
973 << QObject::tr("Impossible to cancel a variable with no running request");
963 break;
974 break;
964 }
975 }
965 case VariableRequestHandlerState::RUNNING: {
976 case VariableRequestHandlerState::RUNNING: {
966
977
967 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
978 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
968 auto var = findVariable(itVarHandler->first);
979 auto var = findVariable(itVarHandler->first);
969 auto varProvider = m_VariableToProviderMap.at(var);
980 auto varProvider = m_VariableToProviderMap.at(var);
970 if (varProvider != nullptr) {
981 if (varProvider != nullptr) {
971 m_VariableAcquisitionWorker->abortProgressRequested(
982 m_VariableAcquisitionWorker->abortProgressRequested(
972 itVarHandler->first);
983 itVarHandler->first);
973 }
984 }
974 m_VariableModel->setDataProgress(var, 0.0);
985 m_VariableModel->setDataProgress(var, 0.0);
975 varHandler->m_CanUpdate = false;
976 varHandler->m_State = VariableRequestHandlerState::OFF;
986 varHandler->m_State = VariableRequestHandlerState::OFF;
977 varHandler->m_RunningVarRequest = VariableRequest{};
987 varHandler->m_RunningVarRequest = VariableRequest{};
978 }
988 }
979 else {
989 else {
980 // TODO: log Impossible to cancel the running variable request beacause its
990 // TODO: log Impossible to cancel the running variable request beacause its
981 // varRequestId isn't not the canceled one
991 // varRequestId isn't not the canceled one
982 }
992 }
983 break;
993 break;
984 }
994 }
985 case VariableRequestHandlerState::PENDING: {
995 case VariableRequestHandlerState::PENDING: {
986 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
996 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
987 auto var = findVariable(itVarHandler->first);
997 auto var = findVariable(itVarHandler->first);
988 auto varProvider = m_VariableToProviderMap.at(var);
998 auto varProvider = m_VariableToProviderMap.at(var);
989 if (varProvider != nullptr) {
999 if (varProvider != nullptr) {
990 m_VariableAcquisitionWorker->abortProgressRequested(
1000 m_VariableAcquisitionWorker->abortProgressRequested(
991 itVarHandler->first);
1001 itVarHandler->first);
992 }
1002 }
993 m_VariableModel->setDataProgress(var, 0.0);
1003 m_VariableModel->setDataProgress(var, 0.0);
994 varHandler->m_CanUpdate = false;
995 varHandler->m_State = VariableRequestHandlerState::RUNNING;
1004 varHandler->m_State = VariableRequestHandlerState::RUNNING;
996 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
1005 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
997 varHandler->m_PendingVarRequest = VariableRequest{};
1006 varHandler->m_PendingVarRequest = VariableRequest{};
998 executeVarRequest(var, varHandler->m_RunningVarRequest);
1007 executeVarRequest(var, varHandler->m_RunningVarRequest);
999 }
1008 }
1000 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
1009 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
1001 varHandler->m_State = VariableRequestHandlerState::RUNNING;
1010 varHandler->m_State = VariableRequestHandlerState::RUNNING;
1002 varHandler->m_PendingVarRequest = VariableRequest{};
1011 varHandler->m_PendingVarRequest = VariableRequest{};
1003 }
1012 }
1004 else {
1013 else {
1005 // TODO: log Impossible to cancel the variable request beacause its
1014 // TODO: log Impossible to cancel the variable request beacause its
1006 // varRequestId isn't not the canceled one
1015 // varRequestId isn't not the canceled one
1007 }
1016 }
1008 break;
1017 break;
1009 }
1018 }
1010 default:
1019 default:
1011 qCCritical(LOG_VariableController())
1020 qCCritical(LOG_VariableController())
1012 << QObject::tr("Unknown VariableRequestHandlerState");
1021 << QObject::tr("Unknown VariableRequestHandlerState");
1013 }
1022 }
1014 }
1023 }
1015 }
1024 }
1016 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
1025 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
1017 m_VarGroupIdToVarIds.erase(varRequestId);
1026 m_VarGroupIdToVarIds.erase(varRequestId);
1018 if (m_VarGroupIdToVarIds.empty()) {
1027 if (m_VarGroupIdToVarIds.empty()) {
1019 emit q->acquisitionFinished();
1028 emit q->acquisitionFinished();
1020 }
1029 }
1021 }
1030 }
1022
1031
1023 void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
1032 void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
1024 VariableRequest &varRequest)
1033 VariableRequest &varRequest)
1025 {
1034 {
1026 auto varIdIt = m_VariableToIdentifierMap.find(var);
1035 auto varIdIt = m_VariableToIdentifierMap.find(var);
1027 if (varIdIt == m_VariableToIdentifierMap.cend()) {
1036 if (varIdIt == m_VariableToIdentifierMap.cend()) {
1028 qCWarning(LOG_VariableController()) << tr(
1037 qCWarning(LOG_VariableController()) << tr(
1029 "Can't execute request of a variable that is not registered (may has been deleted)");
1038 "Can't execute request of a variable that is not registered (may has been deleted)");
1030 return;
1039 return;
1031 }
1040 }
1032
1041
1033 auto varId = varIdIt->second;
1042 auto varId = varIdIt->second;
1034
1043
1035 auto varCacheRange = var->cacheRange();
1044 auto varCacheRange = var->cacheRange();
1036 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
1045 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
1037 auto notInCacheRangeList
1046 auto notInCacheRangeList
1038 = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
1047 = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
1039 auto inCacheRangeList
1048 auto inCacheRangeList
1040 = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
1049 = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
1041
1050
1042 if (!notInCacheRangeList.empty()) {
1051 if (!notInCacheRangeList.empty()) {
1043
1052
1044 auto varProvider = m_VariableToProviderMap.at(var);
1053 auto varProvider = m_VariableToProviderMap.at(var);
1045 if (varProvider != nullptr) {
1054 if (varProvider != nullptr) {
1046 qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
1055 qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
1047 << varRequest.m_CacheRangeRequested;
1056 << varRequest.m_CacheRangeRequested;
1048 m_VariableAcquisitionWorker->pushVariableRequest(
1057 m_VariableAcquisitionWorker->pushVariableRequest(
1049 varRequest.m_VariableGroupId, varId,
1058 varRequest.m_VariableGroupId, varId,
1050 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
1059 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
1051 varProvider);
1060 varProvider);
1052 }
1061 }
1053 else {
1062 else {
1054 qCCritical(LOG_VariableController())
1063 qCCritical(LOG_VariableController())
1055 << "Impossible to provide data with a null provider";
1064 << "Impossible to provide data with a null provider";
1056 }
1065 }
1057
1066
1058 if (!inCacheRangeList.empty()) {
1067 if (!inCacheRangeList.empty()) {
1059 emit q->updateVarDisplaying(var, inCacheRangeList.first());
1068 emit q->updateVarDisplaying(var, inCacheRangeList.first());
1060 }
1069 }
1061 }
1070 }
1062 else {
1071 else {
1063 qCDebug(LOG_VariableController()) << "All already in the cache "
1072 qCDebug(LOG_VariableController()) << "All already in the cache "
1064 << varRequest.m_RangeRequested;
1073 << varRequest.m_RangeRequested;
1065 acceptVariableRequest(varId,
1074 acceptVariableRequest(varId,
1066 var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
1075 var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
1067 }
1076 }
1068 }
1077 }
1069
1078
1070 template <typename VariableIterator>
1079 template <typename VariableIterator>
1071 void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
1080 void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
1072 const QUuid &syncGroupId)
1081 const QUuid &syncGroupId)
1073 {
1082 {
1074 const auto &variable = variableIt->first;
1083 const auto &variable = variableIt->first;
1075 const auto &variableId = variableIt->second;
1084 const auto &variableId = variableIt->second;
1076
1085
1077 // Gets synchronization group
1086 // Gets synchronization group
1078 auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
1087 auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
1079 if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
1088 if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
1080 qCCritical(LOG_VariableController())
1089 qCCritical(LOG_VariableController())
1081 << tr("Can't desynchronize variable %1: unknown synchronization group")
1090 << tr("Can't desynchronize variable %1: unknown synchronization group")
1082 .arg(variable->name());
1091 .arg(variable->name());
1083 return;
1092 return;
1084 }
1093 }
1085
1094
1086 // Removes variable from synchronization group
1095 // Removes variable from synchronization group
1087 auto synchronizationGroup = groupIt->second;
1096 auto synchronizationGroup = groupIt->second;
1088 synchronizationGroup->removeVariableId(variableId);
1097 synchronizationGroup->removeVariableId(variableId);
1089
1098
1090 // Removes link between variable and synchronization group
1099 // Removes link between variable and synchronization group
1091 m_VariableIdGroupIdMap.erase(variableId);
1100 m_VariableIdGroupIdMap.erase(variableId);
1092 }
1101 }
General Comments 0
You need to be logged in to leave comments. Login now