GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r702:7c5b3263c65b

Merge branch 'feature/ProgressAndCancel' into develop

perrinel -

r702:7c5b3263c65b

parent child

Context file:

r702:7c5b3263c65b

core/include/Data/AcquisitionRequest.h +2 0

                 {
                     m_AcqIdentifier = QUuid::createUuid();
                     m_Size = 0;
+                    m_Progression = 0;
                 }
                 QUuid m_VarRequestId;
                 SqpRange m_RangeRequested;
                 SqpRange m_CacheRangeRequested;
                 int m_Size;
+                int m_Progression;
                 std::shared_ptr<IDataProvider> m_Provider;
             };

core/include/Data/IDataProvider.h +1 -1

                  * @brief requestConstructed send a request for the data identified by acqIdentifier
                  * @callback is the methode call by the reply of the request when it is finished.
                  */
-                void requestConstructed(const QNetworkRequest &request, QUuid acqIdentifier,
+                void requestConstructed(std::shared_ptr<QNetworkRequest> request, QUuid acqIdentifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
             };

core/include/Network/NetworkController.h +7 -2

             #include <QObject>
             #include <QUuid>
+            #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             #include <functional>
             public slots:
                 /// Execute request and call callback when the reply is finished. Identifier is attached to the
                 /// callback
-                void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
+                void onProcessRequested(std::shared_ptr<QNetworkRequest> request, QUuid identifier,
                                         std::function<void(QNetworkReply *, QUuid)> callback);
                 /// Cancel the request of identifier
                 void onReplyCanceled(QUuid identifier);
             signals:
                 void replyFinished(QNetworkReply *reply, QUuid identifier);
-                void replyDownloadProgress(QUuid identifier, double progress);
+                void replyDownloadProgress(QUuid identifier, std::shared_ptr<QNetworkRequest> networkRequest,
+                                           double progress);
             private:
                 void waitForFinish();
                 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
             };
+            SCIQLOP_REGISTER_META_TYPE(NETWORKREQUEST_REGISTRY, std::shared_ptr<QNetworkRequest>)
             #endif // SCIQLOP_NETWORKCONTROLLER_H

core/include/Variable/Variable.h +1 -2

                 Q_OBJECT
             public:
-                explicit Variable(const QString &name, const SqpRange &dateTime,
+                explicit Variable(const QString &name, const QVariantHash &metadata = {});
-                                  const QVariantHash &metadata = {});
                 /// Copy ctor
                 explicit Variable(const Variable &other);

core/include/Variable/VariableController.h 0 -4

                  */
                 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
-                /**
-                 * @brief abort the variable retrieve data progression
-                 */
-                void abortProgress(std::shared_ptr<Variable> variable);
                 static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
             signals:

core/include/Variable/VariableModel.h +1 -2

                 /**
                  * Creates a new variable in the model
                  * @param name the name of the new variable
-                 * @param dateTime the dateTime of the new variable
                  * @param metadata the metadata associated to the new variable
                  * @return the pointer to the new variable
                  */
-                std::shared_ptr<Variable> createVariable(const QString &name, const SqpRange &dateTime,
+                std::shared_ptr<Variable> createVariable(const QString &name,
                                                          const QVariantHash &metadata) noexcept;
                 /**

core/src/Network/NetworkController.cpp +29 -22

                 QMutex m_WorkingMutex;
                 QReadWriteLock m_Lock;
-                std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
+                std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToId;
                 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
             };
             {
             }
-            void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
+            void NetworkController::onProcessRequested(std::shared_ptr<QNetworkRequest> request,
+                                                       QUuid identifier,
                                                        std::function<void(QNetworkReply *, QUuid)> callback)
             {
-                qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
+                qCDebug(LOG_NetworkController()) << tr("NetworkController onProcessRequested")
-                                                 << QThread::currentThread()->objectName();
+                                                 << QThread::currentThread()->objectName() << &request;
-                auto reply = impl->m_AccessManager->get(request);
+                auto reply = impl->m_AccessManager->get(*request);
                 // Store the couple reply id
                 impl->lockWrite();
-                impl->m_NetworkReplyToVariableId[reply] = identifier;
+                impl->m_NetworkReplyToId[reply] = identifier;
+                qCDebug(LOG_NetworkController()) << tr("Store for reply: ") << identifier;
                 impl->unlock();
-                auto onReplyFinished = [reply, this, identifier, callback]() {
+                auto onReplyFinished = [request, reply, this, identifier, callback]() {
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
-                                                     << QThread::currentThread() << reply;
+                                                     << QThread::currentThread() << request.get() << reply;
                     impl->lockRead();
-                    auto it = impl->m_NetworkReplyToVariableId.find(reply);
+                    auto it = impl->m_NetworkReplyToId.find(reply);
                     impl->unlock();
-                    if (it != impl->m_NetworkReplyToVariableId.cend()) {
+                    if (it != impl->m_NetworkReplyToId.cend()) {
                         impl->lockWrite();
-                        impl->m_NetworkReplyToVariableId.erase(reply);
+                        qCDebug(LOG_NetworkController()) << tr("Remove for reply: ")
+                                                         << impl->m_NetworkReplyToId[reply];
+                        impl->m_NetworkReplyToId.erase(reply);
                         impl->unlock();
                         // Deletes reply
                         callback(reply, identifier);
                         reply->deleteLater();
-                        emit this->replyDownloadProgress(identifier, 0);
                     }
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
                                                      << QThread::currentThread() << reply;
                 };
-                auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
+                auto onReplyProgress = [reply, request, this](qint64 bytesRead, qint64 totalBytes) {
+                    // NOTE: a totalbytes of 0 can happened when a request has been aborted
+                    if (totalBytes > 0) {
                         double progress = (bytesRead * 100.0) / totalBytes;
                         qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
-                                                     << QThread::currentThread() << reply;
+                                                         << QThread::currentThread() << request.get() << reply
+                                                         << bytesRead << totalBytes;
                         impl->lockRead();
-                    auto it = impl->m_NetworkReplyToVariableId.find(reply);
+                        auto it = impl->m_NetworkReplyToId.find(reply);
                         impl->unlock();
-                    if (it != impl->m_NetworkReplyToVariableId.cend()) {
+                        if (it != impl->m_NetworkReplyToId.cend()) {
-                        emit this->replyDownloadProgress(it->second, progress);
+                            emit this->replyDownloadProgress(it->second, request, progress);
                         }
                         qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
                                                          << QThread::currentThread() << reply;
+                    }
                 };
                 auto onReplyErrors = [this](QNetworkReply *reply, const QList<QSslError> &errors) {
                     qCCritical(LOG_NetworkController()) << tr("NetworkAcessManager errors: ") << errors;
                 };
             {
                 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
                 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
-                                                 << QThread::currentThread();
+                                                 << QThread::currentThread() << identifier;
                 impl->lockRead();
-                auto end = impl->m_NetworkReplyToVariableId.cend();
+                auto end = impl->m_NetworkReplyToId.cend();
-                auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
+                auto it = std::find_if(impl->m_NetworkReplyToId.cbegin(), end, findReply);
                 impl->unlock();
                 if (it != end) {
+                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled ABORT DONE")
+                                                     << QThread::currentThread() << identifier;
                     it->first->abort();
                 }
                 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")

core/src/Variable/Variable.cpp +15 -7

             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
-                explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
+                explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
-                                         const QVariantHash &metadata)
                         : m_Name{name},
-                          m_Range{dateTime},
+                          m_Range{INVALID_RANGE},
+                          m_CacheRange{INVALID_RANGE},
                           m_Metadata{metadata},
                           m_DataSeries{nullptr},
                           m_RealRange{INVALID_RANGE},
                 VariablePrivate(const VariablePrivate &other)
                         : m_Name{other.m_Name},
                           m_Range{other.m_Range},
+                          m_CacheRange{other.m_CacheRange},
                           m_Metadata{other.m_Metadata},
                           m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
                           m_RealRange{other.m_RealRange},
                         auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
                         auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
-                        m_RealRange = (minXAxisIt != end && maxXAxisIt != end)
+                        m_RealRange
+                            = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
                                   ? SqpRange{minXAxisIt->x(), maxXAxisIt->x()}
                                   : INVALID_RANGE;
                         m_DataSeries->unlock();
                 QReadWriteLock m_Lock;
             };
-            Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
+            Variable::Variable(const QString &name, const QVariantHash &metadata)
-                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
+                    : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)}
             {
             }
             QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
             {
                 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
                 auto notInCache = QVector<SqpRange>{};
+                if (impl->m_CacheRange != INVALID_RANGE) {
                     if (!this->cacheContains(range)) {
                         if (range.m_TEnd <= impl->m_CacheRange.m_TStart
                                                        << QThread::currentThread();
                         }
                     }
+                }
+                else {
+                    notInCache << range;
+                }
                 return notInCache;
             }
                 auto inCache = QVector<SqpRange>{};
+                if (impl->m_CacheRange != INVALID_RANGE) {
                     if (this->intersect(range)) {
                         if (range.m_TStart <= impl->m_CacheRange.m_TStart
                                                        << QThread::currentThread();
                         }
                     }
+                }
                 return inCache;
             }

core/src/Variable/VariableAcquisitionWorker.cpp +104 -42

@@ -12,11 +12,16
12	#include <QReadWriteLock>	12	#include <QReadWriteLock>
13	#include <QThread>	13	#include <QThread>
14		14
		15	#include <cmath>
		16
15	Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")	17	Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
16		18
17	struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {	19	struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
18		20
19	explicit VariableAcquisitionWorkerPrivate() : ~~m_Lock~~{~~QReadWriteLock~~::~~Recursive~~} {}	21	explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
		22	: m_Lock{QReadWriteLock::Recursive}, q{parent}
		23	{
		24	}
20		25
21	void lockRead() { m_Lock.lockForRead(); }	26	void lockRead() { m_Lock.lockForRead(); }
22	void lockWrite() { m_Lock.lockForWrite(); }	27	void lockWrite() { m_Lock.lockForWrite(); }
@@ -24,17 +29,21 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
24		29
25	void removeVariableRequest(QUuid vIdentifier);	30	void removeVariableRequest(QUuid vIdentifier);
26		31
		32	/// Remove the current request and execute the next one if exist
		33	void updateToNextRequest(QUuid vIdentifier);
		34
27	QMutex m_WorkingMutex;	35	QMutex m_WorkingMutex;
28	QReadWriteLock m_Lock;	36	QReadWriteLock m_Lock;
29		37
30	std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;	38	std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
31	std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;	39	std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
32	std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;	40	std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
		41	VariableAcquisitionWorker *q;
33	};	42	};
34		43
35		44
36	VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)	45	VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
37	: QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}	46	: QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
38	{	47	{
39	}	48	}
40		49
@@ -100,20 +109,68 QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid v
100		109
101	void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)	110	void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
102	{	111	{
103	// TODO	112	impl->lockRead();
		113
		114	auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
		115	if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
		116	auto currentAcqId = it->second.first;
		117
		118	auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
		119	if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
		120	auto request = it->second;
		121	impl->unlock();
		122
		123	// Remove the current request from the worker
		124
		125	impl->lockWrite();
		126	impl->updateToNextRequest(vIdentifier);
		127	impl->unlock();
		128
		129	// notify the request aborting to the provider
		130	request.m_Provider->requestDataAborting(currentAcqId);
		131	}
		132	else {
		133	impl->unlock();
		134	qCWarning(LOG_VariableAcquisitionWorker())
		135	<< tr("Impossible to abort an unknown acquisition request") << currentAcqId;
		136	}
		137	}
		138	else {
		139	impl->unlock();
		140	}
104	}	141	}
105		142
106	void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,	143	void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
107	double progress)	144	double progress)
108	{	145	{
109	// TODO	146	qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
		147	<< acqIdentifier << progress;
		148	impl->lockRead();
		149	auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
		150	if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
		151	auto currentPartSize = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
		152
		153	auto currentPartProgress
		154	= std::isnan(progress) ? 0.0 : (progress * currentPartSize) / 100.0;
		155	auto currentAlreadyProgress = aIdToARit->second.m_Progression * currentPartSize;
		156
		157	auto finalProgression = currentAlreadyProgress + currentPartProgress;
		158	emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
		159	qCDebug(LOG_VariableAcquisitionWorker())
		160	<< tr("TORM: onVariableRetrieveDataInProgress ") << aIdToARit->second.m_vIdentifier
		161	<< currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;
		162	if (finalProgression == 100.0) {
		163	emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
		164	}
		165	}
		166	impl->unlock();
110	}	167	}
111		168
112	void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,	169	void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
113	std::shared_ptr<IDataSeries> dataSeries,	170	std::shared_ptr<IDataSeries> dataSeries,
114	SqpRange dataRangeAcquired)	171	SqpRange dataRangeAcquired)
115	{	172	{
116	qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableDataAcquired on range ")	173	qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
117	<< acqIdentifier << dataRangeAcquired;	174	<< acqIdentifier << dataRangeAcquired;
118	impl->lockWrite();	175	impl->lockWrite();
119	auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);	176	auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
@@ -137,11 +194,11 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
137		194
138	// Decrement the counter of the request	195	// Decrement the counter of the request
139	auto &acqRequest = aIdToARit->second;	196	auto &acqRequest = aIdToARit->second;
140	acqRequest.m_~~Size~~ = acqRequest.m_~~Size~~ - 1;	197	acqRequest.m_Progression = acqRequest.m_Progression + 1;
141		198
142	// if the counter is 0, we can return data then run the next request if it exists and	199	// if the counter is 0, we can return data then run the next request if it exists and
143	// removed the finished request	200	// removed the finished request
144	if (acqRequest.m_Size == 0) {	201	if (acqRequest.m_Size == acqRequest.m_Progression) {
145	// Return the data	202	// Return the data
146	aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);	203	aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
147	if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {	204	if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
@@ -149,39 +206,32 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
149	acqRequest.m_CacheRangeRequested, aIdToADPVit->second);	206	acqRequest.m_CacheRangeRequested, aIdToADPVit->second);
150	}	207	}
151		208
152	// ~~Execute the next one~~	209	// Update to the next request
153	auto it	210	impl->updateToNextRequest(acqRequest.m_vIdentifier);
154	= impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(acqRequest.m_vIdentifier);
155
156	if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
157	if (it->second.second.isNull()) {
158	// There is no next request, we can remove the variable request
159	impl->removeVariableRequest(acqRequest.m_vIdentifier);
160	}
161	else {
162	auto acqIdentifierToRemove = it->second.first;
163	// Move the next request to the current request
164	it->second.first = it->second.second;
165	it->second.second = QUuid();
166	// Remove AcquisitionRequest and results;
167	impl->m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
168	impl->m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
169	// Execute the current request
170	QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
171	Q_ARG(QUuid, it->second.first));
172	}	211	}
173	}	212	}
174	else {	213	else {
175	qC~~Critical~~(LOG_VariableAcquisitionWorker())	214	qCWarning(LOG_VariableAcquisitionWorker())
176	<< tr("Impossible to ~~execute the acquisition on an unfound variable~~ ");	215	<< tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
177	}	216	}
		217	impl->unlock();
178	}	218	}
		219
		220	void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
		221	{
		222	qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
		223	impl->lockRead();
		224	auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
		225	if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
		226	auto request = it->second;
		227	impl->unlock();
		228	emit variableRequestInProgress(request.m_vIdentifier, 0.1);
		229	request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
179	}	230	}
180	else {	231	else {
181	qCCritical(LOG_VariableAcquisitionWorker())
182	<< tr("Impossible to retrieve AcquisitionRequest for the incoming data");
183	}
184	impl->unlock();	232	impl->unlock();
		233	// TODO log no acqIdentifier recognized
		234	}
185	}	235	}
186		236
187	void VariableAcquisitionWorker::initialize()	237	void VariableAcquisitionWorker::initialize()
@@ -221,18 +271,30 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariable
221	unlock();	271	unlock();
222	}	272	}
223		273
224	void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)	274	void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
		275	QUuid vIdentifier)
225	{	276	{
226	qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();	277	auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
227	impl->lockRead();	278	if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
228	auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);	279	if (it->second.second.isNull()) {
229	if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {	280	// There is no next request, we can remove the variable request
230	auto request = it->second;	281	removeVariableRequest(vIdentifier);
231	impl->unlock();
232	request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
233	}	282	}
234	else {	283	else {
235	impl->unlock();	284	auto acqIdentifierToRemove = it->second.first;
236	// TODO log no acqIdentifier recognized	285	// Move the next request to the current request
		286	it->second.first = it->second.second;
		287	it->second.second = QUuid();
		288	// Remove AcquisitionRequest and results;
		289	m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
		290	m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
		291	// Execute the current request
		292	QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
		293	Q_ARG(QUuid, it->second.first));
		294	}
		295	}
		296	else {
		297	qCCritical(LOG_VariableAcquisitionWorker())
		298	<< tr("Impossible to execute the acquisition on an unfound variable ");
237	}	299	}
238	}	300	}

core/src/Variable/VariableController.cpp +28 -20

                 }
             }
-            void VariableController::abortProgress(std::shared_ptr<Variable> variable)
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                std::shared_ptr<IDataProvider> provider) noexcept
                 auto range = impl->m_TimeController->dateTime();
-                if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
+                if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto identifier = QUuid::createUuid();
                     // store the provider
                     auto varRequestId = QUuid::createUuid();
-                    qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
                     impl->processRequest(newVariable, range, varRequestId);
                     impl->updateVariableRequest(varRequestId);
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
+                qCDebug(LOG_VariableController())
+                    << "TORM: variableController::onVariableRetrieveDataInProgress"
+                    << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
-                qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
-                                                  << QThread::currentThread()->objectName();
                 auto it = impl->m_VariableToIdentifierMap.find(variable);
                 if (it != impl->m_VariableToIdentifierMap.cend()) {
-                    impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
+                    impl->m_VariableAcquisitionWorker->abortProgressRequested(it->second);
+                    QUuid varRequestId;
+                    auto varIdToVarRequestIdQueueMapIt = impl->m_VarIdToVarRequestIdQueueMap.find(it->second);
+                    if (varIdToVarRequestIdQueueMapIt != impl->m_VarIdToVarRequestIdQueueMap.cend()) {
+                        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+                        varRequestId = varRequestIdQueue.front();
+                        impl->cancelVariableRequest(varRequestId);
+                        // Finish the progression for the request
+                        impl->m_VariableModel->setDataProgress(variable, 0.0);
+                    }
+                    else {
+                        qCWarning(LOG_VariableController())
+                            << tr("Aborting progression of inexistant variable request detected !!!")
+                            << QThread::currentThread()->objectName();
+                    }
                 }
                 else {
                     qCWarning(LOG_VariableController())
                 // For the other, we ask the provider to give them.
                 auto varRequestId = QUuid::createUuid();
-                qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 for (const auto &var : variables) {
                 if (!notInCacheRangeList.empty()) {
                     varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                     varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
-                    qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest RR ") << rangeRequested;
-                    qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest R  ")
-                                                             << varStrategyRangesRequested.first;
-                    qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest CR ")
-                                                             << varStrategyRangesRequested.second;
                     // store VarRequest
                     storeVariableRequest(varId, varRequestId, varRequest);
                             varProvider);
                         if (!varRequestIdCanceled.isNull()) {
-                            qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
+                            qCDebug(LOG_VariableAcquisitionWorker()) << tr("vsarRequestIdCanceled: ")
                                                                      << varRequestIdCanceled;
                             cancelVariableRequest(varRequestIdCanceled);
                         }
                     }
                 }
                 else {
                     varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                     varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                     // store VarRequest
                                 /// @todo MPL: confirm
                                 // Variable update is notified only if there is no pending request for it
-                                if (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first) == 0) {
+                                //                    if
+                                //                    (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first)
+                                //                    == 0) {
                                 emit var->updated();
+                                //                    }
                             }
                             else {
                                 qCCritical(LOG_VariableController())

core/src/Variable/VariableModel.cpp +1 -2

             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
-                                                                    const SqpRange &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
-                auto variable = std::make_shared<Variable>(name, dateTime, metadata);
+                auto variable = std::make_shared<Variable>(name, metadata);
                 addVariable(variable);
                 return variable;

core/tests/Data/TestTwoDimArrayData.cpp +2 -2

                                             << true << Container{{1., 2., 3., 4., 5.},
                                                                  {6., 7., 8., 9., 10.},
                                                                  {11., 12., 13., 14., 15.}};
-                QTest::newRow("invalidInput (invalid data size")
+                QTest::newRow("invalidInput (invalid data size") << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3}
-                    << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3} << false << Container{{}, {}, {}};
+                                                                 << false << Container{{}, {}, {}};
                 QTest::newRow("invalidInput (less than two components")
                     << flatten(Container{{1., 2., 3., 4., 5.}}) << false << Container{{}, {}, {}};
             }

core/tests/Variable/TestVariable.cpp +5 -2

                 auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
                 auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
                 auto sqpCR
                     = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
-                Variable var{"Var test", sqpR};
+                Variable var{"Var test"};
+                var.setRange(sqpR);
                 var.setCacheRange(sqpCR);
                 // 1: [ts,te] < varTS
                 auto sqpCR
                     = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
-                Variable var{"Var test", sqpR};
+                Variable var{"Var test"};
+                var.setRange(sqpR);
                 var.setCacheRange(sqpCR);
                 // 1: [ts,te] < varTS

core/tests/Variable/TestVariableCacheController.cpp +4 -2

                 auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
                 auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
-                auto var0 = std::make_shared<Variable>("", sqp0);
+                auto var0 = std::make_shared<Variable>("");
+                var0->setRange(sqp0);
                 variableCacheController.addDateTime(var0, sqp0);
                 variableCacheController.addDateTime(var0, sqp1);
                 auto sqp03 = SqpRange{DateUtils::secondsSinceEpoch(ts03), DateUtils::secondsSinceEpoch(te03)};
-                auto var0 = std::make_shared<Variable>("", sqp0);
+                auto var0 = std::make_shared<Variable>("");
+                var0->setRange(sqp0);
                 // First case: add the first interval to the variable :sqp0

gui/src/Visualization/qcustomplot.cpp +12 -15

               \see initializeParentPlot
             */
-            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
+            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
+            {
+                Q_UNUSED(parentPlot)
+            }
             /*! \internal
                 painter->setBrush(QBrush(basePen.color()));
                 QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
                 if (lowerEnding.style() != QCPLineEnding::esNone)
-                    lowerEnding.draw(painter,
+                    lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
-                                     QCPVector2D(baseLine.p1())
                                                   - baseLineVector.normalized() * lowerEnding.realLength()
                                                         * (lowerEnding.inverted() ? -1 : 1),
                                      -baseLineVector);
                 if (upperEnding.style() != QCPLineEnding::esNone)
-                    upperEnding.draw(painter,
+                    upperEnding.draw(painter, QCPVector2D(baseLine.p2())
-                                     QCPVector2D(baseLine.p2())
                                                   + baseLineVector.normalized() * upperEnding.realLength()
                                                         * (upperEnding.inverted() ? -1 : 1),
                                      baseLineVector);
                                         hue -= 1.0;
                                     if (useAlpha) {
                                         const QRgb rgb
-                                            = QColor::fromHsvF(hue,
+                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
-                                                               (1 - t) * lowHsv.saturationF()
                                                                         + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                     }
                                     else {
                                         mColorBuffer[i]
-                                            = QColor::fromHsvF(hue,
+                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
-                                                               (1 - t) * lowHsv.saturationF()
                                                                         + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                 switch (phase) {
                     case upMargins: {
                         if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop) {
-                            setMaximumSize(QWIDGETSIZE_MAX,
+                            setMaximumSize(QWIDGETSIZE_MAX, mBarWidth + mAxisRect.data()->margins().top()
-                                           mBarWidth + mAxisRect.data()->margins().top()
+                                                                + mAxisRect.data()->margins().bottom()
-                                               + mAxisRect.data()->margins().bottom() + margins().top()
+                                                                + margins().top() + margins().bottom());
-                                               + margins().bottom());
+                            setMinimumSize(0, mBarWidth + mAxisRect.data()->margins().top()
-                            setMinimumSize(0,
-                                           mBarWidth + mAxisRect.data()->margins().top()
                                                   + mAxisRect.data()->margins().bottom() + margins().top()
                                                   + margins().bottom());
                         }

plugins/amda/include/AmdaProvider.h +13 0

             #include <QLoggingCategory>
+            #include <map>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
             class QNetworkReply;
+            class QNetworkRequest;
             /**
              * @brief The AmdaProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
+                Q_OBJECT
             public:
                 explicit AmdaProvider();
                 std::shared_ptr<IDataProvider> clone() const override;
                 void requestDataAborting(QUuid acqIdentifier) override;
+            private slots:
+                void onReplyDownloadProgress(QUuid acqIdentifier,
+                                             std::shared_ptr<QNetworkRequest> networkRequest, double progress);
             private:
                 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
+                void updateRequestProgress(QUuid acqIdentifier, std::shared_ptr<QNetworkRequest> request,
+                                           double progress);
+                std::map<QUuid, std::map<std::shared_ptr<QNetworkRequest>, double> >
+                    m_AcqIdToRequestProgressMap;
             };
             #endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/src/AmdaProvider.cpp +112 -12

@@ -56,15 +56,17 AmdaProvider::AmdaProvider()
56	qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();	56	qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
57	if (auto app = sqpApp) {	57	if (auto app = sqpApp) {
58	auto &networkController = app->networkController();	58	auto &networkController = app->networkController();
59	connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,	59	connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
60	std::function<void(QNetworkReply *, QUuid)>)),	60	std::function<void(QNetworkReply *, QUuid)>)),
61	&networkController,	61	&networkController,
62	SLOT(onProcessRequested(QNetworkRequest, QUuid,	62	SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
63	std::function<void(QNetworkReply *, QUuid)>)));	63	std::function<void(QNetworkReply *, QUuid)>)));
64		64
65		65
66	connect(&sqpApp->networkController(), ~~SIGNAL~~(~~replyDownloadProgress~~(~~QUuid~~, ~~double)),~~ ~~this~~,	66	connect(&sqpApp->networkController(),
67	SIGNAL(~~dataProvide~~dProgress(QUuid, double)));	67	SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
		68	this,
		69	SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
68	}	70	}
69	}	71	}
70		72
@@ -82,6 +84,7 void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderPar
82	for (const auto &dateTime : qAsConst(times)) {	84	for (const auto &dateTime : qAsConst(times)) {
83	this->retrieveData(acqIdentifier, dateTime, data);	85	this->retrieveData(acqIdentifier, dateTime, data);
84		86
		87
85	// TORM when AMDA will support quick asynchrone request	88	// TORM when AMDA will support quick asynchrone request
86	QThread::msleep(1000);	89	QThread::msleep(1000);
87	}	90	}
@@ -95,6 +98,63 void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
95	}	98	}
96	}	99	}
97		100
		101	void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
		102	std::shared_ptr<QNetworkRequest> networkRequest,
		103	double progress)
		104	{
		105	qCInfo(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
		106	<< networkRequest.get() << progress;
		107	auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
		108	if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
		109
		110	auto requestPtr = networkRequest;
		111	auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
		112
		113	auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
		114	auto requestProgressMapEnd = requestProgressMap.end();
		115	auto requestProgressMapIt
		116	= std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
		117
		118	if (requestProgressMapIt != requestProgressMapEnd) {
		119	requestProgressMapIt->second = progress;
		120	}
		121	else {
		122	// This case can happened when a progression is send after the request has been
		123	// finished.
		124	// Generaly the case when aborting a request
		125	qCWarning(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress")
		126	<< acqIdentifier << networkRequest.get() << progress;
		127	}
		128	}
		129
		130	acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
		131	if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
		132	double finalProgress = 0.0;
		133
		134	auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
		135	auto fraq = requestProgressMap.size();
		136
		137	for (auto requestProgress : requestProgressMap) {
		138	finalProgress += requestProgress.second;
		139	qCDebug(LOG_AmdaProvider()) << tr("current final progress without freq:")
		140	<< finalProgress << requestProgress.second;
		141	}
		142
		143	if (fraq > 0) {
		144	finalProgress = finalProgress / fraq;
		145	}
		146
		147	qCDebug(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress final progress") << fraq
		148	<< finalProgress;
		149	emit dataProvidedProgress(acqIdentifier, finalProgress);
		150	}
		151	else {
		152	// This case can happened when a progression is send after the request has been finished.
		153	// Generaly the case when aborting a request
		154	emit dataProvidedProgress(acqIdentifier, 100.0);
		155	}
		156	}
		157
98	void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)	158	void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
99	{	159	{
100	// Retrieves product ID from data: if the value is invalid, no request is made	160	// Retrieves product ID from data: if the value is invalid, no request is made
@@ -103,7 +163,6 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
103	qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");	163	qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
104	return;	164	return;
105	}	165	}
106	qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
107		166
108	// Retrieves the data type that determines whether the expected format for the result file is	167	// Retrieves the data type that determines whether the expected format for the result file is
109	// scalar, vector...	168	// scalar, vector...
@@ -117,7 +176,7 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
117	auto endDate = dateFormat(dateTime.m_TEnd);	176	auto endDate = dateFormat(dateTime.m_TEnd);
118		177
119	auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};	178	auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
120	qC~~Info~~(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;	179	qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
121	auto tempFile = std::make_shared<QTemporaryFile>();	180	auto tempFile = std::make_shared<QTemporaryFile>();
122		181
123	// LAMBDA	182	// LAMBDA
@@ -143,6 +202,9 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
143	/// @todo ALX : debug	202	/// @todo ALX : debug
144	}	203	}
145	}	204	}
		205	qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
		206	<< dataId;
		207	m_AcqIdToRequestProgressMap.erase(dataId);
146	}	208	}
147		209
148	};	210	};
@@ -153,22 +215,60 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
153	if (reply->error() != QNetworkReply::OperationCanceledError) {	215	if (reply->error() != QNetworkReply::OperationCanceledError) {
154	auto downloadFileUrl = QUrl{QString{reply->readAll()}};	216	auto downloadFileUrl = QUrl{QString{reply->readAll()}};
155		217
156		218	qCDebug(LOG_AmdaProvider())
157	qCInfo(LOG_AmdaProvider())
158	<< tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;	219	<< tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
159	// Executes request for downloading file //	220	// Executes request for downloading file //
160		221
161	// Creates destination file	222	// Creates destination file
162	if (tempFile->open()) {	223	if (tempFile->open()) {
163	// Executes request	224	// Executes request and store the request for progression
164	~~emit~~ request~~Constructed~~(~~QNetworkRequest~~{downloadFileUrl}, ~~dataId~~,	225	auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
165	httpDownloadFinished);	226	updateRequestProgress(dataId, request, 0.0);
		227	emit requestConstructed(request, dataId, httpDownloadFinished);
166	}	228	}
167	}	229	}
		230	else {
		231	qCDebug(LOG_AmdaProvider())
		232	<< tr("acquisition requests erase because of aborting") << dataId;
		233	m_AcqIdToRequestProgressMap.erase(dataId);
		234	}
168	};	235	};
169		236
170	// //////////////// //	237	// //////////////// //
171	// Executes request //	238	// Executes request //
172	// //////////////// //	239	// //////////////// //
173	emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);	240
		241	auto request = std::make_shared<QNetworkRequest>(url);
		242	qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
		243	updateRequestProgress(token, request, 0.0);
		244
		245	emit requestConstructed(request, token, httpFinishedLambda);
		246	}
		247
		248	void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
		249	std::shared_ptr<QNetworkRequest> request, double progress)
		250	{
		251	auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
		252	if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
		253	auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
		254	auto requestProgressMapIt = requestProgressMap.find(request);
		255	if (requestProgressMapIt != requestProgressMap.end()) {
		256	requestProgressMapIt->second = progress;
		257	qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
		258	<< acqIdentifier << request.get() << progress;
		259	}
		260	else {
		261	qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
		262	<< request.get() << progress;
		263	acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
		264	}
		265	}
		266	else {
		267	qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
		268	<< acqIdentifier << request.get() << progress;
		269	auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
		270	requestProgressMap.insert(std::make_pair(request, progress));
		271	m_AcqIdToRequestProgressMap.insert(
		272	std::make_pair(acqIdentifier, std::move(requestProgressMap)));
		273	}
174	}	274	}

plugins/amda/tests/TestAmdaAcquisition.cpp 0 -2

                 auto var = vc.createVariable("bx_gse", metaData, provider);
                 // 1 : Variable creation
-                QCOMPARE(var->range().m_TStart, sqpR.m_TStart);
-                QCOMPARE(var->range().m_TEnd, sqpR.m_TEnd);
                 qDebug() << " 1: TIMECONTROLLER" << timeController->dateTime();
                 qDebug() << " 1: RANGE     " << var->range();

plugins/mockplugin/src/CosinusProvider.cpp +7 -2

                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
+                            qCInfo(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
+                                                          << QThread::currentThread()->objectName() << progress;
+                            // NOTE: Try to use multithread if possible
                         }
                     }
                     else {
                         }
                     }
                 }
-                emit dataProvidedProgress(acqIdentifier, 0.0);
+                if (progress != 100) {
+                    // We can close progression beacause all data has been retrieved
+                    emit dataProvidedProgress(acqIdentifier, 100);
+                }
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }

General Comments 2

perrinel

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 2 added
  * 0 removed

Changed files:
  * A core/include/Variable/VariableAcquisitionWorker.h
  * M core/include/Data/IDataProvider.h
  * M core/include/Variable/VariableController.h
  * M core/src/Network/NetworkController.cpp
  * M core/src/Variable/VariableAcquisitionWorker.cpp
  * M core/src/Variable/VariableController.cpp
  * M plugins/amda/src/AmdaProvider.cpp

Write
Preview

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

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages