GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r513:4e7b3226237d

The dataSeries of a variable is now shared istead of uniq to avoid...

perrinel -

r513:4e7b3226237d

parent child

Context file:

r513:4e7b3226237d

core/src/Variable/Variable.cpp +8 -8

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpRange.h>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
                                          const QVariantHash &metadata)
                         : m_Name{name}, m_Range{dateTime}, m_Metadata{metadata}, m_DataSeries{nullptr}
                 {
                 }
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 QString m_Name;
                 SqpRange m_Range;
                 SqpRange m_CacheRange;
                 QVariantHash m_Metadata;
-                std::unique_ptr<IDataSeries> m_DataSeries;
+                std::shared_ptr<IDataSeries> m_DataSeries;
                 QReadWriteLock m_Lock;
             };
             Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
             {
             }
             QString Variable::name() const noexcept
             {
                 impl->lockRead();
                 auto name = impl->m_Name;
                 impl->unlock();
                 return name;
             }
             SqpRange Variable::range() const noexcept
             {
                 impl->lockRead();
                 auto range = impl->m_Range;
                 impl->unlock();
                 return range;
             }
             void Variable::setRange(const SqpRange &range) noexcept
             {
                 impl->lockWrite();
                 impl->m_Range = range;
                 impl->unlock();
             }
             SqpRange Variable::cacheRange() const noexcept
             {
                 impl->lockRead();
                 auto cacheRange = impl->m_CacheRange;
                 impl->unlock();
                 return cacheRange;
             }
             void Variable::setCacheRange(const SqpRange &cacheRange) noexcept
             {
                 impl->lockWrite();
                 impl->m_CacheRange = cacheRange;
                 impl->unlock();
             }
             void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                qCInfo(LOG_Variable()) << "Variable::setDataSeries" << QThread::currentThread()->objectName();
+                qCDebug(LOG_Variable()) << "TORM Variable::setDataSeries"
+                                        << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 impl->lockWrite();
                 impl->m_DataSeries = dataSeries->clone();
                 impl->unlock();
             }
             void Variable::mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                qCDebug(LOG_Variable()) << "Variable::mergeDataSeries"
+                qCDebug(LOG_Variable()) << "TORM Variable::mergeDataSeries"
                                         << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                 }
                 // Add or merge the data
                 // Inits the data series of the variable
                 impl->lockWrite();
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = dataSeries->clone();
                 }
                 else {
                     impl->m_DataSeries->merge(dataSeries.get());
                 }
                 impl->unlock();
                 // sub the data
                 auto subData = this->dataSeries()->subData(this->cacheRange());
-                qCCritical(LOG_Variable()) << "TORM: Variable::mergeDataSeries sub" << subData->range();
+                qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries sub" << subData->range();
                 this->setDataSeries(subData);
-                qCCritical(LOG_Variable()) << "TORM: Variable::mergeDataSeries set"
+                qCDebug(LOG_Variable()) << "TORM: Variable::mergeDataSeries set" << this->dataSeries()->range();
-                                           << this->dataSeries()->range();
             }
-            IDataSeries *Variable::dataSeries() const noexcept
+            std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
             {
                 impl->lockRead();
-                auto dataSeries = impl->m_DataSeries.get();
+                auto dataSeries = impl->m_DataSeries;
                 impl->unlock();
                 return dataSeries;
             }
             QVariantHash Variable::metadata() const noexcept
             {
                 impl->lockRead();
                 auto metadata = impl->m_Metadata;
                 impl->unlock();
                 return metadata;
             }
             bool Variable::contains(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::intersect(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_Range.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::isInside(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(SqpRange{impl->m_Range.m_TStart, impl->m_Range.m_TEnd});
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheContains(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.contains(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIntersect(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = impl->m_CacheRange.intersect(range);
                 impl->unlock();
                 return res;
             }
             bool Variable::cacheIsInside(const SqpRange &range) const noexcept
             {
                 impl->lockRead();
                 auto res = range.contains(SqpRange{impl->m_CacheRange.m_TStart, impl->m_CacheRange.m_TEnd});
                 impl->unlock();
                 return res;
             }
             QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
             {
                 auto notInCache = QVector<SqpRange>{};
                 if (!this->cacheContains(range)) {
                     if (range.m_TEnd <= impl->m_CacheRange.m_TStart
                         || range.m_TStart >= impl->m_CacheRange.m_TEnd) {
                         notInCache << range;
                     }
                     else if (range.m_TStart < impl->m_CacheRange.m_TStart
                              && range.m_TEnd <= impl->m_CacheRange.m_TEnd) {
                         notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart};
                     }
                     else if (range.m_TStart < impl->m_CacheRange.m_TStart
                              && range.m_TEnd > impl->m_CacheRange.m_TEnd) {
                         notInCache << SqpRange{range.m_TStart, impl->m_CacheRange.m_TStart}
                                    << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                     }
                     else if (range.m_TStart < impl->m_CacheRange.m_TEnd) {
                         notInCache << SqpRange{impl->m_CacheRange.m_TEnd, range.m_TEnd};
                     }
                     else {
                         qCCritical(LOG_Variable()) << tr("Detection of unknown case.")
                                                    << QThread::currentThread();
                     }
                 }
                 return notInCache;
             }

core/src/Variable/VariableAcquisitionWorker.cpp +2 -2

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

core/src/Variable/VariableController.cpp +9 -9

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheController.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 <Time/TimeController.h>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &grapheRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(grapheRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = grapheRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - grapheRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
                         auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaRight;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - grapheRange.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_VariableCacheController{std::make_unique<VariableCacheController>()},
                           m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()}
                 {
                     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);
                 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);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 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;
             };
             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;
             }
             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));
                 // Clears cache
                 impl->m_VariableCacheController->clear(variable);
                 // 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)
             {
             }
             void 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;
                 }
                 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;
                     impl->processRequest(newVariable, range);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // TODO check synchronisation
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setRange(dateTime);
                         impl->processRequest(selectedVariable, dateTime);
                         // notify that rescale operation has to be done
                         emit rangeChanged(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 auto var = impl->findVariable(vIdentifier);
                 if (var != nullptr) {
                     var->setRange(rangeRequested);
                     var->setCacheRange(cacheRangeRequested);
                     qCDebug(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
                     qCDebug(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
                     auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                     qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
                                                       << retrievedDataSeries->range();
                     var->mergeDataSeries(retrievedDataSeries);
+                    qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
                     emit var->updated();
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to provide data to a null variable");
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 auto var = impl->findVariable(identifier);
                 if (var != nullptr) {
                     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 vToVIdit = impl->m_VariableToIdentifierMap.find(variable);
                 if (vToVIdit != impl->m_VariableToIdentifierMap.cend()) {
                     auto itSynchroGroup
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (itSynchroGroup != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(vToVIdit->second, synchronizationGroupId));
                         itSynchroGroup->second->addVariableId(vToVIdit->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().
-                qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
-                                                  << QThread::currentThread()->objectName();
+                                                 << QThread::currentThread()->objectName();
                 // 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.
                 foreach (auto var, variables) {
                     qCDebug(LOG_VariableController()) << "processRequest for" << var->name();
                     impl->processRequest(var, range);
                 }
                 if (synchronise) {
                     // Get the group ids
                     qCDebug(LOG_VariableController())
                         << "VariableController::onRequestDataLoading for synchro var ENABLE";
                     auto groupIds = std::set<QUuid>();
                     foreach (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;
                                 if (groupIds.find(gId) == groupIds.cend()) {
                                     qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
                                     groupIds.insert(gId);
                                 }
                             }
                         }
                     }
                     // We assume here all group ids exist
                     foreach (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, oldRange);
                                     impl->processRequest(var, vSyncRangeRequested);
                                 }
                                 else {
                                     qCCritical(LOG_VariableController())
                                         << tr("Impossible to synchronize a null variable");
                                 }
                             }
                         }
                     }
                 }
             }
             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)
             {
                 auto varRangesRequested
                     = m_VariableCacheStrategy->computeCacheRange(var->range(), rangeRequested);
                 auto notInCacheRangeList = var->provideNotInCacheRangeList(varRangesRequested.second);
                 if (!notInCacheRangeList.empty()) {
-                    // Display part of data which are already there
-                    // Ask the provider for each data on the dateTimeListNotInCache
                     auto identifier = m_VariableToIdentifierMap.at(var);
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         m_VariableAcquisitionWorker->pushVariableRequest(
                             identifier, varRangesRequested.first, varRangesRequested.second,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                 }
                 else {
                     var->setRange(rangeRequested);
                     var->setCacheRange(varRangesRequested.second);
                     var->setDataSeries(var->dataSeries()->subData(varRangesRequested.second));
                     emit var->updated();
                 }
             }
             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)
             {
-                qCInfo(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
+                qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
-                                                 << 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()) {
-                    qCInfo(LOG_VariableController()) << tr("Registering of a new provider")
+                    qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
-                                                     << provider->objectName();
+                                                      << 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 ");
                 }
             }

gui/include/Visualization/VisualizationGraphHelper.h +2 -2

             #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QVector>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
             class IDataSeries;
             class QCPAbstractPlottable;
             class QCustomPlot;
             class Variable;
             /**
              * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
              * variable, depending on the data series of this variable
              */
             struct VisualizationGraphHelper {
                 /**
                  * Creates (if possible) the QCustomPlot components relative to the variable passed in
                  * parameter, and adds these to the plot passed in parameter.
                  * @param variable the variable for which to create the components
                  * @param plot the plot in which to add the created components. It takes ownership of these
                  * components.
                  * @return the list of the components created
                  */
                 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
                                                               QCustomPlot &plot) noexcept;
-                static void updateData(QVector<QCPAbstractPlottable *> plotableVect, IDataSeries *dataSeries,
+                static void updateData(QVector<QCPAbstractPlottable *> plotableVect,
-                                       const SqpRange &dateTime);
+                                       std::shared_ptr<IDataSeries> dataSeries, const SqpRange &dateTime);
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H

gui/src/Visualization/VisualizationGraphHelper.cpp +18 -17

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
-            void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
+            void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries,
                                   const SqpRange &dateTime)
             {
                 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
                                                         << QThread::currentThread()->objectName();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
-                    scalarSeries.lockRead();
+                    scalarSeries->lockRead();
                     {
-                        const auto &xData = scalarSeries.xAxisData()->cdata();
+                        const auto &xData = scalarSeries->xAxisData()->cdata();
-                        const auto &valuesData = scalarSeries.valuesData()->cdata();
+                        const auto &valuesData = scalarSeries->valuesData()->cdata();
                         auto xDataBegin = xData.cbegin();
                         auto xDataEnd = xData.cend();
-                        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache"
+                        qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points in cache"
                                                                << xData.count();
                         auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
                         qcpGraph->setData(sqpDataContainer);
                         auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
                         auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
                         auto distance = std::distance(xDataBegin, lowerIt);
                         auto valuesDataIt = valuesData.cbegin() + distance;
                         for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
                              ++xAxisDataIt, ++valuesDataIt) {
                             sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
                         }
-                        qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
+                        qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed"
                                                                << sqpDataContainer->size();
                     }
-                    scalarSeries.unlock();
+                    scalarSeries->unlock();
                     // Display all data
                     component->parentPlot()->replot();
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
-            QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
+            QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries,
-                                                              const SqpRange &dateTime)
+                                                              QCustomPlot &plot, const SqpRange &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // Graph data
-                    component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
+                    component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(),
                                        true);
                     updateScalarData(component, scalarSeries, dateTime);
                     // Axes properties
                     /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                     /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                     auto setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
-                    setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
+                    setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
-                    setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
+                    setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                                              QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
-                    if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
+                    if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
-                        result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->range()));
+                        result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range()));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
-                                                      IDataSeries *dataSeries, const SqpRange &dateTime)
+                                                      std::shared_ptr<IDataSeries> dataSeries,
+                                                      const SqpRange &dateTime)
             {
-                if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
+                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     if (plotableVect.size() == 1) {
-                        updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
+                        updateScalarData(plotableVect.at(0), scalarSeries, dateTime);
                     }
                     else {
                         qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
                             "Can't update Data of a scalarSeries because there is not only one component "
                             "associated");
                     }
                 }
                 else {
                     /// @todo DEBUG
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +1 -1

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate()
                         : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
                 {
                 }
                 // 1 variable -> n qcpplot
                 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 auto calibrationState = impl->m_IsCalibration;
                 impl->m_IsCalibration = true;
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_IsCalibration = calibrationState;
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 this->addVariable(variable);
                 // Request range for the variable
                 auto graphRange = ui->widget->xAxis->range();
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable,
                                         SqpRange{graphRange.lower, graphRange.upper}, variable->range(), false);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 for (auto it = componentsIt.first; it != componentsIt.second;) {
                     ui->widget->removePlottable(it->second);
                     it = impl->m_VariableToPlotMultiMap.erase(it);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
             {
                 // Note: in case of different axes that depends on variable, we could start with a code like
                 // that:
                 //    auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 //    for (auto it = componentsIt.first; it != componentsIt.second;) {
                 //    }
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto grapheRange = ui->widget->xAxis->range();
                 return SqpRange{grapheRange.lower, grapheRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return ui->graphNameLabel->text();
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(mapToGlobal(pos));
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 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};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
-                        qCInfo(LOG_VisualizationGraphWidget())
+                        qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 // NOTE:
                 //    We don't want to call the method for each component of a variable unitarily, but for
                 //    all
                 //    its components at once (eg its three components in the case of a vector).
                 //    The unordered_multimap does not do this easily, so the question is whether to:
                 //    - use an ordered_multimap and the algos of std to group the values by key
                 //    - use a map (unique keys) and store as values directly the list of components
                 auto grapheRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                              variable->dataSeries(), variable->range());
                     }
                 }
             }

plugins/mockplugin/src/CosinusProvider.cpp +1 0

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
                                                                        const SqpRange &dataRangeRequested)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
                 double freq = 100.0;
                 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);    // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto dataCount = end - start;
                 auto xAxisData = QVector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = QVector<double>{};
                 valuesData.resize(dataCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
                         xAxisData.replace(dataIndex, timeOnFreq);
                         valuesData.replace(dataIndex, std::cos(timeOnFreq));
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 emit dataProvidedProgress(acqIdentifier, 0.0);
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }
             void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
                                                      const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[acqIdentifier]) {
                         auto scalarSeries = this->retrieveData(acqIdentifier, dateTime);
+                        qCCritical(LOG_CosinusProvider()) << "CosinusProvider::dataProvided";
                         emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 // TODO: Add Mutex
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCWarning(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }

General Comments 1

perrinel

|

Auto status change to "Under Review"

Write
Preview

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

No TODOs yet

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

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