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