GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Files · core/src/Variable/VariableAcquisitionWorker.cpp

Fixes data loss in some cases of data recovery from the CosiunusProvider

perrinel - - Load All Authors

File last commit:

r761:ff170594501a


                r764:6fa5f5facdaa

Download file

             VariableAcquisitionWorker.cpp
        
                    322 lines
            
             | 12.7 KiB
            
                | text/x-c
            
             |
                CppLexer
            
             / core / src / Variable / VariableAcquisitionWorker.cpp
          
                    History
                
                 |
                  Source
                 | Raw
                 |Copy content
                 |Copy permalink

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      #include "Variable/VariableAcquisitionWorker.h"

      #include "Variable/Variable.h"

        perrinel
    
Implementation of V5 acquisition

              r539
            
      #include <Data/AcquisitionRequest.h>

      #include <Data/SqpRange.h>

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      #include <unordered_map>

        perrinel
    
Implementation of V5 acquisition

              r539
            
      #include <utility>

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
        perrinel
    
Implementation of V5 acquisition

              r539
            
      #include <QMutex>

      #include <QReadWriteLock>

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      #include <QThread>

        perrinel
    
Implementation of V5 acquisition

              r539
            
        perrinel
    
Implementation of progression

              r750
            
      #include <cmath>

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")

      struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {

        perrinel
    
Implementation of abort mechanism

              r754
            
          explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)

                  : m_Lock{QReadWriteLock::Recursive}, q{parent}

          {

          }

        perrinel
    
Implementation of V5 acquisition

              r539
            
          void lockRead() { m_Lock.lockForRead(); }

          void lockWrite() { m_Lock.lockForWrite(); }

          void unlock() { m_Lock.unlock(); }

          void removeVariableRequest(QUuid vIdentifier);

        perrinel
    
Implementation of abort mechanism

              r754
            
          /// Remove the current request and execute the next one if exist

          void updateToNextRequest(QUuid vIdentifier);

        perrinel
    
Implementation of V5 acquisition

              r539
            
          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;

        perrinel
    
Implementation of abort mechanism

              r754
            
          VariableAcquisitionWorker *q;

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      };

      VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)

        perrinel
    
Implementation of abort mechanism

              r754
            
              : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      {

      }

        perrinel
    
Implementation of V5 acquisition

              r539
            
      VariableAcquisitionWorker::~VariableAcquisitionWorker()

      {

          qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")

                                                  << QThread::currentThread();

          this->waitForFinish();

      }

        perrinel
    
push method of worker return the id of the nextRange which is canceled

              r625
            
      QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,

                                                           SqpRange rangeRequested,

                                                           SqpRange cacheRangeRequested,

                                                           DataProviderParameters parameters,

                                                           std::shared_ptr<IDataProvider> provider)

        perrinel
    
Implementation of V5 acquisition

              r539
            
      {

        perrinel
    
Next range of a variable synchronized is now computed using:...

              r627
            
          qCDebug(LOG_VariableAcquisitionWorker())

        perrinel
    
Implementation of V5 acquisition

              r539
            
              << tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;

        perrinel
    
push method of worker return the id of the nextRange which is canceled

              r625
            
          auto varRequestIdCanceled = QUuid();

        perrinel
    
Implementation of V5 acquisition

              r539
            
          // Request creation

          auto acqRequest = AcquisitionRequest{};

        perrinel
    
Implementation of automatic cancel for request that failed

              r761
            
          qCInfo(LOG_VariableAcquisitionWorker()) << tr("TpushVariableRequest ") << vIdentifier;

        perrinel
    
push method of worker return the id of the nextRange which is canceled

              r625
            
          acqRequest.m_VarRequestId = varRequestId;

        perrinel
    
Implementation of V5 acquisition

              r539
            
          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;

        perrinel
    
push method of worker return the id of the nextRange which is canceled

              r625
            
        perrinel
    
Implementation of V5 acquisition

              r539
            
          // 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

        perrinel
    
push method of worker return the id of the nextRange which is canceled

              r625
            
              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;

              }

        perrinel
    
Implementation of V5 acquisition

              r539
            
              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));

          }

        perrinel
    
push method of worker return the id of the nextRange which is canceled

              r625
            
          return varRequestIdCanceled;

        perrinel
    
Implementation of V5 acquisition

              r539
            
      }

      void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)

      {

        perrinel
    
Implementation of abort mechanism

              r754
            
          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();

          }

        perrinel
    
Implementation of V5 acquisition

              r539
            
      }

      void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,

                                                                       double progress)

      {

        perrinel
    
Fix progression bug when aborting a request for Amda plugin

              r758
            
          qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")

                                                   << acqIdentifier << progress;

        perrinel
    
Implementation of progression

              r750
            
          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);

        perrinel
    
Fix progression bug when aborting a request for Amda plugin

              r758
            
              qCDebug(LOG_VariableAcquisitionWorker())

        perrinel
    
Implementation of automatic cancel for request that failed

              r761
            
                  << tr("TORM: onVariableRetrieveDataInProgress ")

                  << QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier

        perrinel
    
Fix progression bug when aborting a request for Amda plugin

              r758
            
                  << currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;

        perrinel
    
Implementation of progression

              r750
            
              if (finalProgression == 100.0) {

                  emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);

              }

          }

          impl->unlock();

        perrinel
    
Implementation of V5 acquisition

              r539
            
      }

        perrinel
    
Implementation of automatic cancel for request that failed

              r761
            
      void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)

      {

          qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")

                                                   << QThread::currentThread();

          impl->lockRead();

          auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);

          if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {

              auto request = it->second;

              impl->unlock();

              qCInfo(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")

                                                      << acqIdentifier << request.m_vIdentifier

                                                      << QThread::currentThread();

              emit variableCanceledRequested(request.m_vIdentifier);

          }

          else {

              impl->unlock();

              // TODO log no acqIdentifier recognized

          }

      }

        perrinel
    
Implementation of V5 acquisition

              r539
            
      void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,

                                                             std::shared_ptr<IDataSeries> dataSeries,

                                                             SqpRange dataRangeAcquired)

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      {

        perrinel
    
request is now passed by shared pointer instead of const &

              r751
            
          qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")

                                                   << acqIdentifier << dataRangeAcquired;

        perrinel
    
Implementation of V5 acquisition

              r539
            
          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;

        perrinel
    
Implementation of progression

              r750
            
              acqRequest.m_Progression = acqRequest.m_Progression + 1;

        perrinel
    
Implementation of V5 acquisition

              r539
            
              // if the counter is 0, we can return data then run the next request if it exists and

              // removed the finished request

        perrinel
    
Implementation of progression

              r750
            
              if (acqRequest.m_Size == acqRequest.m_Progression) {

        perrinel
    
Implementation of V5 acquisition

              r539
            
                  // 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);

                  }

        perrinel
    
Fix progression bug when aborting a request for Amda plugin

              r758
            
                  // Update to the next request

                  impl->updateToNextRequest(acqRequest.m_vIdentifier);

        perrinel
    
Implementation of V5 acquisition

              r539
            
              }

          }

          else {

        perrinel
    
Implementation of abort mechanism

              r754
            
              qCWarning(LOG_VariableAcquisitionWorker())

                  << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");

        perrinel
    
Implementation of V5 acquisition

              r539
            
          }

          impl->unlock();

      }

        perrinel
    
Implementation of progression

              r750
            
      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

          }

      }

        perrinel
    
Implementation of V5 acquisition

              r539
            
      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();

        perrinel
    
Add empty class VariableAcquisitionWorker

              r527
            
      }

        perrinel
    
Implementation of abort mechanism

              r754
            
      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 ");

          }

      }

	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

perrinel Add empty class VariableAcquisitionWorker	r527	#include "Variable/VariableAcquisitionWorker.h"

		#include "Variable/Variable.h"
perrinel Implementation of V5 acquisition	r539
		#include <Data/AcquisitionRequest.h>
		#include <Data/SqpRange.h>

perrinel Add empty class VariableAcquisitionWorker	r527	#include <unordered_map>
perrinel Implementation of V5 acquisition	r539	#include <utility>
perrinel Add empty class VariableAcquisitionWorker	r527
perrinel Implementation of V5 acquisition	r539	#include <QMutex>
		#include <QReadWriteLock>
perrinel Add empty class VariableAcquisitionWorker	r527	#include <QThread>
perrinel Implementation of V5 acquisition	r539
perrinel Implementation of progression	r750	#include <cmath>

perrinel Add empty class VariableAcquisitionWorker	r527	Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")

		struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {

perrinel Implementation of abort mechanism	r754	explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
		: m_Lock{QReadWriteLock::Recursive}, q{parent}
		{
		}
perrinel Implementation of V5 acquisition	r539
		void lockRead() { m_Lock.lockForRead(); }
		void lockWrite() { m_Lock.lockForWrite(); }
		void unlock() { m_Lock.unlock(); }

		void removeVariableRequest(QUuid vIdentifier);

perrinel Implementation of abort mechanism	r754	/// Remove the current request and execute the next one if exist
		void updateToNextRequest(QUuid vIdentifier);

perrinel Implementation of V5 acquisition	r539	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;
perrinel Implementation of abort mechanism	r754	VariableAcquisitionWorker *q;
perrinel Add empty class VariableAcquisitionWorker	r527	};


		VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
perrinel Implementation of abort mechanism	r754	: QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
perrinel Add empty class VariableAcquisitionWorker	r527	{
		}

perrinel Implementation of V5 acquisition	r539	VariableAcquisitionWorker::~VariableAcquisitionWorker()
		{
		qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
		<< QThread::currentThread();
		this->waitForFinish();
		}


perrinel push method of worker return the id of the nextRange which is canceled	r625	QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
		SqpRange rangeRequested,
		SqpRange cacheRangeRequested,
		DataProviderParameters parameters,
		std::shared_ptr<IDataProvider> provider)
perrinel Implementation of V5 acquisition	r539	{
perrinel Next range of a variable synchronized is now computed using:...	r627	qCDebug(LOG_VariableAcquisitionWorker())
perrinel Implementation of V5 acquisition	r539	<< tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;
perrinel push method of worker return the id of the nextRange which is canceled	r625	auto varRequestIdCanceled = QUuid();
perrinel Implementation of V5 acquisition	r539
		// Request creation
		auto acqRequest = AcquisitionRequest{};
perrinel Implementation of automatic cancel for request that failed	r761	qCInfo(LOG_VariableAcquisitionWorker()) << tr("TpushVariableRequest ") << vIdentifier;
perrinel push method of worker return the id of the nextRange which is canceled	r625	acqRequest.m_VarRequestId = varRequestId;
perrinel Implementation of V5 acquisition	r539	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;

perrinel push method of worker return the id of the nextRange which is canceled	r625
perrinel Implementation of V5 acquisition	r539	// 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
perrinel push method of worker return the id of the nextRange which is canceled	r625	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;
		}

perrinel Implementation of V5 acquisition	r539	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));
		}
perrinel push method of worker return the id of the nextRange which is canceled	r625
		return varRequestIdCanceled;
perrinel Implementation of V5 acquisition	r539	}

		void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
		{
perrinel Implementation of abort mechanism	r754	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();
		}
perrinel Implementation of V5 acquisition	r539	}

		void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
		double progress)
		{
perrinel Fix progression bug when aborting a request for Amda plugin	r758	qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
		<< acqIdentifier << progress;
perrinel Implementation of progression	r750	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);
perrinel Fix progression bug when aborting a request for Amda plugin	r758	qCDebug(LOG_VariableAcquisitionWorker())
perrinel Implementation of automatic cancel for request that failed	r761	<< tr("TORM: onVariableRetrieveDataInProgress ")
		<< QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier
perrinel Fix progression bug when aborting a request for Amda plugin	r758	<< currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;
perrinel Implementation of progression	r750	if (finalProgression == 100.0) {
		emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
		}
		}
		impl->unlock();
perrinel Implementation of V5 acquisition	r539	}

perrinel Implementation of automatic cancel for request that failed	r761	void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
		{
		qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
		<< QThread::currentThread();
		impl->lockRead();
		auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
		if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
		auto request = it->second;
		impl->unlock();
		qCInfo(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
		<< acqIdentifier << request.m_vIdentifier
		<< QThread::currentThread();
		emit variableCanceledRequested(request.m_vIdentifier);
		}
		else {
		impl->unlock();
		// TODO log no acqIdentifier recognized
		}
		}

perrinel Implementation of V5 acquisition	r539	void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
		std::shared_ptr<IDataSeries> dataSeries,
		SqpRange dataRangeAcquired)
perrinel Add empty class VariableAcquisitionWorker	r527	{
perrinel request is now passed by shared pointer instead of const &	r751	qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
		<< acqIdentifier << dataRangeAcquired;
perrinel Implementation of V5 acquisition	r539	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;
perrinel Implementation of progression	r750	acqRequest.m_Progression = acqRequest.m_Progression + 1;
perrinel Implementation of V5 acquisition	r539
		// if the counter is 0, we can return data then run the next request if it exists and
		// removed the finished request
perrinel Implementation of progression	r750	if (acqRequest.m_Size == acqRequest.m_Progression) {
perrinel Implementation of V5 acquisition	r539	// 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);
		}

perrinel Fix progression bug when aborting a request for Amda plugin	r758	// Update to the next request
		impl->updateToNextRequest(acqRequest.m_vIdentifier);
perrinel Implementation of V5 acquisition	r539	}
		}
		else {
perrinel Implementation of abort mechanism	r754	qCWarning(LOG_VariableAcquisitionWorker())
		<< tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
perrinel Implementation of V5 acquisition	r539	}
		impl->unlock();
		}

perrinel Implementation of progression	r750	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
		}
		}

perrinel Implementation of V5 acquisition	r539	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();
perrinel Add empty class VariableAcquisitionWorker	r527	}
perrinel Implementation of abort mechanism	r754
		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 ");
		}
		}