From 00ac2d91df6400ccf1c4bc80f650a6a9f8963d89 2017-09-14 07:19:26
From: Alexandre Leroux <aleroux@itlink.fr>
Date: 2017-09-14 07:19:26
Subject: [PATCH] temp commit

---

diff --git a/core/include/Common/spimpl.h b/core/include/Common/spimpl.h
index b4d5e04..7f6e8be 100644
--- a/core/include/Common/spimpl.h
+++ b/core/include/Common/spimpl.h
@@ -89,8 +89,9 @@ using default_copier_t = typename default_copier<T>::type;
 
 template <class T, class D, class C>
 struct is_default_manageable
-    : public std::integral_constant<bool, std::is_same<D, default_deleter_t<T> >::value
-                                              && std::is_same<C, default_copier_t<T> >::value> {
+    : public std::integral_constant<bool,
+                                    std::is_same<D, default_deleter_t<T> >::value
+                                        && std::is_same<C, default_copier_t<T> >::value> {
 };
 }
 
@@ -131,10 +132,11 @@ public:
     }
 
     template <class U>
-    impl_ptr(U *u, typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                               && is_default_manageable::value,
-                                           dummy_t_>::type
-                   = dummy_t_()) SPIMPL_NOEXCEPT
+    impl_ptr(U *u,
+             typename std::enable_if<std::is_convertible<U *, pointer>::value
+                                         && is_default_manageable::value,
+                                     dummy_t_>::type
+             = dummy_t_()) SPIMPL_NOEXCEPT
         : impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>)
     {
     }
@@ -151,12 +153,12 @@ public:
 
 #ifdef SPIMPL_HAS_AUTO_PTR
     template <class U>
-    impl_ptr(std::auto_ptr<U> &&u, typename std::enable_if<std::is_convertible<U *, pointer>::value
-                                                               && is_default_manageable::value,
-                                                           dummy_t_>::type
-                                   = dummy_t_()) SPIMPL_NOEXCEPT
-        : ptr_(u.release(), &details::default_delete<T>),
-          copier_(&details::default_copy<T>)
+    impl_ptr(std::auto_ptr<U> &&u,
+             typename std::enable_if<std::is_convertible<U *, pointer>::value
+                                         && is_default_manageable::value,
+                                     dummy_t_>::type
+             = dummy_t_()) SPIMPL_NOEXCEPT : ptr_(u.release(), &details::default_delete<T>),
+                                             copier_(&details::default_copy<T>)
     {
     }
 #endif
diff --git a/core/src/DataSource/DataSourceController.cpp b/core/src/DataSource/DataSourceController.cpp
index 220945e..22441fe 100644
--- a/core/src/DataSource/DataSourceController.cpp
+++ b/core/src/DataSource/DataSourceController.cpp
@@ -49,14 +49,14 @@ public:
 DataSourceController::DataSourceController(QObject *parent)
         : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
 {
-    qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
-                                        << QThread::currentThread();
+    qCDebug(LOG_DataSourceController())
+        << tr("DataSourceController construction") << QThread::currentThread();
 }
 
 DataSourceController::~DataSourceController()
 {
-    qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
-                                        << QThread::currentThread();
+    qCDebug(LOG_DataSourceController())
+        << tr("DataSourceController destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
@@ -126,8 +126,8 @@ void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
 
 void DataSourceController::initialize()
 {
-    qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
-                                        << QThread::currentThread();
+    qCDebug(LOG_DataSourceController())
+        << tr("DataSourceController init") << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
 }
diff --git a/core/src/Network/NetworkController.cpp b/core/src/Network/NetworkController.cpp
index 1649cc5..dfbac8b 100644
--- a/core/src/Network/NetworkController.cpp
+++ b/core/src/Network/NetworkController.cpp
@@ -33,8 +33,8 @@ NetworkController::NetworkController(QObject *parent)
 void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
                                            std::function<void(QNetworkReply *, QUuid)> callback)
 {
-    qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
-                                     << QThread::currentThread()->objectName();
+    qCDebug(LOG_NetworkController())
+        << tr("NetworkController registered") << QThread::currentThread()->objectName();
     auto reply = impl->m_AccessManager->get(request);
 
     // Store the couple reply id
@@ -44,8 +44,8 @@ void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid
 
     auto onReplyFinished = [reply, this, identifier, callback]() {
 
-        qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
-                                         << QThread::currentThread() << reply;
+        qCDebug(LOG_NetworkController())
+            << tr("NetworkController onReplyFinished") << QThread::currentThread() << reply;
         impl->lockRead();
         auto it = impl->m_NetworkReplyToVariableId.find(reply);
         impl->unlock();
@@ -60,8 +60,8 @@ void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid
             emit this->replyDownloadProgress(identifier, 0);
         }
 
-        qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
-                                         << QThread::currentThread() << reply;
+        qCDebug(LOG_NetworkController())
+            << tr("NetworkController onReplyFinished END") << QThread::currentThread() << reply;
     };
 
     auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
@@ -75,8 +75,8 @@ void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid
         if (it != impl->m_NetworkReplyToVariableId.cend()) {
             emit this->replyDownloadProgress(it->second, progress);
         }
-        qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
-                                         << QThread::currentThread() << reply;
+        qCDebug(LOG_NetworkController())
+            << tr("NetworkController onReplyProgress END") << QThread::currentThread() << reply;
     };
 
 
@@ -113,8 +113,8 @@ void NetworkController::finalize()
 void NetworkController::onReplyCanceled(QUuid identifier)
 {
     auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
-    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
-                                     << QThread::currentThread();
+    qCDebug(LOG_NetworkController())
+        << tr("NetworkController onReplyCanceled") << QThread::currentThread();
 
 
     impl->lockRead();
@@ -124,8 +124,8 @@ void NetworkController::onReplyCanceled(QUuid identifier)
     if (it != end) {
         it->first->abort();
     }
-    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
-                                     << QThread::currentThread();
+    qCDebug(LOG_NetworkController())
+        << tr("NetworkController onReplyCanceled END") << QThread::currentThread();
 }
 
 void NetworkController::waitForFinish()
diff --git a/core/src/Variable/Variable.cpp b/core/src/Variable/Variable.cpp
index ed9c248..9f8945b 100644
--- a/core/src/Variable/Variable.cpp
+++ b/core/src/Variable/Variable.cpp
@@ -263,8 +263,8 @@ QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) co
             notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
         }
         else {
-            qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
-                                       << QThread::currentThread();
+            qCCritical(LOG_Variable())
+                << tr("Detection of unknown case.") << QThread::currentThread();
         }
     }
 
@@ -298,8 +298,8 @@ QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const
             inCache << impl->m_CacheRange;
         }
         else {
-            qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
-                                       << QThread::currentThread();
+            qCCritical(LOG_Variable())
+                << tr("Detection of unknown case.") << QThread::currentThread();
         }
     }
 
diff --git a/core/src/Variable/VariableAcquisitionWorker.cpp b/core/src/Variable/VariableAcquisitionWorker.cpp
index f24a269..fd75f09 100644
--- a/core/src/Variable/VariableAcquisitionWorker.cpp
+++ b/core/src/Variable/VariableAcquisitionWorker.cpp
@@ -40,8 +40,8 @@ VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
 
 VariableAcquisitionWorker::~VariableAcquisitionWorker()
 {
-    qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
-                                            << QThread::currentThread();
+    qCInfo(LOG_VariableAcquisitionWorker())
+        << tr("VariableAcquisitionWorker destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
@@ -113,8 +113,8 @@ void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                        std::shared_ptr<IDataSeries> dataSeries,
                                                        SqpRange dataRangeAcquired)
 {
-    qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableDataAcquired on range ")
-                                             << acqIdentifier << dataRangeAcquired;
+    qCDebug(LOG_VariableAcquisitionWorker())
+        << tr("onVariableDataAcquired on range ") << acqIdentifier << dataRangeAcquired;
     impl->lockWrite();
     auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
     if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
@@ -186,8 +186,8 @@ void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
 
 void VariableAcquisitionWorker::initialize()
 {
-    qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
-                                             << QThread::currentThread();
+    qCDebug(LOG_VariableAcquisitionWorker())
+        << tr("VariableAcquisitionWorker init") << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
 }
diff --git a/core/src/Variable/VariableCacheController.cpp b/core/src/Variable/VariableCacheController.cpp
index fd1e836..9edc77c 100644
--- a/core/src/Variable/VariableCacheController.cpp
+++ b/core/src/Variable/VariableCacheController.cpp
@@ -30,8 +30,8 @@ VariableCacheController::VariableCacheController(QObject *parent)
 void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                           const SqpRange &dateTime)
 {
-    qCDebug(LOG_VariableCacheController()) << "VariableCacheController::addDateTime"
-                                           << QThread::currentThread()->objectName();
+    qCDebug(LOG_VariableCacheController())
+        << "VariableCacheController::addDateTime" << QThread::currentThread()->objectName();
     if (variable) {
         auto findVariableIte = impl->m_VariableToSqpRangeListMap.find(variable);
         if (findVariableIte == impl->m_VariableToSqpRangeListMap.end()) {
@@ -104,8 +104,8 @@ VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable>
 QVector<SqpRange>
 VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
 {
-    qCDebug(LOG_VariableCacheController()) << "VariableCacheController::dateCacheList"
-                                           << QThread::currentThread()->objectName();
+    qCDebug(LOG_VariableCacheController())
+        << "VariableCacheController::dateCacheList" << QThread::currentThread()->objectName();
     try {
         return impl->m_VariableToSqpRangeListMap.at(variable);
     }
@@ -215,8 +215,8 @@ void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) c
 {
     auto variableDateTimeList = impl->m_VariableToSqpRangeListMap.find(variable);
     if (variableDateTimeList != impl->m_VariableToSqpRangeListMap.end()) {
-        qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
-                                              << variableDateTimeList->second;
+        qCInfo(LOG_VariableCacheController())
+            << tr("VariableCacheController::displayCache") << variableDateTimeList->second;
     }
     else {
         qCWarning(LOG_VariableCacheController())
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 3aa437b..86d597f 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -145,8 +145,8 @@ struct VariableController::VariableControllerPrivate {
 VariableController::VariableController(QObject *parent)
         : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
 {
-    qCDebug(LOG_VariableController()) << tr("VariableController construction")
-                                      << QThread::currentThread();
+    qCDebug(LOG_VariableController())
+        << tr("VariableController construction") << QThread::currentThread();
 
     connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
             &VariableController::onAbortProgressRequested);
@@ -168,8 +168,8 @@ VariableController::VariableController(QObject *parent)
 
 VariableController::~VariableController()
 {
-    qCDebug(LOG_VariableController()) << tr("VariableController destruction")
-                                      << QThread::currentThread();
+    qCDebug(LOG_VariableController())
+        << tr("VariableController destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
@@ -292,8 +292,8 @@ VariableController::createVariable(const QString &name, const QVariantHash &meta
 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
 {
     // TODO check synchronisation and Rescale
-    qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
-                                      << QThread::currentThread()->objectName();
+    qCDebug(LOG_VariableController())
+        << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
     auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
     auto varRequestId = QUuid::createUuid();
 
@@ -349,9 +349,9 @@ void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> vari
 
 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
 {
-    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
-                                      << QThread::currentThread()->objectName()
-                                      << synchronizationGroupId;
+    qCDebug(LOG_VariableController())
+        << "TORM: VariableController::onAddSynchronizationGroupId"
+        << QThread::currentThread()->objectName() << synchronizationGroupId;
     auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
     impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
         std::make_pair(synchronizationGroupId, vSynchroGroup));
@@ -366,8 +366,8 @@ void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                            QUuid synchronizationGroupId)
 
 {
-    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
-                                      << synchronizationGroupId;
+    qCDebug(LOG_VariableController())
+        << "TORM: VariableController::onAddSynchronized" << synchronizationGroupId;
     auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
     if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
         auto groupIdToVSGIt
@@ -472,8 +472,8 @@ void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> 
                 // Don't process already processed var
                 if (!variables.contains(var)) {
                     if (var != nullptr) {
-                        qCDebug(LOG_VariableController()) << "processRequest synchro for"
-                                                          << var->name();
+                        qCDebug(LOG_VariableController())
+                            << "processRequest synchro for" << var->name();
                         auto vSyncRangeRequested = computeSynchroRangeRequested(
                             var->range(), range, groupIdToOldRangeMap.at(gId));
                         qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
@@ -550,10 +550,10 @@ void VariableController::VariableControllerPrivate::processRequest(std::shared_p
         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;
+        qCDebug(LOG_VariableAcquisitionWorker())
+            << tr("TORM processRequest R  ") << varStrategyRangesRequested.first;
+        qCDebug(LOG_VariableAcquisitionWorker())
+            << tr("TORM processRequest CR ") << varStrategyRangesRequested.second;
         // store VarRequest
         storeVariableRequest(varId, varRequestId, varRequest);
 
@@ -566,8 +566,8 @@ void VariableController::VariableControllerPrivate::processRequest(std::shared_p
                 varProvider);
 
             if (!varRequestIdCanceled.isNull()) {
-                qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
-                                                        << varRequestIdCanceled;
+                qCInfo(LOG_VariableAcquisitionWorker())
+                    << tr("varRequestIdCanceled: ") << varRequestIdCanceled;
                 cancelVariableRequest(varRequestIdCanceled);
             }
         }
@@ -613,8 +613,8 @@ VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
     const QVector<AcquisitionDataPacket> acqDataPacketVector)
 {
-    qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
-                                      << acqDataPacketVector.size();
+    qCDebug(LOG_VariableController())
+        << tr("TORM: retrieveDataSeries acqDataPacketVector size") << acqDataPacketVector.size();
     std::shared_ptr<IDataSeries> dataSeries;
     if (!acqDataPacketVector.isEmpty()) {
         dataSeries = acqDataPacketVector[0].m_DateSeries;
@@ -631,8 +631,8 @@ void VariableController::VariableControllerPrivate::registerProvider(
     std::shared_ptr<IDataProvider> provider)
 {
     if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
-        qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
-                                          << provider->objectName();
+        qCDebug(LOG_VariableController())
+            << tr("Registering of a new provider") << provider->objectName();
         m_ProviderSet.insert(provider);
         connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                 &VariableAcquisitionWorker::onVariableDataAcquired);
@@ -709,11 +709,11 @@ QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 << varRequestId;
         }
 
-        qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  QUEUE ?")
-                                          << varRequestIdQueue.size();
+        qCDebug(LOG_VariableController())
+            << tr("1: erase REQUEST in  QUEUE ?") << varRequestIdQueue.size();
         varRequestIdQueue.pop_front();
-        qCDebug(LOG_VariableController()) << tr("2: erase REQUEST in  QUEUE ?")
-                                          << varRequestIdQueue.size();
+        qCDebug(LOG_VariableController())
+            << tr("2: erase REQUEST in  QUEUE ?") << varRequestIdQueue.size();
         if (varRequestIdQueue.empty()) {
             m_VarIdToVarRequestIdQueueMap.erase(varId);
         }
@@ -737,8 +737,8 @@ void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid 
              (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
              ++varIdToVarRequestMapIt) {
             processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
-            qCDebug(LOG_VariableController()) << tr("updateVariableRequest")
-                                              << processVariableUpdate;
+            qCDebug(LOG_VariableController())
+                << tr("updateVariableRequest") << processVariableUpdate;
         }
 
         if (processVariableUpdate) {
@@ -748,13 +748,13 @@ void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid 
                     auto &varRequest = varIdToVarRequestMapIt->second;
                     var->setRange(varRequest.m_RangeRequested);
                     var->setCacheRange(varRequest.m_CacheRangeRequested);
-                    qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
-                                                      << varRequest.m_RangeRequested;
-                    qCDebug(LOG_VariableController()) << tr("2: onDataProvided")
-                                                      << varRequest.m_CacheRangeRequested;
+                    qCDebug(LOG_VariableController())
+                        << tr("1: onDataProvided") << varRequest.m_RangeRequested;
+                    qCDebug(LOG_VariableController())
+                        << tr("2: onDataProvided") << varRequest.m_CacheRangeRequested;
                     var->mergeDataSeries(varRequest.m_DataSeries);
-                    qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
-                                                      << varRequest.m_DataSeries->range();
+                    qCDebug(LOG_VariableController())
+                        << tr("3: onDataProvided") << varRequest.m_DataSeries->range();
                     qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
 
                     /// @todo MPL: confirm
@@ -770,11 +770,11 @@ void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid 
             }
 
             // cleaning varRequestId
-            qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in  MAP ?")
-                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+            qCDebug(LOG_VariableController())
+                << tr("0: erase REQUEST in  MAP ?") << m_VarRequestIdToVarIdVarRequestMap.size();
             m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
-            qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  MAP ?")
-                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+            qCDebug(LOG_VariableController())
+                << tr("1: erase REQUEST in  MAP ?") << m_VarRequestIdToVarIdVarRequestMap.size();
         }
     }
     else {
diff --git a/core/src/Variable/VariableController.cpp~RF14af5971.TMP b/core/src/Variable/VariableController.cpp~RF14af5971.TMP
new file mode 100644
index 0000000..50b88cc
--- /dev/null
+++ b/core/src/Variable/VariableController.cpp~RF14af5971.TMP
@@ -0,0 +1,775 @@
+#include <Variable/Variable.h>
+#include <Variable/VariableAcquisitionWorker.h>
+#include <Variable/VariableCacheStrategy.h>
+#include <Variable/VariableController.h>
+#include <Variable/VariableModel.h>
+#include <Variable/VariableSynchronizationGroup.h>
+
+#include <Data/DataProviderParameters.h>
+#include <Data/IDataProvider.h>
+#include <Data/IDataSeries.h>
+#include <Data/VariableRequest.h>
+#include <Time/TimeController.h>
+
+#include <QMutex>
+#include <QThread>
+#include <QUuid>
+#include <QtCore/QItemSelectionModel>
+
+#include <deque>
+#include <set>
+#include <unordered_map>
+
+Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
+
+namespace {
+
+SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
+                                      const SqpRange &oldGraphRange)
+{
+    auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
+
+    auto varRangeRequested = varRange;
+    switch (zoomType) {
+        case AcquisitionZoomType::ZoomIn: {
+            auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
+            auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
+            varRangeRequested.m_TStart += deltaLeft;
+            varRangeRequested.m_TEnd -= deltaRight;
+            break;
+        }
+
+        case AcquisitionZoomType::ZoomOut: {
+            auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
+            auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
+            varRangeRequested.m_TStart -= deltaLeft;
+            varRangeRequested.m_TEnd += deltaRight;
+            break;
+        }
+        case AcquisitionZoomType::PanRight: {
+            auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
+            varRangeRequested.m_TStart += deltaRight;
+            varRangeRequested.m_TEnd += deltaRight;
+            break;
+        }
+        case AcquisitionZoomType::PanLeft: {
+            auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
+            varRangeRequested.m_TStart -= deltaLeft;
+            varRangeRequested.m_TEnd -= deltaLeft;
+            break;
+        }
+        case AcquisitionZoomType::Unknown: {
+            qCCritical(LOG_VariableController())
+                << VariableController::tr("Impossible to synchronize: zoom type unknown");
+            break;
+        }
+        default:
+            qCCritical(LOG_VariableController()) << VariableController::tr(
+                "Impossible to synchronize: zoom type not take into account");
+            // No action
+            break;
+    }
+
+    return varRangeRequested;
+}
+}
+
+struct VariableController::VariableControllerPrivate {
+    explicit VariableControllerPrivate(VariableController *parent)
+            : m_WorkingMutex{},
+              m_VariableModel{new VariableModel{parent}},
+              m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
+              m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
+              m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
+              q{parent}
+    {
+
+        m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
+        m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
+    }
+
+
+    virtual ~VariableControllerPrivate()
+    {
+        qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
+        m_VariableAcquisitionWorkerThread.quit();
+        m_VariableAcquisitionWorkerThread.wait();
+    }
+
+
+    void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
+                        QUuid varRequestId);
+
+    QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
+                                                    const SqpRange &dateTime);
+
+    std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
+    std::shared_ptr<IDataSeries>
+    retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
+
+    void registerProvider(std::shared_ptr<IDataProvider> provider);
+
+    void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
+    QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
+    void updateVariableRequest(QUuid varRequestId);
+    void cancelVariableRequest(QUuid varRequestId);
+
+    QMutex m_WorkingMutex;
+    /// Variable model. The VariableController has the ownership
+    VariableModel *m_VariableModel;
+    QItemSelectionModel *m_VariableSelectionModel;
+
+
+    TimeController *m_TimeController{nullptr};
+    std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
+    std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
+    QThread m_VariableAcquisitionWorkerThread;
+
+    std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
+        m_VariableToProviderMap;
+    std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
+    std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
+        m_GroupIdToVariableSynchronizationGroupMap;
+    std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
+    std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
+
+    std::map<QUuid, std::map<QUuid, VariableRequest> > m_VarRequestIdToVarIdVarRequestMap;
+
+    std::map<QUuid, std::deque<QUuid> > m_VarIdToVarRequestIdQueueMap;
+
+
+    VariableController *q;
+};
+
+
+VariableController::VariableController(QObject *parent)
+        : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
+{
+    qCDebug(LOG_VariableController()) << tr("VariableController construction")
+                                      << QThread::currentThread();
+
+    connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
+            &VariableController::onAbortProgressRequested);
+
+    connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
+            &VariableController::onDataProvided);
+    connect(impl->m_VariableAcquisitionWorker.get(),
+            &VariableAcquisitionWorker::variableRequestInProgress, this,
+            &VariableController::onVariableRetrieveDataInProgress);
+
+    connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
+            impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
+    connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
+            impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
+
+
+    impl->m_VariableAcquisitionWorkerThread.start();
+}
+
+VariableController::~VariableController()
+{
+    qCDebug(LOG_VariableController()) << tr("VariableController destruction")
+                                      << QThread::currentThread();
+    this->waitForFinish();
+}
+
+VariableModel *VariableController::variableModel() noexcept
+{
+    return impl->m_VariableModel;
+}
+
+QItemSelectionModel *VariableController::variableSelectionModel() noexcept
+{
+    return impl->m_VariableSelectionModel;
+}
+
+void VariableController::setTimeController(TimeController *timeController) noexcept
+{
+    impl->m_TimeController = timeController;
+}
+
+std::shared_ptr<Variable>
+VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
+{
+    if (impl->m_VariableModel->containsVariable(variable)) {
+        // Clones variable
+        auto duplicate = variable->clone();
+
+        // Adds clone to model
+        impl->m_VariableModel->addVariable(duplicate);
+
+        // Generates clone identifier
+        impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
+
+        // Registers provider
+        auto variableProvider = impl->m_VariableToProviderMap.at(variable);
+        auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
+
+        impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
+        if (duplicateProvider) {
+            impl->registerProvider(duplicateProvider);
+        }
+
+        return duplicate;
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Can't create duplicate of variable %1: variable not registered in the model")
+                   .arg(variable->name());
+        return nullptr;
+    }
+}
+
+void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
+{
+    if (!variable) {
+        qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
+        return;
+    }
+
+    // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
+    // make some treatments before the deletion
+    emit variableAboutToBeDeleted(variable);
+
+    // Deletes identifier
+    impl->m_VariableToIdentifierMap.erase(variable);
+
+    // Deletes provider
+    auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
+    qCDebug(LOG_VariableController())
+        << tr("Number of providers deleted for variable %1: %2")
+               .arg(variable->name(), QString::number(nbProvidersDeleted));
+
+
+    // Deletes from model
+    impl->m_VariableModel->deleteVariable(variable);
+}
+
+void VariableController::deleteVariables(
+    const QVector<std::shared_ptr<Variable> > &variables) noexcept
+{
+    for (auto variable : qAsConst(variables)) {
+        deleteVariable(variable);
+    }
+}
+
+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
+{
+    if (!impl->m_TimeController) {
+        qCCritical(LOG_VariableController())
+            << tr("Impossible to create variable: The time controller is null");
+        return nullptr;
+    }
+
+    auto range = impl->m_TimeController->dateTime();
+
+    if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
+        auto identifier = QUuid::createUuid();
+
+        // store the provider
+        impl->registerProvider(provider);
+
+        // Associate the provider
+        impl->m_VariableToProviderMap[newVariable] = provider;
+        impl->m_VariableToIdentifierMap[newVariable] = identifier;
+
+
+        auto varRequestId = QUuid::createUuid();
+        qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
+        impl->processRequest(newVariable, range, varRequestId);
+        impl->updateVariableRequest(varRequestId);
+
+        return newVariable;
+    }
+}
+
+void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
+{
+    // TODO check synchronisation and Rescale
+    qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
+                                      << QThread::currentThread()->objectName();
+    auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
+    auto varRequestId = QUuid::createUuid();
+
+    for (const auto &selectedRow : qAsConst(selectedRows)) {
+        if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
+            selectedVariable->setRange(dateTime);
+            impl->processRequest(selectedVariable, dateTime, varRequestId);
+
+            // notify that rescale operation has to be done
+            emit rangeChanged(selectedVariable, dateTime);
+        }
+    }
+    impl->updateVariableRequest(varRequestId);
+}
+
+void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
+                                        const SqpRange &cacheRangeRequested,
+                                        QVector<AcquisitionDataPacket> dataAcquired)
+{
+    auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
+    auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
+    if (!varRequestId.isNull()) {
+        impl->updateVariableRequest(varRequestId);
+    }
+}
+
+void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
+{
+    if (auto var = impl->findVariable(identifier)) {
+        impl->m_VariableModel->setDataProgress(var, progress);
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Impossible to notify progression of a null variable");
+    }
+}
+
+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);
+    }
+    else {
+        qCWarning(LOG_VariableController())
+            << tr("Aborting progression of inexistant variable detected !!!")
+            << QThread::currentThread()->objectName();
+    }
+}
+
+void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
+{
+    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
+                                      << QThread::currentThread()->objectName()
+                                      << synchronizationGroupId;
+    auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
+    impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
+        std::make_pair(synchronizationGroupId, vSynchroGroup));
+}
+
+void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
+{
+    impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
+}
+
+void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
+                                           QUuid synchronizationGroupId)
+
+{
+    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
+                                      << synchronizationGroupId;
+    auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
+    if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
+        auto groupIdToVSGIt
+            = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
+        if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
+            impl->m_VariableIdGroupIdMap.insert(
+                std::make_pair(varToVarIdIt->second, synchronizationGroupId));
+            groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
+        }
+        else {
+            qCCritical(LOG_VariableController())
+                << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
+                << variable->name();
+        }
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Impossible to synchronize a variable with no identifier") << variable->name();
+    }
+}
+
+
+void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
+                                              const SqpRange &range, const SqpRange &oldRange,
+                                              bool synchronise)
+{
+    // NOTE: oldRange isn't really necessary since oldRange == variable->range().
+
+    // we want to load data of the variable for the dateTime.
+    // First we check if the cache contains some of them.
+    // For the other, we ask the provider to give them.
+
+    auto varRequestId = QUuid::createUuid();
+    qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                                     << QThread::currentThread()->objectName() << varRequestId;
+
+    for (const auto &var : variables) {
+        qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId;
+        impl->processRequest(var, range, varRequestId);
+    }
+
+    if (synchronise) {
+        // Get the group ids
+        qCDebug(LOG_VariableController())
+            << "TORM VariableController::onRequestDataLoading for synchro var ENABLE";
+        auto groupIds = std::set<QUuid>{};
+        auto groupIdToOldRangeMap = std::map<QUuid, SqpRange>{};
+        for (const auto &var : variables) {
+            auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(var);
+            if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
+                auto vId = varToVarIdIt->second;
+                auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
+                if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
+                    auto gId = varIdToGroupIdIt->second;
+                    groupIdToOldRangeMap.insert(std::make_pair(gId, var->range()));
+                    if (groupIds.find(gId) == groupIds.cend()) {
+                        qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
+                        groupIds.insert(gId);
+                    }
+                }
+            }
+        }
+
+        // We assume here all group ids exist
+        for (const auto &gId : groupIds) {
+            auto vSynchronizationGroup = impl->m_GroupIdToVariableSynchronizationGroupMap.at(gId);
+            auto vSyncIds = vSynchronizationGroup->getIds();
+            qCDebug(LOG_VariableController()) << "Var in synchro group ";
+            for (auto vId : vSyncIds) {
+                auto var = impl->findVariable(vId);
+
+                // Don't process already processed var
+                if (!variables.contains(var)) {
+                    if (var != nullptr) {
+                        qCDebug(LOG_VariableController()) << "processRequest synchro for"
+                                                          << var->name();
+                        auto vSyncRangeRequested = computeSynchroRangeRequested(
+                            var->range(), range, groupIdToOldRangeMap.at(gId));
+                        qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
+                        impl->processRequest(var, vSyncRangeRequested, varRequestId);
+                    }
+                    else {
+                        qCCritical(LOG_VariableController())
+
+                            << tr("Impossible to synchronize a null variable");
+                    }
+                }
+            }
+        }
+    }
+
+    impl->updateVariableRequest(varRequestId);
+}
+
+
+void VariableController::initialize()
+{
+    qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
+    impl->m_WorkingMutex.lock();
+    qCDebug(LOG_VariableController()) << tr("VariableController init END");
+}
+
+void VariableController::finalize()
+{
+    impl->m_WorkingMutex.unlock();
+}
+
+void VariableController::waitForFinish()
+{
+    QMutexLocker locker{&impl->m_WorkingMutex};
+}
+
+AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
+{
+    // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
+    auto zoomType = AcquisitionZoomType::Unknown;
+    if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
+        zoomType = AcquisitionZoomType::ZoomOut;
+    }
+    else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
+        zoomType = AcquisitionZoomType::PanRight;
+    }
+    else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
+        zoomType = AcquisitionZoomType::PanLeft;
+    }
+    else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
+        zoomType = AcquisitionZoomType::ZoomIn;
+    }
+    else {
+        qCCritical(LOG_VariableController()) << "getZoomType: Unknown type detected";
+    }
+    return zoomType;
+}
+
+void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
+                                                                   const SqpRange &rangeRequested,
+                                                                   QUuid varRequestId)
+{
+
+    // TODO: protect at
+    auto varRequest = VariableRequest{};
+    auto varId = m_VariableToIdentifierMap.at(var);
+
+    auto varStrategyRangesRequested
+        = m_VariableCacheStrategy->computeStrategyRanges(var->range(), rangeRequested);
+    auto notInCacheRangeList = var->provideNotInCacheRangeList(varStrategyRangesRequested.second);
+    auto inCacheRangeList = var->provideInCacheRangeList(varStrategyRangesRequested.second);
+
+    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);
+
+        auto varProvider = m_VariableToProviderMap.at(var);
+        if (varProvider != nullptr) {
+            auto varRequestIdCanceled = m_VariableAcquisitionWorker->pushVariableRequest(
+                varRequestId, varId, varStrategyRangesRequested.first,
+                varStrategyRangesRequested.second,
+                DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
+                varProvider);
+
+            if (!varRequestIdCanceled.isNull()) {
+                qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
+                                                        << varRequestIdCanceled;
+                cancelVariableRequest(varRequestIdCanceled);
+            }
+        }
+        else {
+            qCCritical(LOG_VariableController())
+                << "Impossible to provide data with a null provider";
+        }
+
+        if (!inCacheRangeList.empty()) {
+            emit q->updateVarDisplaying(var, inCacheRangeList.first());
+        }
+    }
+    else {
+
+        varRequest.m_RangeRequested = varStrategyRangesRequested.first;
+        varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
+        // store VarRequest
+        storeVariableRequest(varId, varRequestId, varRequest);
+        acceptVariableRequest(varId,
+                              var->dataSeries()->subDataSeries(varStrategyRangesRequested.second));
+    }
+}
+
+std::shared_ptr<Variable>
+VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
+{
+    std::shared_ptr<Variable> var;
+    auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
+
+    auto end = m_VariableToIdentifierMap.cend();
+    auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
+    if (it != end) {
+        var = it->first;
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
+    }
+
+    return var;
+}
+
+std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
+    const QVector<AcquisitionDataPacket> acqDataPacketVector)
+{
+    qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
+                                      << acqDataPacketVector.size();
+    std::shared_ptr<IDataSeries> dataSeries;
+    if (!acqDataPacketVector.isEmpty()) {
+        dataSeries = acqDataPacketVector[0].m_DateSeries;
+        for (int i = 1; i < acqDataPacketVector.size(); ++i) {
+            dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
+        }
+    }
+    qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
+                                      << acqDataPacketVector.size();
+    return dataSeries;
+}
+
+void VariableController::VariableControllerPrivate::registerProvider(
+    std::shared_ptr<IDataProvider> provider)
+{
+    if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
+        qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
+                                          << provider->objectName();
+        m_ProviderSet.insert(provider);
+        connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
+                &VariableAcquisitionWorker::onVariableDataAcquired);
+        connect(provider.get(), &IDataProvider::dataProvidedProgress,
+                m_VariableAcquisitionWorker.get(),
+                &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
+    }
+    else {
+        qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
+    }
+}
+
+void VariableController::VariableControllerPrivate::storeVariableRequest(
+    QUuid varId, QUuid varRequestId, const VariableRequest &varRequest)
+{
+    // First request for the variable. we can create an entry for it
+    auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
+    if (varIdToVarRequestIdQueueMapIt == m_VarIdToVarRequestIdQueueMap.cend()) {
+        auto varRequestIdQueue = std::deque<QUuid>{};
+        qCDebug(LOG_VariableController()) << tr("Store REQUEST in  QUEUE");
+        varRequestIdQueue.push_back(varRequestId);
+        m_VarIdToVarRequestIdQueueMap.insert(std::make_pair(varId, std::move(varRequestIdQueue)));
+    }
+    else {
+        qCDebug(LOG_VariableController()) << tr("Store REQUEST in EXISTING QUEUE");
+        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+        varRequestIdQueue.push_back(varRequestId);
+    }
+
+    auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
+    if (varRequestIdToVarIdVarRequestMapIt == m_VarRequestIdToVarIdVarRequestMap.cend()) {
+        auto varIdToVarRequestMap = std::map<QUuid, VariableRequest>{};
+        varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
+        qCDebug(LOG_VariableController()) << tr("Store REQUESTID in MAP");
+        m_VarRequestIdToVarIdVarRequestMap.insert(
+            std::make_pair(varRequestId, std::move(varIdToVarRequestMap)));
+    }
+    else {
+        auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
+        qCDebug(LOG_VariableController()) << tr("Store REQUESTID in EXISTING MAP");
+        varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
+    }
+}
+
+QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
+    QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
+{
+    QUuid varRequestId;
+    auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
+    if (varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.cend()) {
+        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+        varRequestId = varRequestIdQueue.front();
+        auto varRequestIdToVarIdVarRequestMapIt
+            = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
+        if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
+            auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
+            auto varIdToVarRequestMapIt = varIdToVarRequestMap.find(varId);
+            if (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) {
+                qCDebug(LOG_VariableController()) << tr("acceptVariableRequest");
+                auto &varRequest = varIdToVarRequestMapIt->second;
+                varRequest.m_DataSeries = dataSeries;
+                varRequest.m_CanUpdate = true;
+            }
+            else {
+                qCDebug(LOG_VariableController())
+                    << tr("Impossible to acceptVariableRequest of a unknown variable id attached "
+                          "to a variableRequestId")
+                    << varRequestId << varId;
+            }
+        }
+        else {
+            qCCritical(LOG_VariableController())
+                << tr("Impossible to acceptVariableRequest of a unknown variableRequestId")
+                << varRequestId;
+        }
+
+        qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  QUEUE ?")
+                                          << varRequestIdQueue.size();
+        varRequestIdQueue.pop_front();
+        qCDebug(LOG_VariableController()) << tr("2: erase REQUEST in  QUEUE ?")
+                                          << varRequestIdQueue.size();
+        if (varRequestIdQueue.empty()) {
+            m_VarIdToVarRequestIdQueueMap.erase(varId);
+        }
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Impossible to acceptVariableRequest of a unknown variable id") << varId;
+    }
+
+    return varRequestId;
+}
+
+void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
+{
+
+    auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
+    if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
+        bool processVariableUpdate = true;
+        auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
+        for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
+             (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
+             ++varIdToVarRequestMapIt) {
+            processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
+            qCDebug(LOG_VariableController()) << tr("updateVariableRequest")
+                                              << processVariableUpdate;
+        }
+
+        if (processVariableUpdate) {
+            for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
+                 varIdToVarRequestMapIt != varIdToVarRequestMap.cend(); ++varIdToVarRequestMapIt) {
+                if (auto var = findVariable(varIdToVarRequestMapIt->first)) {
+                    auto &varRequest = varIdToVarRequestMapIt->second;
+                    var->setRange(varRequest.m_RangeRequested);
+                    var->setCacheRange(varRequest.m_CacheRangeRequested);
+                    qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
+                                                      << varRequest.m_RangeRequested;
+                    qCDebug(LOG_VariableController()) << tr("2: onDataProvided")
+                                                      << varRequest.m_CacheRangeRequested;
+                    var->mergeDataSeries(varRequest.m_DataSeries);
+                    qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
+                                                      << varRequest.m_DataSeries->range();
+                    qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
+
+                    /// @todo MPL: confirm
+                    // Variable update is notified only if there is no pending request for it
+                    if (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first) == 0) {
+                        emit var->updated();
+                    }
+                }
+                else {
+                    qCCritical(LOG_VariableController())
+                        << tr("Impossible to update data to a null variable");
+                }
+            }
+
+            // cleaning varRequestId
+            qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in  MAP ?")
+                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+            m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
+            qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  MAP ?")
+                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+        }
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Cannot updateVariableRequest for a unknow varRequestId") << varRequestId;
+    }
+}
+
+void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
+{
+    // cleaning varRequestId
+    m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
+
+    for (auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.begin();
+         varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.end();) {
+        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+        varRequestIdQueue.erase(
+            std::remove(varRequestIdQueue.begin(), varRequestIdQueue.end(), varRequestId),
+            varRequestIdQueue.end());
+        if (varRequestIdQueue.empty()) {
+            varIdToVarRequestIdQueueMapIt
+                = m_VarIdToVarRequestIdQueueMap.erase(varIdToVarRequestIdQueueMapIt);
+        }
+        else {
+            ++varIdToVarRequestIdQueueMapIt;
+        }
+    }
+}
diff --git a/core/src/Visualization/VisualizationController.cpp b/core/src/Visualization/VisualizationController.cpp
index 0f4d9fd..e6c5e98 100644
--- a/core/src/Visualization/VisualizationController.cpp
+++ b/core/src/Visualization/VisualizationController.cpp
@@ -18,21 +18,21 @@ public:
 VisualizationController::VisualizationController(QObject *parent)
         : impl{spimpl::make_unique_impl<VisualizationControllerPrivate>()}
 {
-    qCDebug(LOG_VisualizationController()) << tr("VisualizationController construction")
-                                           << QThread::currentThread();
+    qCDebug(LOG_VisualizationController())
+        << tr("VisualizationController construction") << QThread::currentThread();
 }
 
 VisualizationController::~VisualizationController()
 {
-    qCDebug(LOG_VisualizationController()) << tr("VisualizationController destruction")
-                                           << QThread::currentThread();
+    qCDebug(LOG_VisualizationController())
+        << tr("VisualizationController destruction") << QThread::currentThread();
     this->waitForFinish();
 }
 
 void VisualizationController::initialize()
 {
-    qCDebug(LOG_VisualizationController()) << tr("VisualizationController init")
-                                           << QThread::currentThread();
+    qCDebug(LOG_VisualizationController())
+        << tr("VisualizationController init") << QThread::currentThread();
     impl->m_WorkingMutex.lock();
     qCDebug(LOG_VisualizationController()) << tr("VisualizationController init END");
 }
diff --git a/core/tests/Data/TestDataSeries.cpp b/core/tests/Data/TestDataSeries.cpp
index 3551e87..11726d2 100644
--- a/core/tests/Data/TestDataSeries.cpp
+++ b/core/tests/Data/TestDataSeries.cpp
@@ -581,8 +581,8 @@ void TestDataSeries::testValuesBoundsScalar_data()
     QTest::newRow("scalarBounds4")
         << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
         << false << nan << nan;
-    QTest::newRow("scalarBounds5") << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100.
-                                   << 100.;
+    QTest::newRow("scalarBounds5")
+        << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
     QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
 
     // Tests with NaN values: NaN values are not included in min/max search
diff --git a/core/tests/Data/TestDataSeries.cpp~RF14af52ec.TMP b/core/tests/Data/TestDataSeries.cpp~RF14af52ec.TMP
new file mode 100644
index 0000000..3551e87
--- /dev/null
+++ b/core/tests/Data/TestDataSeries.cpp~RF14af52ec.TMP
@@ -0,0 +1,636 @@
+#include "Data/DataSeries.h"
+#include "Data/ScalarSeries.h"
+#include "Data/VectorSeries.h"
+
+#include <cmath>
+
+#include <QObject>
+#include <QtTest>
+
+Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
+Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
+
+namespace {
+
+using DataContainer = std::vector<double>;
+
+void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
+                   const DataContainer &valuesData)
+{
+    QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
+                       [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
+    QVERIFY(std::equal(
+        first, last, valuesData.cbegin(), valuesData.cend(),
+        [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
+}
+
+void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
+                   const std::vector<DataContainer> &valuesData)
+{
+    QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
+                       [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
+    for (auto i = 0; i < valuesData.size(); ++i) {
+        auto componentData = valuesData.at(i);
+
+        QVERIFY(std::equal(
+            first, last, componentData.cbegin(), componentData.cend(),
+            [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
+    }
+}
+
+} // namespace
+
+class TestDataSeries : public QObject {
+    Q_OBJECT
+private:
+    template <typename T>
+    void testValuesBoundsStructure()
+    {
+        // ////////////// //
+        // Test structure //
+        // ////////////// //
+
+        // Data series to get values bounds
+        QTest::addColumn<std::shared_ptr<T> >("dataSeries");
+
+        // x-axis range
+        QTest::addColumn<double>("minXAxis");
+        QTest::addColumn<double>("maxXAxis");
+
+        // Expected results
+        QTest::addColumn<bool>(
+            "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
+        QTest::addColumn<double>("expectedMinValue");
+        QTest::addColumn<double>("expectedMaxValue");
+    }
+
+    template <typename T>
+    void testValuesBounds()
+    {
+        QFETCH(std::shared_ptr<T>, dataSeries);
+        QFETCH(double, minXAxis);
+        QFETCH(double, maxXAxis);
+
+        QFETCH(bool, expectedOK);
+        QFETCH(double, expectedMinValue);
+        QFETCH(double, expectedMaxValue);
+
+        auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
+        auto end = dataSeries->cend();
+
+        // Checks iterators with expected result
+        QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
+
+        if (expectedOK) {
+            auto compare = [](const auto &v1, const auto &v2) {
+                return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
+            };
+
+            QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
+            QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
+        }
+    }
+
+    template <typename T>
+    void testPurgeStructure()
+    {
+        // ////////////// //
+        // Test structure //
+        // ////////////// //
+
+        // Data series to purge
+        QTest::addColumn<std::shared_ptr<T> >("dataSeries");
+        QTest::addColumn<double>("min");
+        QTest::addColumn<double>("max");
+
+        // Expected values after purge
+        QTest::addColumn<DataContainer>("expectedXAxisData");
+        QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
+    }
+
+    template <typename T>
+    void testPurge()
+    {
+        QFETCH(std::shared_ptr<T>, dataSeries);
+        QFETCH(double, min);
+        QFETCH(double, max);
+
+        dataSeries->purge(min, max);
+
+        // Validates results
+        QFETCH(DataContainer, expectedXAxisData);
+        QFETCH(std::vector<DataContainer>, expectedValuesData);
+
+        validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
+                      expectedValuesData);
+    }
+
+private slots:
+
+    /// Input test data
+    /// @sa testCtor()
+    void testCtor_data();
+
+    /// Tests construction of a data series
+    void testCtor();
+
+    /// Input test data
+    /// @sa testMerge()
+    void testMerge_data();
+
+    /// Tests merge of two data series
+    void testMerge();
+
+    /// Input test data
+    /// @sa testPurgeScalar()
+    void testPurgeScalar_data();
+
+    /// Tests purge of a scalar series
+    void testPurgeScalar();
+
+    /// Input test data
+    /// @sa testPurgeVector()
+    void testPurgeVector_data();
+
+    /// Tests purge of a vector series
+    void testPurgeVector();
+
+    /// Input test data
+    /// @sa testMinXAxisData()
+    void testMinXAxisData_data();
+
+    /// Tests get min x-axis data of a data series
+    void testMinXAxisData();
+
+    /// Input test data
+    /// @sa testMaxXAxisData()
+    void testMaxXAxisData_data();
+
+    /// Tests get max x-axis data of a data series
+    void testMaxXAxisData();
+
+    /// Input test data
+    /// @sa testXAxisRange()
+    void testXAxisRange_data();
+
+    /// Tests get x-axis range of a data series
+    void testXAxisRange();
+
+    /// Input test data
+    /// @sa testValuesBoundsScalar()
+    void testValuesBoundsScalar_data();
+
+    /// Tests get values bounds of a scalar series
+    void testValuesBoundsScalar();
+
+    /// Input test data
+    /// @sa testValuesBoundsVector()
+    void testValuesBoundsVector_data();
+
+    /// Tests get values bounds of a vector series
+    void testValuesBoundsVector();
+};
+
+void TestDataSeries::testCtor_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // x-axis data
+    QTest::addColumn<DataContainer>("xAxisData");
+    // values data
+    QTest::addColumn<DataContainer>("valuesData");
+
+    // expected x-axis data
+    QTest::addColumn<DataContainer>("expectedXAxisData");
+    // expected values data
+    QTest::addColumn<DataContainer>("expectedValuesData");
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("invalidData (different sizes of vectors)")
+        << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
+        << DataContainer{};
+
+    QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
+                                << DataContainer{100., 200., 300., 400., 500.}
+                                << DataContainer{1., 2., 3., 4., 5.}
+                                << DataContainer{100., 200., 300., 400., 500.};
+
+    QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
+                                  << DataContainer{100., 200., 300., 400., 500.}
+                                  << DataContainer{1., 2., 3., 4., 5.}
+                                  << DataContainer{500., 400., 300., 200., 100.};
+
+    QTest::newRow("unsortedData2")
+        << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
+        << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
+}
+
+void TestDataSeries::testCtor()
+{
+    // Creates series
+    QFETCH(DataContainer, xAxisData);
+    QFETCH(DataContainer, valuesData);
+
+    auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
+                                                 Unit{}, Unit{});
+
+    // Validates results : we check that the data series is sorted on its x-axis data
+    QFETCH(DataContainer, expectedXAxisData);
+    QFETCH(DataContainer, expectedValuesData);
+
+    validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
+}
+
+namespace {
+
+std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
+{
+    return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
+                                          Unit{});
+}
+
+std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
+                                                 DataContainer yValuesData,
+                                                 DataContainer zValuesData)
+{
+    return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
+                                          std::move(yValuesData), std::move(zValuesData), Unit{},
+                                          Unit{});
+}
+
+} // namespace
+
+void TestDataSeries::testMerge_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // Data series to merge
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
+
+    // Expected values in the first data series after merge
+    QTest::addColumn<DataContainer>("expectedXAxisData");
+    QTest::addColumn<DataContainer>("expectedValuesData");
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("sortedMerge")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+        << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
+        << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
+        << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
+
+    QTest::newRow("unsortedMerge")
+        << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
+        << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+        << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
+        << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
+
+    QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
+        << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
+        << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
+        << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
+
+    QTest::newRow("unsortedMerge3")
+        << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
+        << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
+        << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
+        << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
+}
+
+void TestDataSeries::testMerge()
+{
+    // Merges series
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
+
+    dataSeries->merge(dataSeries2.get());
+
+    // Validates results : we check that the merge is valid and the data series is sorted on its
+    // x-axis data
+    QFETCH(DataContainer, expectedXAxisData);
+    QFETCH(DataContainer, expectedValuesData);
+
+    validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
+}
+
+void TestDataSeries::testPurgeScalar_data()
+{
+    testPurgeStructure<ScalarSeries>();
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 2. << 4. << DataContainer{2., 3., 4.}
+                                 << std::vector<DataContainer>{{200., 300., 400.}};
+    QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                        {100., 200., 300., 400., 500.})
+                                  << 0. << 2.5 << DataContainer{1., 2.}
+                                  << std::vector<DataContainer>{{100., 200.}};
+    QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                        {100., 200., 300., 400., 500.})
+                                  << 3.5 << 7. << DataContainer{4., 5.}
+                                  << std::vector<DataContainer>{{400., 500.}};
+    QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                        {100., 200., 300., 400., 500.})
+                                  << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
+                                  << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
+    QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                        {100., 200., 300., 400., 500.})
+                                  << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
+}
+
+void TestDataSeries::testPurgeScalar()
+{
+    testPurge<ScalarSeries>();
+}
+
+void TestDataSeries::testPurgeVector_data()
+{
+    testPurgeStructure<VectorSeries>();
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
+                                                       {11., 12., 13., 14., 15.},
+                                                       {16., 17., 18., 19., 20.})
+                                 << 2. << 4. << DataContainer{2., 3., 4.}
+                                 << std::vector<DataContainer>{
+                                        {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
+}
+
+void TestDataSeries::testPurgeVector()
+{
+    testPurge<VectorSeries>();
+}
+
+void TestDataSeries::testMinXAxisData_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // Data series to get min data
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
+
+    // Min data
+    QTest::addColumn<double>("min");
+
+    // Expected results
+    QTest::addColumn<bool>(
+        "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
+    QTest::addColumn<double>(
+        "expectedMin"); // Expected value when method doesn't return end iterator
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 0. << true << 1.;
+    QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 1. << true << 1.;
+    QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 1.1 << true << 2.;
+    QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 5. << true << 5.;
+    QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
+    QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
+                              << std::numeric_limits<double>::quiet_NaN();
+}
+
+void TestDataSeries::testMinXAxisData()
+{
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
+    QFETCH(double, min);
+
+    QFETCH(bool, expectedOK);
+    QFETCH(double, expectedMin);
+
+    auto it = dataSeries->minXAxisData(min);
+
+    QCOMPARE(expectedOK, it != dataSeries->cend());
+
+    // If the method doesn't return a end iterator, checks with expected value
+    if (expectedOK) {
+        QCOMPARE(expectedMin, it->x());
+    }
+}
+
+void TestDataSeries::testMaxXAxisData_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // Data series to get max data
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
+
+    // Max data
+    QTest::addColumn<double>("max");
+
+    // Expected results
+    QTest::addColumn<bool>(
+        "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
+    QTest::addColumn<double>(
+        "expectedMax"); // Expected value when method doesn't return end iterator
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 6. << true << 5.;
+    QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 5. << true << 5.;
+    QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 4.9 << true << 4.;
+    QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 1.1 << true << 1.;
+    QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                    {100., 200., 300., 400., 500.})
+                              << 1. << true << 1.;
+    QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
+                              << std::numeric_limits<double>::quiet_NaN();
+}
+
+void TestDataSeries::testMaxXAxisData()
+{
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
+    QFETCH(double, max);
+
+    QFETCH(bool, expectedOK);
+    QFETCH(double, expectedMax);
+
+    auto it = dataSeries->maxXAxisData(max);
+
+    QCOMPARE(expectedOK, it != dataSeries->cend());
+
+    // If the method doesn't return a end iterator, checks with expected value
+    if (expectedOK) {
+        QCOMPARE(expectedMax, it->x());
+    }
+}
+
+void TestDataSeries::testXAxisRange_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // Data series to get x-axis range
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
+
+    // Min/max values
+    QTest::addColumn<double>("min");
+    QTest::addColumn<double>("max");
+
+    // Expected values
+    QTest::addColumn<DataContainer>("expectedXAxisData");
+    QTest::addColumn<DataContainer>("expectedValuesData");
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << -1. << 3.2 << DataContainer{1., 2., 3.}
+                                 << DataContainer{100., 200., 300.};
+    QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 1. << 4. << DataContainer{1., 2., 3., 4.}
+                                 << DataContainer{100., 200., 300., 400.};
+    QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 1. << 3.9 << DataContainer{1., 2., 3.}
+                                 << DataContainer{100., 200., 300.};
+    QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 0. << 0.9 << DataContainer{} << DataContainer{};
+    QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
+    QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 2.1 << 6. << DataContainer{3., 4., 5.}
+                                 << DataContainer{300., 400., 500.};
+    QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 6. << 9. << DataContainer{} << DataContainer{};
+    QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                       {100., 200., 300., 400., 500.})
+                                 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
+}
+
+void TestDataSeries::testXAxisRange()
+{
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
+    QFETCH(double, min);
+    QFETCH(double, max);
+
+    QFETCH(DataContainer, expectedXAxisData);
+    QFETCH(DataContainer, expectedValuesData);
+
+    auto bounds = dataSeries->xAxisRange(min, max);
+    validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
+}
+
+void TestDataSeries::testValuesBoundsScalar_data()
+{
+    testValuesBoundsStructure<ScalarSeries>();
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+    auto nan = std::numeric_limits<double>::quiet_NaN();
+
+    QTest::newRow("scalarBounds1")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
+        << true << 100. << 500.;
+    QTest::newRow("scalarBounds2")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
+        << true << 200. << 400.;
+    QTest::newRow("scalarBounds3")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
+        << false << nan << nan;
+    QTest::newRow("scalarBounds4")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
+        << false << nan << nan;
+    QTest::newRow("scalarBounds5") << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100.
+                                   << 100.;
+    QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
+
+    // Tests with NaN values: NaN values are not included in min/max search
+    QTest::newRow("scalarBounds7")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
+        << true << 200. << 400.;
+    QTest::newRow("scalarBounds8")
+        << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
+        << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
+}
+
+void TestDataSeries::testValuesBoundsScalar()
+{
+    testValuesBounds<ScalarSeries>();
+}
+
+void TestDataSeries::testValuesBoundsVector_data()
+{
+    testValuesBoundsStructure<VectorSeries>();
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+    auto nan = std::numeric_limits<double>::quiet_NaN();
+
+    QTest::newRow("vectorBounds1")
+        << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
+                              {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
+        << 0. << 6. << true << 0.3 << 35.; // min/max in same component
+    QTest::newRow("vectorBounds2")
+        << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
+                              {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
+        << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
+    QTest::newRow("vectorBounds3")
+        << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
+                              {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
+        << 2. << 3. << true << 10. << 24.;
+
+    // Tests with NaN values: NaN values are not included in min/max search
+    QTest::newRow("vectorBounds4")
+        << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
+        << nan << nan;
+}
+
+void TestDataSeries::testValuesBoundsVector()
+{
+    testValuesBounds<VectorSeries>();
+}
+
+QTEST_MAIN(TestDataSeries)
+#include "TestDataSeries.moc"
diff --git a/gui/src/Visualization/VisualizationGraphWidget.cpp b/gui/src/Visualization/VisualizationGraphWidget.cpp
index fc99f91..62ab281 100644
--- a/gui/src/Visualization/VisualizationGraphWidget.cpp
+++ b/gui/src/Visualization/VisualizationGraphWidget.cpp
@@ -267,9 +267,9 @@ void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
 
 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
 {
-    qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                                            << QThread::currentThread()->objectName() << "DoAcqui"
-                                            << impl->m_DoAcquisition;
+    qCDebug(LOG_VisualizationGraphWidget())
+        << tr("TORM: VisualizationGraphWidget::onRangeChanged")
+        << QThread::currentThread()->objectName() << "DoAcqui" << impl->m_DoAcquisition;
 
     auto graphRange = SqpRange{t1.lower, t1.upper};
     auto oldGraphRange = SqpRange{t2.lower, t2.upper};
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index aacba29..0c646bb 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -127,10 +127,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         graphChildRange.m_TStart += deltaLeft;
                         graphChildRange.m_TEnd -= deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaLeft") << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaRight") << deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
 
@@ -141,10 +141,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                               << deltaLeft;
-                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaLeft") << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget())
+                            << tr("TORM: deltaRight") << deltaRight;
                         qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         graphChildRange.m_TStart -= deltaLeft;
@@ -179,10 +179,10 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         break;
                 }
                 graphChild->enableAcquisition(false);
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                       << graphChild->graphRange();
-                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                       << graphChildRange;
+                qCDebug(LOG_VisualizationZoneWidget())
+                    << tr("TORM: Range before: ") << graphChild->graphRange();
+                qCDebug(LOG_VisualizationZoneWidget())
+                    << tr("TORM: Range after : ") << graphChildRange;
                 qCDebug(LOG_VisualizationZoneWidget())
                     << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                 graphChild->setGraphRange(graphChildRange);
diff --git a/plugins/amda/tests/TestAmdaParser.cpp b/plugins/amda/tests/TestAmdaParser.cpp
index d2779a2..e2023f9 100644
--- a/plugins/amda/tests/TestAmdaParser.cpp
+++ b/plugins/amda/tests/TestAmdaParser.cpp
@@ -142,14 +142,14 @@ void TestAmdaParser::testReadJson_data()
     QTest::newRow("Valid file") << QStringLiteral("ValidFile1.json") << validResults1();
 
     // Invalid files
-    QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.json")
-                                                    << invalidResults();
-    QTest::newRow("Invalid file (two root objects)") << QStringLiteral("TwoRootsFile.json")
-                                                     << invalidResults();
-    QTest::newRow("Invalid file (wrong root key)") << QStringLiteral("WrongRootKey.json")
-                                                   << invalidResults();
-    QTest::newRow("Invalid file (wrong root type)") << QStringLiteral("WrongRootType.json")
-                                                    << invalidResults();
+    QTest::newRow("Invalid file (unexisting file)")
+        << QStringLiteral("UnexistingFile.json") << invalidResults();
+    QTest::newRow("Invalid file (two root objects)")
+        << QStringLiteral("TwoRootsFile.json") << invalidResults();
+    QTest::newRow("Invalid file (wrong root key)")
+        << QStringLiteral("WrongRootKey.json") << invalidResults();
+    QTest::newRow("Invalid file (wrong root type)")
+        << QStringLiteral("WrongRootType.json") << invalidResults();
 }
 
 void TestAmdaParser::testReadJson()
diff --git a/plugins/amda/tests/TestAmdaResultParser.cpp b/plugins/amda/tests/TestAmdaResultParser.cpp
index 70a840f..be6616b 100644
--- a/plugins/amda/tests/TestAmdaResultParser.cpp
+++ b/plugins/amda/tests/TestAmdaResultParser.cpp
@@ -229,11 +229,11 @@ void TestAmdaResultParser::testReadScalarTxt_data()
                                          QVector<QDateTime>{}, QVector<double>{}};
 
     // Invalid files
-    QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
-                                                    << ExpectedResults<ScalarSeries>{};
+    QTest::newRow("Invalid file (unexisting file)")
+        << QStringLiteral("UnexistingFile.txt") << ExpectedResults<ScalarSeries>{};
 
-    QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
-                                                             << ExpectedResults<ScalarSeries>{};
+    QTest::newRow("Invalid file (file not found on server)")
+        << QStringLiteral("FileNotFound.txt") << ExpectedResults<ScalarSeries>{};
 }
 
 void TestAmdaResultParser::testReadScalarTxt()
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index 6ba687f..d8abeed 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -24,7 +24,7 @@ std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
     auto dataIndex = 0;
 
     // Gets the timerange from the parameters
-    double freq = 100.0;
+    double freq = 1.0;
     double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
     double end = std::floor(dataRangeRequested.m_TEnd * freq);    // 100 htz
 
@@ -79,8 +79,8 @@ void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
 {
     // TODO: Add Mutex
     m_VariableToEnableProvider[acqIdentifier] = true;
-    qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
-                                   << QThread::currentThread()->objectName();
+    qCDebug(LOG_CosinusProvider())
+        << "TORM: CosinusProvider::requestDataLoading" << QThread::currentThread()->objectName();
     // NOTE: Try to use multithread if possible
     const auto times = parameters.m_Times;