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

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

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

Auto status change to "Under Review"

Approved
perrinel
author
Comment #2316
Edit
Delete
|

Merge lasted acquisition developpement on main Sciqlop branch

You need to be logged in to leave comments. Login now