HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r758:87c4dffdd5b8

Fix progression bug when aborting a request for Amda plugin

perrinel -

r758:87c4dffdd5b8

parent child

Context file:

r758:87c4dffdd5b8

core/src/Variable/VariableAcquisitionWorker.cpp +7 -28

             #include "Variable/VariableAcquisitionWorker.h"
             #include "Variable/Variable.h"
             #include <Data/AcquisitionRequest.h>
             #include <Data/SqpRange.h>
             #include <unordered_map>
             #include <utility>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
             struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
                 explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
                         : m_Lock{QReadWriteLock::Recursive}, q{parent}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 void removeVariableRequest(QUuid vIdentifier);
                 /// Remove the current request and execute the next one if exist
                 void updateToNextRequest(QUuid vIdentifier);
                 QMutex m_WorkingMutex;
                 QReadWriteLock m_Lock;
                 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
                 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
                 std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
                 VariableAcquisitionWorker *q;
             };
             VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
             {
             }
             VariableAcquisitionWorker::~VariableAcquisitionWorker()
             {
                 qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
                                                         << QThread::currentThread();
                 this->waitForFinish();
             }
             QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
                                                                  SqpRange rangeRequested,
                                                                  SqpRange cacheRangeRequested,
                                                                  DataProviderParameters parameters,
                                                                  std::shared_ptr<IDataProvider> provider)
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
                     << tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;
                 auto varRequestIdCanceled = QUuid();
                 // Request creation
                 auto acqRequest = AcquisitionRequest{};
                 acqRequest.m_VarRequestId = varRequestId;
                 acqRequest.m_vIdentifier = vIdentifier;
                 acqRequest.m_DataProviderParameters = parameters;
                 acqRequest.m_RangeRequested = rangeRequested;
                 acqRequest.m_CacheRangeRequested = cacheRangeRequested;
                 acqRequest.m_Size = parameters.m_Times.size();
                 acqRequest.m_Provider = provider;
                 // Register request
                 impl->lockWrite();
                 impl->m_AcqIdentifierToAcqRequestMap.insert(
                     std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
                 auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                     // A current request already exists, we can replace the next one
                     auto nextAcqId = it->second.second;
                     auto acqIdentifierToAcqRequestMapIt = impl->m_AcqIdentifierToAcqRequestMap.find(nextAcqId);
                     if (acqIdentifierToAcqRequestMapIt != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                         auto request = acqIdentifierToAcqRequestMapIt->second;
                         varRequestIdCanceled = request.m_VarRequestId;
                     }
                     it->second.second = acqRequest.m_AcqIdentifier;
                     impl->unlock();
                 }
                 else {
                     // First request for the variable, it must be stored and executed
                     impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.insert(
                         std::make_pair(vIdentifier, std::make_pair(acqRequest.m_AcqIdentifier, QUuid())));
                     impl->unlock();
                     QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
                                               Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
                 }
                 return varRequestIdCanceled;
             }
             void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
             {
-                // TODO
                 impl->lockRead();
                 auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                     auto currentAcqId = it->second.first;
                     auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
                     if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                         auto request = it->second;
                         impl->unlock();
                         // Remove the current request from the worker
                         impl->lockWrite();
                         impl->updateToNextRequest(vIdentifier);
                         impl->unlock();
                         // notify the request aborting to the provider
                         request.m_Provider->requestDataAborting(currentAcqId);
                     }
                     else {
                         impl->unlock();
                         qCWarning(LOG_VariableAcquisitionWorker())
                             << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
                     }
                 }
                 else {
                     impl->unlock();
                 }
             }
             void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                              double progress)
             {
+                qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
+                                                         << acqIdentifier << progress;
                 impl->lockRead();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto currentPartSize = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
                     auto currentPartProgress
                         = std::isnan(progress) ? 0.0 : (progress * currentPartSize) / 100.0;
                     auto currentAlreadyProgress = aIdToARit->second.m_Progression * currentPartSize;
                     auto finalProgression = currentAlreadyProgress + currentPartProgress;
                     emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
+                    qCDebug(LOG_VariableAcquisitionWorker())
+                        << tr("TORM: onVariableRetrieveDataInProgress ") << aIdToARit->second.m_vIdentifier
+                        << currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;
                     if (finalProgression == 100.0) {
                         emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
                     }
                 }
                 impl->unlock();
             }
             void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                                    std::shared_ptr<IDataSeries> dataSeries,
                                                                    SqpRange dataRangeAcquired)
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
                                                          << acqIdentifier << dataRangeAcquired;
                 impl->lockWrite();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     // Store the result
                     auto dataPacket = AcquisitionDataPacket{};
                     dataPacket.m_Range = dataRangeAcquired;
                     dataPacket.m_DateSeries = dataSeries;
                     auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                     if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                         // A current request result already exists, we can update it
                         aIdToADPVit->second.push_back(dataPacket);
                     }
                     else {
                         // First request result for the variable, it must be stored
                         impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
                             std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
                     }
                     // Decrement the counter of the request
                     auto &acqRequest = aIdToARit->second;
                     acqRequest.m_Progression = acqRequest.m_Progression + 1;
                     // if the counter is 0, we can return data then run the next request if it exists and
                     // removed the finished request
                     if (acqRequest.m_Size == acqRequest.m_Progression) {
                         // Return the data
                         aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                         if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                             emit dataProvided(acqRequest.m_vIdentifier, acqRequest.m_RangeRequested,
                                               acqRequest.m_CacheRangeRequested, aIdToADPVit->second);
                         }
-                        // Execute the next one
+                        // Update to the next request
-                        auto it
+                        impl->updateToNextRequest(acqRequest.m_vIdentifier);
-                            = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(acqRequest.m_vIdentifier);
-                        if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
-                            if (it->second.second.isNull()) {
-                                // There is no next request, we can remove the variable request
-                                impl->removeVariableRequest(acqRequest.m_vIdentifier);
-                            else {
-                                auto acqIdentifierToRemove = it->second.first;
-                                // Move the next request to the current request
-                                it->second.first = it->second.second;
-                                it->second.second = QUuid();
-                                // Remove AcquisitionRequest and results;
-                                impl->m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
-                                impl->m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
-                                // Execute the current request
-                                QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
-                                                          Q_ARG(QUuid, it->second.first));
-                        else {
-                            qCCritical(LOG_VariableAcquisitionWorker())
-                                << tr("Impossible to execute the acquisition on an unfound variable ");
                     }
                 }
                 else {
                     qCWarning(LOG_VariableAcquisitionWorker())
                         << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
                 }
                 impl->unlock();
             }
             void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
                 impl->lockRead();
                 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto request = it->second;
                     impl->unlock();
                     emit variableRequestInProgress(request.m_vIdentifier, 0.1);
                     request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
                 }
                 else {
                     impl->unlock();
                     // TODO log no acqIdentifier recognized
                 }
             }
             void VariableAcquisitionWorker::initialize()
             {
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
                                                          << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
             }
             void VariableAcquisitionWorker::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableAcquisitionWorker::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
                 QUuid vIdentifier)
             {
                 lockWrite();
                 auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                 if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                     // A current request already exists, we can replace the next one
                     m_AcqIdentifierToAcqRequestMap.erase(it->second.first);
                     m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.first);
                     m_AcqIdentifierToAcqRequestMap.erase(it->second.second);
                     m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.second);
                 }
                 m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
                 unlock();
             }
             void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
                 QUuid vIdentifier)
             {
                 auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                 if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                     if (it->second.second.isNull()) {
                         // There is no next request, we can remove the variable request
                         removeVariableRequest(vIdentifier);
                     }
                     else {
                         auto acqIdentifierToRemove = it->second.first;
                         // Move the next request to the current request
                         it->second.first = it->second.second;
                         it->second.second = QUuid();
                         // Remove AcquisitionRequest and results;
                         m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
                         m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
                         // Execute the current request
                         QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
                                                   Q_ARG(QUuid, it->second.first));
                     }
                 }
                 else {
                     qCCritical(LOG_VariableAcquisitionWorker())
                         << tr("Impossible to execute the acquisition on an unfound variable ");
                 }
             }

plugins/amda/src/AmdaProvider.cpp +14 -5

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: start date
             /// - %2: end date
             /// - %3: parameter id
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://amda.irap.omp.eu/php/rest/"
                 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             AmdaResultParser::ValueType valueType(const QString &valueType)
             {
                 if (valueType == QStringLiteral("scalar")) {
                     return AmdaResultParser::ValueType::SCALAR;
                 }
                 else if (valueType == QStringLiteral("vector")) {
                     return AmdaResultParser::ValueType::VECTOR;
                 }
                 else {
                     return AmdaResultParser::ValueType::UNKNOWN;
                 }
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(),
                             SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
                             this,
                             SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                 }
             }
             std::shared_ptr<IDataProvider> AmdaProvider::clone() const
             {
                 // No copy is made in the clone
                 return std::make_shared<AmdaProvider>();
             }
             void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     this->retrieveData(acqIdentifier, dateTime, data);
                     // TORM when AMDA will support quick asynchrone request
                     QThread::msleep(1000);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
                                                        std::shared_ptr<QNetworkRequest> networkRequest,
                                                        double progress)
             {
-                qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
+                qCInfo(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
-                                            << networkRequest.get() << progress;
+                                           << networkRequest.get() << progress;
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto requestPtr = networkRequest;
                     auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapEnd = requestProgressMap.end();
                     auto requestProgressMapIt
                         = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
                     if (requestProgressMapIt != requestProgressMapEnd) {
                         requestProgressMapIt->second = progress;
                     }
                     else {
-                        qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress")
+                        // This case can happened when a progression is send after the request has been
-                                                       << acqIdentifier << networkRequest.get() << progress;
+                        // finished.
+                        // Generaly the case when aborting a request
+                        qCWarning(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress")
+                                                      << acqIdentifier << networkRequest.get() << progress;
                     }
                 }
                 acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     double finalProgress = 0.0;
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto fraq = requestProgressMap.size();
                     for (auto requestProgress : requestProgressMap) {
                         finalProgress += requestProgress.second;
                         qCDebug(LOG_AmdaProvider()) << tr("current final progress without freq:")
                                                     << finalProgress << requestProgress.second;
                     }
                     if (fraq > 0) {
                         finalProgress = finalProgress / fraq;
                     }
                     qCDebug(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress final progress") << fraq
                                                 << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
-                    emit dataProvidedProgress(acqIdentifier, 0.0);
+                    // This case can happened when a progression is send after the request has been finished.
+                    // Generaly the case when aborting a request
+                    emit dataProvidedProgress(acqIdentifier, 100.0);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 // Retrieves the data type that determines whether the expected format for the result file is
                 // scalar, vector...
                 auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                 qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished = [this, dateTime, tempFile,
                                              productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                     // Don't do anything if the reply was abort
                     if (reply->error() != QNetworkReply::OperationCanceledError) {
                         if (tempFile) {
                             auto replyReadAll = reply->readAll();
                             if (!replyReadAll.isEmpty()) {
                                 tempFile->write(replyReadAll);
                             }
                             tempFile->close();
                             // Parse results file
                             if (auto dataSeries
                                 = AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {
                                 emit dataProvided(dataId, dataSeries, dateTime);
                             }
                             else {
                                 /// @todo ALX : debug
                             }
                         }
+                        qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
+                                                    << dataId;
                         m_AcqIdToRequestProgressMap.erase(dataId);
                     }
                 };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() != QNetworkReply::OperationCanceledError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                               qCDebug(LOG_AmdaProvider())
                                   << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request and store the request for progression
                                   auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                   updateRequestProgress(dataId, request, 0.0);
                                   emit requestConstructed(request, dataId, httpDownloadFinished);
                               }
                           }
                           else {
+                              qCDebug(LOG_AmdaProvider())
+                                  << tr("acquisition requests erase because of aborting") << dataId;
                               m_AcqIdToRequestProgressMap.erase(dataId);
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
                 qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
                 emit requestConstructed(request, token, httpFinishedLambda);
             }
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                      std::shared_ptr<QNetworkRequest> request, double progress)
             {
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapIt = requestProgressMap.find(request);
                     if (requestProgressMapIt != requestProgressMap.end()) {
                         requestProgressMapIt->second = progress;
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
                                                     << acqIdentifier << request.get() << progress;
                     }
                     else {
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
                                                     << request.get() << progress;
                         acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                     }
                 }
                 else {
                     qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
                                                 << acqIdentifier << request.get() << progress;
                     auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                     requestProgressMap.insert(std::make_pair(request, progress));
                     m_AcqIdToRequestProgressMap.insert(
                         std::make_pair(acqIdentifier, std::move(requestProgressMap)));
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

	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