##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

commit processRequest
Alexandre Leroux -
r682:d41b2e70981c
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,27
1 #ifndef SCIQLOP_ACQUISITIONUTILS_H
2 #define SCIQLOP_ACQUISITIONUTILS_H
3
4 #include "CoreGlobal.h"
5
6 #include <QLoggingCategory>
7
8 Q_DECLARE_LOGGING_CATEGORY(LOG_AcquisitionUtils)
9
10 class SqpRange;
11
12 /**
13 * Possible types of zoom operation
14 */
15 enum class AcquisitionZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
16
17 struct SCIQLOP_CORE_EXPORT AcquisitionUtils {
18 /**
19 * Returns the zoom operation which results from the two ranges passed in parameters
20 * @param range the range after operation
21 * @param oldRange the range before operation
22 * @return the operation type
23 */
24 static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
25 };
26
27 #endif // SCIQLOP_ACQUISITIONUTILS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,27
1 #include "Data/AcquisitionUtils.h"
2
3 #include "Data/SqpRange.h"
4
5 Q_LOGGING_CATEGORY(LOG_AcquisitionUtils, "AcquisitionUtils")
6
7 AcquisitionZoomType AcquisitionUtils::getZoomType(const SqpRange &range, const SqpRange &oldRange)
8 {
9 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
10 auto zoomType = AcquisitionZoomType::Unknown;
11 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
12 zoomType = AcquisitionZoomType::ZoomOut;
13 }
14 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
15 zoomType = AcquisitionZoomType::PanRight;
16 }
17 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
18 zoomType = AcquisitionZoomType::PanLeft;
19 }
20 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
21 zoomType = AcquisitionZoomType::ZoomIn;
22 }
23 else {
24 qCCritical(LOG_AcquisitionUtils()) << "getZoomType: Unknown type detected";
25 }
26 return zoomType;
27 }
Show file before | Show file after | Hide comments
@@ -41,13 +41,13 const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
41 41
42 42 int main(int argc, char *argv[])
43 43 {
44 QLoggingCategory::setFilterRules(
45 "*.warning=false\n"
46 "*.info=false\n"
47 "*.debug=false\n"
48 "AmdaProvider.info=true\n"
49 "NetworkController.info=true\n"
50 "VariableAcquisitionWorker.info=true\n");
44 // QLoggingCategory::setFilterRules(
45 // "*.warning=false\n"
46 // "*.info=false\n"
47 // "*.debug=false\n"
48 // "AmdaProvider.info=true\n"
49 // "NetworkController.info=true\n"
50 // "VariableAcquisitionWorker.info=true\n");
51 51
52 52 SqpApplication a{argc, argv};
53 53 SqpApplication::setOrganizationName("LPP");
Show file before | Show file after | Hide comments
@@ -15,12 +15,10
15 15 * @brief The VariableRequest struct holds the information of an acquisition request
16 16 */
17 17 struct VariableRequest {
18 VariableRequest() { m_CanUpdate = false; }
19
20 SqpRange m_RangeRequested;
21 SqpRange m_CacheRangeRequested;
22 std::shared_ptr<IDataSeries> m_DataSeries;
23 bool m_CanUpdate;
18 SqpRange m_RangeRequested{INVALID_RANGE};
19 SqpRange m_CacheRangeRequested{INVALID_RANGE};
20 std::shared_ptr<IDataSeries> m_DataSeries{nullptr};
21 bool m_CanUpdate{false};
24 22 };
25 23
26 24 SCIQLOP_REGISTER_META_TYPE(VARIABLEREQUEST_REGISTRY, VariableRequest)
Show file before | Show file after | Hide comments
@@ -20,13 +20,6 class VariableModel;
20 20
21 21 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
22 22
23
24 /**
25 * Possible types of zoom operation
26 */
27 enum class AcquisitionZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
28
29
30 23 /**
31 24 * @brief The VariableController class aims to handle the variables in SciQlop.
32 25 */
@@ -73,7 +66,6 public:
73 66 */
74 67 void abortProgress(std::shared_ptr<Variable> variable);
75 68
76 static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
77 69 signals:
78 70 /// Signal emitted when a variable is about to be deleted from the controller
79 71 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
Show file before | Show file after | Hide comments
@@ -21,6 +21,7 core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
21 21 core_sources = [
22 22 'src/Common/DateUtils.cpp',
23 23 'src/Common/StringUtils.cpp',
24 'src/Data/AcquisitionUtils.cpp',
24 25 'src/Data/ScalarSeries.cpp',
25 26 'src/Data/DataSeriesIterator.cpp',
26 27 'src/Data/ArrayDataIterator.cpp',
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (600 lines changed) Show them Hide them
@@ -5,6 +5,7
5 5 #include <Variable/VariableModel.h>
6 6 #include <Variable/VariableSynchronizationGroup.h>
7 7
8 #include <Data/AcquisitionUtils.h>
8 9 #include <Data/DataProviderParameters.h>
9 10 #include <Data/IDataProvider.h>
10 11 #include <Data/IDataSeries.h>
@@ -27,7 +28,7 namespace {
27 28 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
28 29 const SqpRange &oldGraphRange)
29 30 {
30 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
31 auto zoomType = AcquisitionUtils::getZoomType(graphRange, oldGraphRange);
31 32
32 33 auto varRangeRequested = varRange;
33 34 switch (zoomType) {
@@ -72,7 +73,7 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &
72 73
73 74 return varRangeRequested;
74 75 }
75 }
76 } // namespace
76 77
77 78 struct VariableController::VariableControllerPrivate {
78 79 explicit VariableControllerPrivate(VariableController *parent)
@@ -83,12 +84,10 struct VariableController::VariableControllerPrivate {
83 84 m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
84 85 q{parent}
85 86 {
86
87 87 m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
88 88 m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
89 89 }
90 90
91
92 91 virtual ~VariableControllerPrivate()
93 92 {
94 93 qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
@@ -96,52 +95,249 struct VariableController::VariableControllerPrivate {
96 95 m_VariableAcquisitionWorkerThread.wait();
97 96 }
98 97
98 void processRequest(std::shared_ptr<Variable> variable, const SqpRange &rangeRequested)
99 {
100 Q_ASSERT(variable != nullptr);
99 101
100 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
101 QUuid varRequestId);
102 if (!m_VariableModel->containsVariable(variable)) {
103 qCCritical(LOG_VariableController())
104 << QObject::tr("Can't process request for variable %1: variable is not registered")
105 .arg(variable->name());
106 return;
107 }
102 108
103 QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
104 const SqpRange &dateTime);
109 // Gets ranges in/out of variable range
110 auto requestRange
111 = m_VariableCacheStrategy->computeStrategyRanges(variable->range(), rangeRequested);
112 auto notInCacheRanges = variable->provideNotInCacheRangeList(requestRange.second);
113 auto inCacheRanges = variable->provideInCacheRangeList(requestRange.second);
114
115 // Creates request for out-of-cache ranges
116 if (!notInCacheRanges.isEmpty()) {
117 // Gets provider for request
118 if (auto provider = m_Providers.at(variable)) {
119 VariableRequest request{requestRange.first, requestRange.second};
120 // m_VariableAcquisitionWorker->pushVariableRequest();
121 }
122 }
105 123
106 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
124 // Calls UI update for in-cache range
125 if (!inCacheRanges.isEmpty()) {
126 emit q->updateVarDisplaying(variable, inCacheRanges.first());
127 }
128 }
129
130 std::shared_ptr<Variable> findVariable(QUuid vIdentifier)
131 {
132 /// @todo ALX
133 std::shared_ptr<Variable> var;
134 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
135
136 auto end = m_VariableToIdentifierMap.cend();
137 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
138 if (it != end) {
139 var = it->first;
140 }
141 else {
142 qCCritical(LOG_VariableController())
143 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
144 }
145
146 return var;
147 }
107 148 std::shared_ptr<IDataSeries>
108 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
149 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector)
150 {
151 /// @todo ALX
152 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
153 << acqDataPacketVector.size();
154 std::shared_ptr<IDataSeries> dataSeries;
155 if (!acqDataPacketVector.isEmpty()) {
156 dataSeries = acqDataPacketVector[0].m_DateSeries;
157 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
158 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
159 }
160 }
161 qCDebug(LOG_VariableController())
162 << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
163 << acqDataPacketVector.size();
164 return dataSeries;
165 }
109 166
110 void registerProvider(std::shared_ptr<IDataProvider> provider);
167 void registerProvider(std::shared_ptr<IDataProvider> provider)
168 {
169 Q_ASSERT(provider != nullptr);
170 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
171 &VariableAcquisitionWorker::onVariableDataAcquired);
172 connect(provider.get(), &IDataProvider::dataProvidedProgress,
173 m_VariableAcquisitionWorker.get(),
174 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
175 }
111 176
112 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
113 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
114 void updateVariableRequest(QUuid varRequestId);
115 void cancelVariableRequest(QUuid varRequestId);
177 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
178 {
179 /// @todo ALX
180 QUuid varRequestId;
181 // auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
182 // if (varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.cend()) {
183 // auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
184 // varRequestId = varRequestIdQueue.front();
185 // auto varRequestIdToVarIdVarRequestMapIt
186 // = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
187 // if (varRequestIdToVarIdVarRequestMapIt !=
188 // m_VarRequestIdToVarIdVarRequestMap.cend()) {
189 // auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
190 // auto varIdToVarRequestMapIt = varIdToVarRequestMap.find(varId);
191 // if (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) {
192 // qCDebug(LOG_VariableController()) << tr("acceptVariableRequest");
193 // auto &varRequest = varIdToVarRequestMapIt->second;
194 // varRequest.m_DataSeries = dataSeries;
195 // varRequest.m_CanUpdate = true;
196 // }
197 // else {
198 // qCDebug(LOG_VariableController()) << tr("Impossible to
199 // acceptVariableRequest "
200 // "of a unknown variable id
201 // attached "
202 // "to a variableRequestId")
203 // << varRequestId << varId;
204 // }
205 // }
206 // else {
207 // qCCritical(LOG_VariableController())
208 // << tr("Impossible to acceptVariableRequest of a unknown
209 // variableRequestId")
210 // << varRequestId;
211 // }
212
213 // qCDebug(LOG_VariableController())
214 // << tr("1: erase REQUEST in QUEUE ?") << varRequestIdQueue.size();
215 // varRequestIdQueue.pop_front();
216 // qCDebug(LOG_VariableController())
217 // << tr("2: erase REQUEST in QUEUE ?") << varRequestIdQueue.size();
218 // if (varRequestIdQueue.empty()) {
219 // m_VarIdToVarRequestIdQueueMap.erase(varId);
220 // }
221 // }
222 // else {
223 // qCCritical(LOG_VariableController())
224 // << tr("Impossible to acceptVariableRequest of a unknown variable id") <<
225 // varId;
226 // }
227
228 return varRequestId;
229 }
230 void updateVariableRequest(QUuid varRequestId)
231 {
232 /// @todo ALX
233 // auto varRequestIdToVarIdVarRequestMapIt
234 // = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
235 // if (varRequestIdToVarIdVarRequestMapIt !=
236 // m_VarRequestIdToVarIdVarRequestMap.cend()) {
237 // bool processVariableUpdate = true;
238 // auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
239 // for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
240 // (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) &&
241 // processVariableUpdate;
242 // ++varIdToVarRequestMapIt) {
243 // processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
244 // qCDebug(LOG_VariableController())
245 // << tr("updateVariableRequest") << processVariableUpdate;
246 // }
247
248 // if (processVariableUpdate) {
249 // for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
250 // varIdToVarRequestMapIt != varIdToVarRequestMap.cend();
251 // ++varIdToVarRequestMapIt) {
252 // if (auto var = findVariable(varIdToVarRequestMapIt->first)) {
253 // auto &varRequest = varIdToVarRequestMapIt->second;
254 // var->setRange(varRequest.m_RangeRequested);
255 // var->setCacheRange(varRequest.m_CacheRangeRequested);
256 // qCDebug(LOG_VariableController())
257 // << tr("1: onDataProvided") << varRequest.m_RangeRequested;
258 // qCDebug(LOG_VariableController())
259 // << tr("2: onDataProvided") <<
260 // varRequest.m_CacheRangeRequested;
261 // var->mergeDataSeries(varRequest.m_DataSeries);
262 // qCDebug(LOG_VariableController())
263 // << tr("3: onDataProvided") <<
264 // varRequest.m_DataSeries->range();
265 // qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
266
267 // /// @todo MPL: confirm
268 // // Variable update is notified only if there is no pending request
269 // for it
270 // if
271 // (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first)
272 // == 0) {
273 // emit var->updated();
274 // }
275 // }
276 // else {
277 // qCCritical(LOG_VariableController())
278 // << tr("Impossible to update data to a null variable");
279 // }
280 // }
281
282 // // cleaning varRequestId
283 // qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in MAP ?")
284 // <<
285 // m_VarRequestIdToVarIdVarRequestMap.size();
286 // m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
287 // qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in MAP ?")
288 // <<
289 // m_VarRequestIdToVarIdVarRequestMap.size();
290 // }
291 // }
292 // else {
293 // qCCritical(LOG_VariableController())
294 // << tr("Cannot updateVariableRequest for a unknow varRequestId") <<
295 // varRequestId;
296 // }
297 }
298
299 void cancelVariableRequest(QUuid varRequestId)
300 {
301 /// @todo ALX
302 // // cleaning varRequestId
303 // m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
304
305 // for (auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.begin();
306 // varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.end();) {
307 // auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
308 // varRequestIdQueue.erase(
309 // std::remove(varRequestIdQueue.begin(), varRequestIdQueue.end(),
310 // varRequestId),
311 // varRequestIdQueue.end());
312 // if (varRequestIdQueue.empty()) {
313 // varIdToVarRequestIdQueueMapIt
314 // = m_VarIdToVarRequestIdQueueMap.erase(varIdToVarRequestIdQueueMapIt);
315 // }
316 // else {
317 // ++varIdToVarRequestIdQueueMapIt;
318 // }
319 // }
320 }
116 321
117 322 QMutex m_WorkingMutex;
118 323 /// Variable model. The VariableController has the ownership
119 324 VariableModel *m_VariableModel;
120 325 QItemSelectionModel *m_VariableSelectionModel;
121 326
122
123 327 TimeController *m_TimeController{nullptr};
124 328 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
125 329 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
126 330 QThread m_VariableAcquisitionWorkerThread;
127 331
128 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
129 m_VariableToProviderMap;
332 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> > m_Providers;
130 333 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
131 334 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
132 335 m_GroupIdToVariableSynchronizationGroupMap;
133 336 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
134 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
135
136 std::map<QUuid, std::map<QUuid, VariableRequest> > m_VarRequestIdToVarIdVarRequestMap;
137
138 std::map<QUuid, std::deque<QUuid> > m_VarIdToVarRequestIdQueueMap;
139
140 337
141 338 VariableController *q;
142 339 };
143 340
144
145 341 VariableController::VariableController(QObject *parent)
146 342 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
147 343 {
@@ -202,10 +398,10 VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
202 398 impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
203 399
204 400 // Registers provider
205 auto variableProvider = impl->m_VariableToProviderMap.at(variable);
401 auto variableProvider = impl->m_Providers.at(variable);
206 402 auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
207 403
208 impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
404 impl->m_Providers[duplicate] = duplicateProvider;
209 405 if (duplicateProvider) {
210 406 impl->registerProvider(duplicateProvider);
211 407 }
@@ -235,7 +431,7 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noex
235 431 impl->m_VariableToIdentifierMap.erase(variable);
236 432
237 433 // Deletes provider
238 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
434 auto nbProvidersDeleted = impl->m_Providers.erase(variable);
239 435 qCDebug(LOG_VariableController())
240 436 << tr("Number of providers deleted for variable %1: %2")
241 437 .arg(variable->name(), QString::number(nbProvidersDeleted));
@@ -276,14 +472,12 VariableController::createVariable(const QString &name, const QVariantHash &meta
276 472 impl->registerProvider(provider);
277 473
278 474 // Associate the provider
279 impl->m_VariableToProviderMap[newVariable] = provider;
475 impl->m_Providers[newVariable] = provider;
280 476 impl->m_VariableToIdentifierMap[newVariable] = identifier;
281 477
282
283 auto varRequestId = QUuid::createUuid();
284 qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
285 impl->processRequest(newVariable, range, varRequestId);
286 impl->updateVariableRequest(varRequestId);
478 impl->processRequest(newVariable, range);
479 /// @todo ALX
480 // impl->updateVariableRequest(varRequestId);
287 481
288 482 return newVariable;
289 483 }
@@ -295,18 +489,18 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
295 489 qCDebug(LOG_VariableController())
296 490 << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
297 491 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
298 auto varRequestId = QUuid::createUuid();
299
300 492 for (const auto &selectedRow : qAsConst(selectedRows)) {
301 493 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
302 494 selectedVariable->setRange(dateTime);
303 impl->processRequest(selectedVariable, dateTime, varRequestId);
495 impl->processRequest(selectedVariable, dateTime);
304 496
305 497 // notify that rescale operation has to be done
306 498 emit rangeChanged(selectedVariable, dateTime);
307 499 }
308 500 }
309 impl->updateVariableRequest(varRequestId);
501
502 /// @todo ALX
503 // impl->updateVariableRequest(varRequestId);
310 504 }
311 505
312 506 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
@@ -334,18 +528,19 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, doub
334 528
335 529 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
336 530 {
337 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
338 << QThread::currentThread()->objectName();
531 /// @todo ALX
532 // qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
533 // << QThread::currentThread()->objectName();
339 534
340 auto it = impl->m_VariableToIdentifierMap.find(variable);
341 if (it != impl->m_VariableToIdentifierMap.cend()) {
342 impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
343 }
344 else {
345 qCWarning(LOG_VariableController())
346 << tr("Aborting progression of inexistant variable detected !!!")
347 << QThread::currentThread()->objectName();
348 }
535 // auto it = impl->m_VariableToIdentifierMap.find(variable);
536 // if (it != impl->m_VariableToIdentifierMap.cend()) {
537 // impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
538 // }
539 // else {
540 // qCWarning(LOG_VariableController())
541 // << tr("Aborting progression of inexistant variable detected !!!")
542 // << QThread::currentThread()->objectName();
543 // }
349 544 }
350 545
351 546 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
@@ -430,14 +625,8 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable>
430 625 // we want to load data of the variable for the dateTime.
431 626 // First we check if the cache contains some of them.
432 627 // For the other, we ask the provider to give them.
433
434 auto varRequestId = QUuid::createUuid();
435 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
436 << QThread::currentThread()->objectName() << varRequestId;
437
438 628 for (const auto &var : variables) {
439 qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId;
440 impl->processRequest(var, range, varRequestId);
629 impl->processRequest(var, range);
441 630 }
442 631
443 632 if (synchronise) {
@@ -478,7 +667,7 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable>
478 667 auto vSyncRangeRequested = computeSynchroRangeRequested(
479 668 var->range(), range, groupIdToOldRangeMap.at(gId));
480 669 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
481 impl->processRequest(var, vSyncRangeRequested, varRequestId);
670 impl->processRequest(var, vSyncRangeRequested);
482 671 }
483 672 else {
484 673 qCCritical(LOG_VariableController())
@@ -490,7 +679,8 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable>
490 679 }
491 680 }
492 681
493 impl->updateVariableRequest(varRequestId);
682 /// @todo ALX
683 // impl->updateVariableRequest(varRequestId);
494 684 }
495 685
496 686
@@ -510,297 +700,3 void VariableController::waitForFinish()
510 700 {
511 701 QMutexLocker locker{&impl->m_WorkingMutex};
512 702 }
513
514 AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
515 {
516 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
517 auto zoomType = AcquisitionZoomType::Unknown;
518 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
519 zoomType = AcquisitionZoomType::ZoomOut;
520 }
521 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
522 zoomType = AcquisitionZoomType::PanRight;
523 }
524 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
525 zoomType = AcquisitionZoomType::PanLeft;
526 }
527 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
528 zoomType = AcquisitionZoomType::ZoomIn;
529 }
530 else {
531 qCCritical(LOG_VariableController()) << "getZoomType: Unknown type detected";
532 }
533 return zoomType;
534 }
535
536 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
537 const SqpRange &rangeRequested,
538 QUuid varRequestId)
539 {
540
541 // TODO: protect at
542 auto varRequest = VariableRequest{};
543 auto varId = m_VariableToIdentifierMap.at(var);
544
545 auto varStrategyRangesRequested
546 = m_VariableCacheStrategy->computeStrategyRanges(var->range(), rangeRequested);
547 auto notInCacheRangeList = var->provideNotInCacheRangeList(varStrategyRangesRequested.second);
548 auto inCacheRangeList = var->provideInCacheRangeList(varStrategyRangesRequested.second);
549
550 if (!notInCacheRangeList.empty()) {
551 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
552 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
553 qCInfo(LOG_VariableController()) << tr("TORM processRequest RR ") << rangeRequested;
554 qCInfo(LOG_VariableController())
555 << tr("TORM processRequest R ") << varStrategyRangesRequested.first;
556 qCInfo(LOG_VariableController())
557 << tr("TORM processRequest CR ") << varStrategyRangesRequested.second;
558 // store VarRequest
559 storeVariableRequest(varId, varRequestId, varRequest);
560
561 auto varProvider = m_VariableToProviderMap.at(var);
562 if (varProvider != nullptr) {
563 auto varRequestIdCanceled = m_VariableAcquisitionWorker->pushVariableRequest(
564 varRequestId, varId, varStrategyRangesRequested.first,
565 varStrategyRangesRequested.second,
566 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
567 varProvider);
568
569 if (!varRequestIdCanceled.isNull()) {
570 qCInfo(LOG_VariableController())
571 << tr("varRequestIdCanceled: ") << varRequestIdCanceled;
572 cancelVariableRequest(varRequestIdCanceled);
573 }
574 }
575 else {
576 qCCritical(LOG_VariableController())
577 << "Impossible to provide data with a null provider";
578 }
579
580 if (!inCacheRangeList.empty()) {
581 emit q->updateVarDisplaying(var, inCacheRangeList.first());
582 }
583 }
584 else {
585
586 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
587 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
588 // store VarRequest
589 storeVariableRequest(varId, varRequestId, varRequest);
590 acceptVariableRequest(varId,
591 var->dataSeries()->subDataSeries(varStrategyRangesRequested.second));
592 }
593 }
594
595 std::shared_ptr<Variable>
596 VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
597 {
598 std::shared_ptr<Variable> var;
599 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
600
601 auto end = m_VariableToIdentifierMap.cend();
602 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
603 if (it != end) {
604 var = it->first;
605 }
606 else {
607 qCCritical(LOG_VariableController())
608 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
609 }
610
611 return var;
612 }
613
614 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
615 const QVector<AcquisitionDataPacket> acqDataPacketVector)
616 {
617 qCDebug(LOG_VariableController())
618 << tr("TORM: retrieveDataSeries acqDataPacketVector size") << acqDataPacketVector.size();
619 std::shared_ptr<IDataSeries> dataSeries;
620 if (!acqDataPacketVector.isEmpty()) {
621 dataSeries = acqDataPacketVector[0].m_DateSeries;
622 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
623 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
624 }
625 }
626 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
627 << acqDataPacketVector.size();
628 return dataSeries;
629 }
630
631 void VariableController::VariableControllerPrivate::registerProvider(
632 std::shared_ptr<IDataProvider> provider)
633 {
634 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
635 qCDebug(LOG_VariableController())
636 << tr("Registering of a new provider") << provider->objectName();
637 m_ProviderSet.insert(provider);
638 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
639 &VariableAcquisitionWorker::onVariableDataAcquired);
640 connect(provider.get(), &IDataProvider::dataProvidedProgress,
641 m_VariableAcquisitionWorker.get(),
642 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
643 }
644 else {
645 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
646 }
647 }
648
649 void VariableController::VariableControllerPrivate::storeVariableRequest(
650 QUuid varId, QUuid varRequestId, const VariableRequest &varRequest)
651 {
652 // First request for the variable. we can create an entry for it
653 auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
654 if (varIdToVarRequestIdQueueMapIt == m_VarIdToVarRequestIdQueueMap.cend()) {
655 auto varRequestIdQueue = std::deque<QUuid>{};
656 qCInfo(LOG_VariableController()) << tr("Store REQUEST in QUEUE");
657 varRequestIdQueue.push_back(varRequestId);
658 m_VarIdToVarRequestIdQueueMap.insert(std::make_pair(varId, std::move(varRequestIdQueue)));
659 }
660 else {
661 qCInfo(LOG_VariableController()) << tr("Store REQUEST in EXISTING QUEUE");
662 auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
663 varRequestIdQueue.push_back(varRequestId);
664 }
665
666 auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
667 if (varRequestIdToVarIdVarRequestMapIt == m_VarRequestIdToVarIdVarRequestMap.cend()) {
668 auto varIdToVarRequestMap = std::map<QUuid, VariableRequest>{};
669 varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
670 qCInfo(LOG_VariableController()) << tr("Store REQUESTID in MAP");
671 m_VarRequestIdToVarIdVarRequestMap.insert(
672 std::make_pair(varRequestId, std::move(varIdToVarRequestMap)));
673 }
674 else {
675 auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
676 qCInfo(LOG_VariableController()) << tr("Store REQUESTID in EXISTING MAP");
677 varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
678 }
679 }
680
681 QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
682 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
683 {
684 QUuid varRequestId;
685 auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
686 if (varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.cend()) {
687 auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
688 varRequestId = varRequestIdQueue.front();
689 auto varRequestIdToVarIdVarRequestMapIt
690 = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
691 if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
692 auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
693 auto varIdToVarRequestMapIt = varIdToVarRequestMap.find(varId);
694 if (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) {
695 qCDebug(LOG_VariableController()) << tr("acceptVariableRequest");
696 auto &varRequest = varIdToVarRequestMapIt->second;
697 varRequest.m_DataSeries = dataSeries;
698 varRequest.m_CanUpdate = true;
699 }
700 else {
701 qCDebug(LOG_VariableController())
702 << tr("Impossible to acceptVariableRequest of a unknown variable id attached "
703 "to a variableRequestId")
704 << varRequestId << varId;
705 }
706 }
707 else {
708 qCCritical(LOG_VariableController())
709 << tr("Impossible to acceptVariableRequest of a unknown variableRequestId")
710 << varRequestId;
711 }
712
713 qCDebug(LOG_VariableController())
714 << tr("1: erase REQUEST in QUEUE ?") << varRequestIdQueue.size();
715 varRequestIdQueue.pop_front();
716 qCDebug(LOG_VariableController())
717 << tr("2: erase REQUEST in QUEUE ?") << varRequestIdQueue.size();
718 if (varRequestIdQueue.empty()) {
719 m_VarIdToVarRequestIdQueueMap.erase(varId);
720 }
721 }
722 else {
723 qCCritical(LOG_VariableController())
724 << tr("Impossible to acceptVariableRequest of a unknown variable id") << varId;
725 }
726
727 return varRequestId;
728 }
729
730 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
731 {
732
733 auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
734 if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
735 bool processVariableUpdate = true;
736 auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
737 for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
738 (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
739 ++varIdToVarRequestMapIt) {
740 processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
741 qCDebug(LOG_VariableController())
742 << tr("updateVariableRequest") << processVariableUpdate;
743 }
744
745 if (processVariableUpdate) {
746 for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
747 varIdToVarRequestMapIt != varIdToVarRequestMap.cend(); ++varIdToVarRequestMapIt) {
748 if (auto var = findVariable(varIdToVarRequestMapIt->first)) {
749 auto &varRequest = varIdToVarRequestMapIt->second;
750 var->setRange(varRequest.m_RangeRequested);
751 var->setCacheRange(varRequest.m_CacheRangeRequested);
752 qCDebug(LOG_VariableController())
753 << tr("1: onDataProvided") << varRequest.m_RangeRequested;
754 qCDebug(LOG_VariableController())
755 << tr("2: onDataProvided") << varRequest.m_CacheRangeRequested;
756 var->mergeDataSeries(varRequest.m_DataSeries);
757 qCDebug(LOG_VariableController())
758 << tr("3: onDataProvided") << varRequest.m_DataSeries->range();
759 qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
760
761 /// @todo MPL: confirm
762 // Variable update is notified only if there is no pending request for it
763 if (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first) == 0) {
764 emit var->updated();
765 }
766 }
767 else {
768 qCCritical(LOG_VariableController())
769 << tr("Impossible to update data to a null variable");
770 }
771 }
772
773 // cleaning varRequestId
774 qCDebug(LOG_VariableController())
775 << tr("0: erase REQUEST in MAP ?") << m_VarRequestIdToVarIdVarRequestMap.size();
776 m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
777 qCDebug(LOG_VariableController())
778 << tr("1: erase REQUEST in MAP ?") << m_VarRequestIdToVarIdVarRequestMap.size();
779 }
780 }
781 else {
782 qCCritical(LOG_VariableController())
783 << tr("Cannot updateVariableRequest for a unknow varRequestId") << varRequestId;
784 }
785 }
786
787 void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
788 {
789 // cleaning varRequestId
790 m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
791
792 for (auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.begin();
793 varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.end();) {
794 auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
795 varRequestIdQueue.erase(
796 std::remove(varRequestIdQueue.begin(), varRequestIdQueue.end(), varRequestId),
797 varRequestIdQueue.end());
798 if (varRequestIdQueue.empty()) {
799 varIdToVarRequestIdQueueMapIt
800 = m_VarIdToVarRequestIdQueueMap.erase(varIdToVarRequestIdQueueMapIt);
801 }
802 else {
803 ++varIdToVarRequestIdQueueMapIt;
804 }
805 }
806 }
Show file before | Show file after | Hide comments
@@ -5,6 +5,7
5 5 #include "Visualization/VisualizationGraphWidget.h"
6 6 #include "ui_VisualizationZoneWidget.h"
7 7
8 #include <Data/AcquisitionUtils.h>
8 9 #include <Data/SqpRange.h>
9 10 #include <Variable/Variable.h>
10 11 #include <Variable/VariableController.h>
@@ -112,7 +113,7 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
112 113 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
113 114 const SqpRange &oldGraphRange) {
114 115
115 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
116 auto zoomType = AcquisitionUtils::getZoomType(graphRange, oldGraphRange);
116 117 auto frameLayout = ui->visualizationZoneFrame->layout();
117 118 for (auto i = 0; i < frameLayout->count(); ++i) {
118 119 auto graphChild
General Comments 0
You need to be logged in to leave comments. Login now