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

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Implement cancel with the new kernel
perrinel -
r831:5c98f6d8205b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,969 +1,973
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 auto variables = QVector<std::shared_ptr<Variable> >{};
327 327
328 328 for (const auto &selectedRow : qAsConst(selectedRows)) {
329 329 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
330 330 variables << selectedVariable;
331 331
332 332 // notify that rescale operation has to be done
333 333 emit rangeChanged(selectedVariable, dateTime);
334 334 }
335 335 }
336 336
337 337 if (!variables.isEmpty()) {
338 338 this->onRequestDataLoading(variables, dateTime, true);
339 339 }
340 340 }
341 341
342 342 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
343 343 const SqpRange &cacheRangeRequested,
344 344 QVector<AcquisitionDataPacket> dataAcquired)
345 345 {
346 346 qCInfo(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
347 347 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
348 348 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
349 349 if (!varRequestId.isNull()) {
350 350 impl->updateVariables(varRequestId);
351 351 }
352 352 }
353 353
354 354 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
355 355 {
356 356 qCDebug(LOG_VariableController())
357 357 << "TORM: variableController::onVariableRetrieveDataInProgress"
358 358 << QThread::currentThread()->objectName() << progress;
359 359 if (auto var = impl->findVariable(identifier)) {
360 360 impl->m_VariableModel->setDataProgress(var, progress);
361 361 }
362 362 else {
363 363 qCCritical(LOG_VariableController())
364 364 << tr("Impossible to notify progression of a null variable");
365 365 }
366 366 }
367 367
368 368 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
369 369 {
370 // auto it = impl->m_VariableToIdentifierMap.find(variable);
371 // if (it != impl->m_VariableToIdentifierMap.cend()) {
372 // impl->m_VariableAcquisitionWorker->abortProgressRequested(it->second);
373
374 // QUuid varRequestId;
375 // auto varIdToVarRequestIdQueueMapIt =
376 // impl->m_VarIdToVarRequestIdQueueMap.find(it->second);
377 // if (varIdToVarRequestIdQueueMapIt != impl->m_VarIdToVarRequestIdQueueMap.cend()) {
378 // auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
379 // varRequestId = varRequestIdQueue.front();
380 // impl->cancelVariableRequest(varRequestId);
381
382 // // Finish the progression for the request
383 // impl->m_VariableModel->setDataProgress(variable, 0.0);
384 // }
385 // else {
386 // qCWarning(LOG_VariableController())
387 // << tr("Aborting progression of inexistant variable request detected !!!")
388 // << QThread::currentThread()->objectName();
389 // }
390 // }
391 // else {
392 // qCWarning(LOG_VariableController())
393 // << tr("Aborting progression of inexistant variable detected !!!")
394 // << QThread::currentThread()->objectName();
395 // }
370
371 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
372 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
373 qCCritical(LOG_VariableController())
374 << tr("Impossible to onAbortProgressRequested request for unknown variable");
375 return;
376 }
377
378 auto varId = itVar->second;
379
380 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
381 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
382 qCCritical(LOG_VariableController())
383 << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
384 return;
385 }
386
387 auto varHandler = itVarHandler->second.get();
388
389 // case where a variable has a running request
390 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
391 impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
392 }
396 393 }
397 394
398 395 void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
399 396 {
400 397 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
401 398 << QThread::currentThread()->objectName() << vIdentifier;
402 399
403 400 if (auto var = impl->findVariable(vIdentifier)) {
404 401 this->onAbortProgressRequested(var);
405 402 }
406 403 else {
407 404 qCCritical(LOG_VariableController())
408 405 << tr("Impossible to abort Acquisition Requestof a null variable");
409 406 }
410 407 }
411 408
412 409 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
413 410 {
414 411 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
415 412 << QThread::currentThread()->objectName()
416 413 << synchronizationGroupId;
417 414 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
418 415 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
419 416 std::make_pair(synchronizationGroupId, vSynchroGroup));
420 417 }
421 418
422 419 void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
423 420 {
424 421 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
425 422 }
426 423
427 424 void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
428 425 QUuid synchronizationGroupId)
429 426
430 427 {
431 428 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
432 429 << synchronizationGroupId;
433 430 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
434 431 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
435 432 auto groupIdToVSGIt
436 433 = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
437 434 if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
438 435 impl->m_VariableIdGroupIdMap.insert(
439 436 std::make_pair(varToVarIdIt->second, synchronizationGroupId));
440 437 groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
441 438 }
442 439 else {
443 440 qCCritical(LOG_VariableController())
444 441 << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
445 442 << variable->name();
446 443 }
447 444 }
448 445 else {
449 446 qCCritical(LOG_VariableController())
450 447 << tr("Impossible to synchronize a variable with no identifier") << variable->name();
451 448 }
452 449 }
453 450
454 451 void VariableController::desynchronize(std::shared_ptr<Variable> variable,
455 452 QUuid synchronizationGroupId)
456 453 {
457 454 // Gets variable id
458 455 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
459 456 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
460 457 qCCritical(LOG_VariableController())
461 458 << tr("Can't desynchronize variable %1: variable identifier not found")
462 459 .arg(variable->name());
463 460 return;
464 461 }
465 462
466 463 // Gets synchronization group
467 464 auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
468 465 if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
469 466 qCCritical(LOG_VariableController())
470 467 << tr("Can't desynchronize variable %1: unknown synchronization group")
471 468 .arg(variable->name());
472 469 return;
473 470 }
474 471
475 472 auto variableId = variableIt->second;
476 473
477 474 // Removes variable from synchronization group
478 475 auto synchronizationGroup = groupIt->second;
479 476 synchronizationGroup->removeVariableId(variableId);
480 477
481 478 // Removes link between variable and synchronization group
482 479 impl->m_VariableIdGroupIdMap.erase(variableId);
483 480 }
484 481
485 482 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
486 483 const SqpRange &range, bool synchronise)
487 484 {
488 485 // variables is assumed synchronized
489 486 // TODO: Asser variables synchronization
490 487 // we want to load data of the variable for the dateTime.
491 488 if (variables.isEmpty()) {
492 489 return;
493 490 }
494 491
495 492 auto varRequestId = QUuid::createUuid();
496 493 qCCritical(LOG_VariableController()) << "VariableController::onRequestDataLoading"
497 494 << QThread::currentThread()->objectName() << varRequestId
498 495 << range;
499 496
500 497 if (!synchronise) {
501 498 auto varIds = std::list<QUuid>{};
502 499 for (const auto &var : variables) {
503 500 auto vId = impl->m_VariableToIdentifierMap.at(var);
504 501 varIds.push_back(vId);
505 502 }
506 503 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
507 504 for (const auto &var : variables) {
508 505 qCInfo(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
509 506 << varIds.size();
510 507 impl->processRequest(var, range, varRequestId);
511 508 }
512 509 }
513 510 else {
514 511 auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
515 512 qCInfo(LOG_VariableController()) << "Var in synchro group 0" << vId;
516 513 auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
517 514 if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
518 515 auto groupId = varIdToGroupIdIt->second;
519 516
520 517 auto vSynchronizationGroup
521 518 = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
522 519 auto vSyncIds = vSynchronizationGroup->getIds();
523 520
524 521 qCInfo(LOG_VariableController()) << "Var in synchro group 1" << groupId;
525 522
526 523 auto varIds = std::list<QUuid>{};
527 524 for (auto vId : vSyncIds) {
528 525 varIds.push_back(vId);
529 526 }
530 527 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
531 528
532 529 for (auto vId : vSyncIds) {
533 530 auto var = impl->findVariable(vId);
534 531
535 532 // Don't process already processed var
536 533 if (var != nullptr) {
537 534 qCInfo(LOG_VariableController()) << "processRequest synchro for" << var->name()
538 535 << varRequestId;
539 536 auto vSyncRangeRequested
540 537 = variables.contains(var)
541 538 ? range
542 539 : computeSynchroRangeRequested(var->range(), range,
543 540 variables.first()->range());
544 541 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
545 542 impl->processRequest(var, vSyncRangeRequested, varRequestId);
546 543 }
547 544 else {
548 545 qCCritical(LOG_VariableController())
549 546
550 547 << tr("Impossible to synchronize a null variable");
551 548 }
552 549 }
553 550 }
554 551 }
555 552
556 553 impl->updateVariables(varRequestId);
557 554 }
558 555
559 556
560 557 void VariableController::initialize()
561 558 {
562 559 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
563 560 impl->m_WorkingMutex.lock();
564 561 qCDebug(LOG_VariableController()) << tr("VariableController init END");
565 562 }
566 563
567 564 void VariableController::finalize()
568 565 {
569 566 impl->m_WorkingMutex.unlock();
570 567 }
571 568
572 569 void VariableController::waitForFinish()
573 570 {
574 571 QMutexLocker locker{&impl->m_WorkingMutex};
575 572 }
576 573
577 574 AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
578 575 {
579 576 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
580 577 auto zoomType = AcquisitionZoomType::Unknown;
581 578 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
582 579 qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
583 580 zoomType = AcquisitionZoomType::ZoomOut;
584 581 }
585 582 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
586 583 qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
587 584 zoomType = AcquisitionZoomType::PanRight;
588 585 }
589 586 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
590 587 qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
591 588 zoomType = AcquisitionZoomType::PanLeft;
592 589 }
593 590 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
594 591 qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
595 592 zoomType = AcquisitionZoomType::ZoomIn;
596 593 }
597 594 else {
598 595 qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
599 596 }
600 597 return zoomType;
601 598 }
602 599
603 600 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
604 601 const SqpRange &rangeRequested,
605 602 QUuid varRequestId)
606 603 {
607 604 auto itVar = m_VariableToIdentifierMap.find(var);
608 605 if (itVar == m_VariableToIdentifierMap.cend()) {
609 606 qCCritical(LOG_VariableController())
610 607 << tr("Impossible to process request for unknown variable");
611 608 return;
612 609 }
613 610
614 611 auto varId = itVar->second;
615 612
616 613 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
617 614 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
618 615 qCCritical(LOG_VariableController())
619 616 << tr("Impossible to process request for variable with unknown handler");
620 617 return;
621 618 }
622 619
623 620 auto oldRange = var->range();
624 621
625 622 auto varHandler = itVarHandler->second.get();
626 623
627 624 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
628 625 oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
629 626 }
630 627
631 628 auto varRequest = VariableRequest{};
632 629 varRequest.m_VariableGroupId = varRequestId;
633 630 auto varStrategyRangesRequested
634 631 = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
635 632 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
636 633 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
637 634
638 635 switch (varHandler->m_State) {
639 636 case VariableRequestHandlerState::OFF: {
640 637 qCCritical(LOG_VariableController()) << tr("Process Request OFF")
641 638 << varRequest.m_RangeRequested
642 639 << varRequest.m_CacheRangeRequested;
643 640 varHandler->m_RunningVarRequest = varRequest;
644 641 varHandler->m_State = VariableRequestHandlerState::RUNNING;
645 642 executeVarRequest(var, varRequest);
646 643 break;
647 644 }
648 645 case VariableRequestHandlerState::RUNNING: {
649 646 qCCritical(LOG_VariableController()) << tr("Process Request RUNNING")
650 647 << varRequest.m_RangeRequested
651 648 << varRequest.m_CacheRangeRequested;
652 649 varHandler->m_State = VariableRequestHandlerState::PENDING;
653 650 varHandler->m_PendingVarRequest = varRequest;
654 651 break;
655 652 }
656 653 case VariableRequestHandlerState::PENDING: {
657 654 qCCritical(LOG_VariableController()) << tr("Process Request PENDING")
658 655 << varRequest.m_RangeRequested
659 656 << varRequest.m_CacheRangeRequested;
660 657 auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
661 658 varHandler->m_PendingVarRequest = varRequest;
662 659 cancelVariableRequest(variableGroupIdToCancel);
663 660
664 661 break;
665 662 }
666 663 default:
667 664 qCCritical(LOG_VariableController())
668 665 << QObject::tr("Unknown VariableRequestHandlerState");
669 666 }
670 667 }
671 668
672 669 std::shared_ptr<Variable>
673 670 VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
674 671 {
675 672 std::shared_ptr<Variable> var;
676 673 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
677 674
678 675 auto end = m_VariableToIdentifierMap.cend();
679 676 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
680 677 if (it != end) {
681 678 var = it->first;
682 679 }
683 680 else {
684 681 qCCritical(LOG_VariableController())
685 682 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
686 683 }
687 684
688 685 return var;
689 686 }
690 687
691 688 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
692 689 const QVector<AcquisitionDataPacket> acqDataPacketVector)
693 690 {
694 691 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
695 692 << acqDataPacketVector.size();
696 693 std::shared_ptr<IDataSeries> dataSeries;
697 694 if (!acqDataPacketVector.isEmpty()) {
698 695 dataSeries = acqDataPacketVector[0].m_DateSeries;
699 696 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
700 697 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
701 698 }
702 699 }
703 700 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
704 701 << acqDataPacketVector.size();
705 702 return dataSeries;
706 703 }
707 704
708 705 void VariableController::VariableControllerPrivate::registerProvider(
709 706 std::shared_ptr<IDataProvider> provider)
710 707 {
711 708 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
712 709 qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
713 710 << provider->objectName();
714 711 m_ProviderSet.insert(provider);
715 712 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
716 713 &VariableAcquisitionWorker::onVariableDataAcquired);
717 714 connect(provider.get(), &IDataProvider::dataProvidedProgress,
718 715 m_VariableAcquisitionWorker.get(),
719 716 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
720 717 connect(provider.get(), &IDataProvider::dataProvidedFailed,
721 718 m_VariableAcquisitionWorker.get(),
722 719 &VariableAcquisitionWorker::onVariableAcquisitionFailed);
723 720 }
724 721 else {
725 722 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
726 723 }
727 724 }
728 725
729 726 QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
730 727 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
731 728 {
732 729 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
733 730 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
734 731 return QUuid();
735 732 }
736 733
737 734 auto varHandler = itVarHandler->second.get();
738 735 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
739 736 // TODO log impossible case !!!
740 737 }
741 738
742 739 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
743 740 varHandler->m_CanUpdate = true;
744 741
745 742 // Element traitΓ©, on a dΓ©jΓ  toutes les donnΓ©es necessaires
746 743 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
747 744 qCInfo(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
748 745 << m_VarGroupIdToVarIds.size();
749 746
750 747 return varHandler->m_RunningVarRequest.m_VariableGroupId;
751 748 }
752 749
753 750 void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
754 751 {
755 752 qCInfo(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
756 753 << QThread::currentThread()->objectName() << varRequestId;
757 754
758 755 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
759 756 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
760 757 // TODO LOG cannot update since varGroupdId isn't here anymore
761 758 qCInfo(LOG_VariableController()) << "Impossible to updateVariables of unknown variables"
762 759 << varRequestId;
763 760 return;
764 761 }
765 762
766 763 auto &varIds = varGroupIdToVarIdsIt->second;
767 764 auto varIdsEnd = varIds.end();
768 765 bool processVariableUpdate = true;
769 766 qCInfo(LOG_VariableController())
770 767 << "VariableControllerPrivate::compute procss for group of size" << varIds.size();
771 768 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
772 769 ++varIdsIt) {
773 770 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
774 771 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
775 772 processVariableUpdate &= itVarHandler->second->m_CanUpdate;
776 773 }
777 774 }
778 775
779 776 if (processVariableUpdate) {
780 777 qCInfo(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
781 778 for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
782 779 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
783 780 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
784 781 if (auto var = findVariable(*varIdsIt)) {
785 782 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
786 783 var->setRange(varRequest.m_RangeRequested);
787 784 var->setCacheRange(varRequest.m_CacheRangeRequested);
788 785 qCInfo(LOG_VariableController()) << tr("1: onDataProvided")
789 786 << varRequest.m_RangeRequested
790 787 << varRequest.m_CacheRangeRequested;
791 788 qCInfo(LOG_VariableController()) << tr("2: onDataProvided var points before")
792 789 << var->nbPoints()
793 790 << varRequest.m_DataSeries->nbPoints();
794 791 var->mergeDataSeries(varRequest.m_DataSeries);
795 792 qCInfo(LOG_VariableController()) << tr("3: onDataProvided var points after")
796 793 << var->nbPoints();
797 794
798 795 emit var->updated();
799 796 qCCritical(LOG_VariableController()) << tr("Update OK");
800 797 }
801 798 else {
802 799 qCCritical(LOG_VariableController())
803 800 << tr("Impossible to update data to a null variable");
804 801 }
805 802 }
806 803 }
807 804 updateVariableRequest(varRequestId);
808 805
809 806 // cleaning varRequestId
810 807 qCInfo(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
811 808 m_VarGroupIdToVarIds.erase(varRequestId);
812 809 }
813 810 }
814 811
815 812
816 813 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
817 814 {
818 815 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
819 816 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
820 817 // TODO LOG cannot update variable request since varGroupdId isn't here anymore
821 818 return;
822 819 }
823 820
824 821 auto &varIds = varGroupIdToVarIdsIt->second;
825 822 auto varIdsEnd = varIds.end();
826 823 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
827 824 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
828 825 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
829 826
830 827 auto varHandler = itVarHandler->second.get();
831 828 varHandler->m_CanUpdate = false;
832 829
833 830
834 831 switch (varHandler->m_State) {
835 832 case VariableRequestHandlerState::OFF: {
836 833 qCCritical(LOG_VariableController())
837 834 << QObject::tr("Impossible to update a variable with handler in OFF state");
838 835 } break;
839 836 case VariableRequestHandlerState::RUNNING: {
840 837 varHandler->m_State = VariableRequestHandlerState::OFF;
841 838 varHandler->m_RunningVarRequest = VariableRequest{};
842 839 break;
843 840 }
844 841 case VariableRequestHandlerState::PENDING: {
845 842 varHandler->m_State = VariableRequestHandlerState::RUNNING;
846 843 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
847 844 varHandler->m_PendingVarRequest = VariableRequest{};
848 845 auto var = findVariable(itVarHandler->first);
849 846 executeVarRequest(var, varHandler->m_RunningVarRequest);
850 847 break;
851 848 }
852 849 default:
853 850 qCCritical(LOG_VariableController())
854 851 << QObject::tr("Unknown VariableRequestHandlerState");
855 852 }
856 853 }
857 854 }
858 855 }
859 856
860 857
861 858 void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
862 859 {
863 860 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
864 861 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
865 // TODO LOG cannot cancel variable request since varGroupdId isn't here anymore
862 qCCritical(LOG_VariableController())
863 << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
866 864 return;
867 865 }
868 866
869 867 auto &varIds = varGroupIdToVarIdsIt->second;
870 868 auto varIdsEnd = varIds.end();
871 869 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
872 870 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
873 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
871 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
874 872
875 873 auto varHandler = itVarHandler->second.get();
876 874 varHandler->m_CanUpdate = false;
877 875 varHandler->m_VarId = QUuid{};
878 876 switch (varHandler->m_State) {
879 877 case VariableRequestHandlerState::OFF: {
880 878 qCWarning(LOG_VariableController())
881 879 << QObject::tr("Impossible to cancel a variable with no running request");
882 880 break;
883 881 }
884 882 case VariableRequestHandlerState::RUNNING: {
885 883
886 884 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
887 885 auto var = findVariable(itVarHandler->first);
888 886 auto varProvider = m_VariableToProviderMap.at(var);
889 887 if (varProvider != nullptr) {
890 888 m_VariableAcquisitionWorker->abortProgressRequested(
891 889 itVarHandler->first);
892 890 }
891 m_VariableModel->setDataProgress(var, 0.0);
892 varHandler->m_State = VariableRequestHandlerState::OFF;
893 893 varHandler->m_RunningVarRequest = VariableRequest{};
894 894 }
895 895 else {
896 896 // TODO: log Impossible to cancel the running variable request beacause its
897 897 // varRequestId isn't not the canceled one
898 898 }
899 899 break;
900 900 }
901 901 case VariableRequestHandlerState::PENDING: {
902 902 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
903 903 auto var = findVariable(itVarHandler->first);
904 904 auto varProvider = m_VariableToProviderMap.at(var);
905 905 if (varProvider != nullptr) {
906 906 m_VariableAcquisitionWorker->abortProgressRequested(
907 907 itVarHandler->first);
908 908 }
909 m_VariableModel->setDataProgress(var, 0.0);
910 varHandler->m_State = VariableRequestHandlerState::RUNNING;
909 911 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
910 912 executeVarRequest(var, varHandler->m_RunningVarRequest);
911 913 }
912 914 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
915 varHandler->m_State = VariableRequestHandlerState::RUNNING;
913 916 varHandler->m_PendingVarRequest = VariableRequest{};
914 917 }
915 918 else {
916 919 // TODO: log Impossible to cancel the variable request beacause its
917 920 // varRequestId isn't not the canceled one
918 921 }
919 922 break;
920 923 }
921 924 default:
922 925 qCCritical(LOG_VariableController())
923 926 << QObject::tr("Unknown VariableRequestHandlerState");
924 927 }
925 928 }
926 929 }
930 m_VarGroupIdToVarIds.erase(varRequestId);
927 931 }
928 932
929 933 void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
930 934 VariableRequest &varRequest)
931 935 {
932 936 qCCritical(LOG_VariableController()) << tr("TORM: executeVarRequest");
933 937
934 938 auto varId = m_VariableToIdentifierMap.at(var);
935 939
936 940 auto varCacheRange = var->cacheRange();
937 941 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
938 942 auto notInCacheRangeList
939 943 = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
940 944 // auto inCacheRangeList
941 945 // = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
942 946
943 947 if (!notInCacheRangeList.empty()) {
944 948
945 949 auto varProvider = m_VariableToProviderMap.at(var);
946 950 if (varProvider != nullptr) {
947 951 qCCritical(LOG_VariableController()) << "executeVarRequest "
948 952 << varRequest.m_RangeRequested
949 953 << varRequest.m_CacheRangeRequested;
950 954 m_VariableAcquisitionWorker->pushVariableRequest(
951 955 varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
952 956 varRequest.m_CacheRangeRequested,
953 957 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
954 958 varProvider);
955 959 }
956 960 else {
957 961 qCCritical(LOG_VariableController())
958 962 << "Impossible to provide data with a null provider";
959 963 }
960 964
961 965 // if (!inCacheRangeList.empty()) {
962 966 // emit q->updateVarDisplaying(var, inCacheRangeList.first());
963 967 // }
964 968 }
965 969 else {
966 970 acceptVariableRequest(varId,
967 971 var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
968 972 }
969 973 }
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